CODEWITHSUNDEEP
c#nhibernatefluent-nhibernatequeryoveriusertype
John Long
John Long

Reputation: 133

NHibernate QueryOver with IUserType fails

I have a custom user type with NHibernate and the custom type works fine for saving and updating. However an error occurs when using QueryOver on this custom user type. I get the error message: could not resolve property: SpecialType.Code of: NHibernateComplexIUserTypeExample.Person.

I know that I can map the SpecialType class using Component() instead of Map() with a custom type, but there are other considerations outside of this example that make that inappropriate. If possible I would like to resolve this while keeping it as an IUserType.

Here is my sample code that can cause this error.

The error occurs in Program.cs on the line with the QueryOver<>.

Person.cs

public class Person
{
    public virtual int Id { get; protected set; }

    public virtual string Name { get; set; }

    public virtual SpecialType SpecialType { get; set; }

    public Person()
    {
    }
}

PersonMap.cs

public class PersonMap : ClassMap<Person>
{
    public PersonMap()
    {
        Id(x => x.Id);

        Map(x => x.Name).Not.Nullable();

        Map(x => x.SpecialType)
            .CustomType<SpecialTypeUserType>()
            .Not.Nullable()
            .Column("SpecialType_Code");
    }
}

Program.cs

class Program
{
    static void Main(string[] args)
    {
        // create db session
        var sessionFactory = Program.CreateSessionFactory();

        var session = sessionFactory.OpenSession();

        // query db using complex iusertype
        var results = session.QueryOver<Person>().Where(x => x.SpecialType.Code == "1").List();

        if (results != null)
        {
            foreach (var result in results)
            {
                Console.WriteLine("Person {0} has code {1}.", result.Name, result.SpecialType.Code);
            }
        }
    }

    public static ISessionFactory CreateSessionFactory()
    {
        return Fluently.Configure()
            .Database(
                MsSqlConfiguration
                .MsSql2008
                .ConnectionString("..."))
            .Mappings(
                m =>
                {
                    m.FluentMappings.AddFromAssemblyOf<Person>();
                })
            .BuildSessionFactory();
    }
}

SpecialTypeUserType.cs

public class SpecialTypeUserType : global::NHibernate.UserTypes.IUserType
{
    #region IUserType Members

    public object Assemble(object cached, object owner)
    {
        // used for caching, as our object is immutable we can just return it as is

        return cached;
    }

    public object DeepCopy(object value)
    {
        //? should we implement deep copy for this?

        return value;
    }

    public object Disassemble(object value)
    {
        // used for caching, as our object is immutable we can just return it as is

        return value;
    }

    public new bool Equals(object x, object y)
    {
        // implements equals itself so we use this implementation

        if (x == null)
        {
            return false;
        }
        else
        {
            return x.Equals(y);
        }
    }

    public int GetHashCode(object x)
    {
        if (x == null)
        {
            throw new ArgumentNullException("x");
        }

        // object itself implements GetHashCode so we use that

        return x.GetHashCode();
    }

    public bool IsMutable
    {
        get
        {
            return false;
        }
    }

    public object NullSafeGet(System.Data.IDataReader rs, string[] names, object owner)
    {
        if (names == null)
        {
            throw new ArgumentNullException("names");
        }

        // we get the string from the database using the NullSafeGet used to get strings 

        string codeString = (string)global::NHibernate.NHibernateUtil.String.NullSafeGet(rs, names[0]);

        SpecialType newSpecialType = new SpecialType(codeString, "Test...");

        return newSpecialType;
    }

    public void NullSafeSet(System.Data.IDbCommand cmd, object value, int index)
    {
        // set the value using the NullSafeSet implementation for string from NHibernateUtil

        if (value == null)
        {
            global::NHibernate.NHibernateUtil.String.NullSafeSet(cmd, null, index);

            return;
        }

        value = ((SpecialType)value).Code;

        global::NHibernate.NHibernateUtil.String.NullSafeSet(cmd, value, index);
    }

    public object Replace(object original, object target, object owner)
    {
        // as our object is immutable we can just return the original

        return original;
    }

    public Type ReturnedType
    {
        get
        {
            return typeof(SpecialType);
        }
    }

    public NHibernate.SqlTypes.SqlType[] SqlTypes
    {
        get
        {
            // we store our SpecialType.Code in a single column in the database that can contain a string

            global::NHibernate.SqlTypes.SqlType[] types = new global::NHibernate.SqlTypes.SqlType[1];

            types[0] = new global::NHibernate.SqlTypes.SqlType(System.Data.DbType.String);

            return types;
        }
    }

    #endregion
}

SpecialType.cs

public class SpecialType
{
    public string Code { get; private set; }

    public string Description { get; private set; }

    public SpecialType(string code, string description)
    {
        this.Code = code;
        this.Description = description;
    }

    public override bool Equals(object obj)
    {
        if (obj == null)
        {
            return false;
        }

        SpecialType type = obj as SpecialType;

        if (type == null)
        {
            return false;
        }

        if (object.ReferenceEquals(this, type))
        {
            return true;
        }

        if (type.Code == null && this.Code != null)
        {
            return false;
        }
        else if (type.Code != null && this.Code == null)
        {
            return false;
        }
        else if (type.Code != null && this.Code != null)
        {
            if (!type.Code.Equals(this.Code, StringComparison.OrdinalIgnoreCase))
            {
                return false;
            }
        }

        return true;
    }

    public override int GetHashCode()
    {
        return this.Code.GetHashCode();
    }
}

Database Table Definition

CREATE TABLE [dbo].[Person](
    [Id] [int] IDENTITY(1,1) NOT NULL,
    [Name] [nvarchar](255) NOT NULL,
    [SpecialType_Code] [nvarchar](255) NOT NULL,
PRIMARY KEY CLUSTERED 
(
    [Id] ASC
)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF,     ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]
) ON [PRIMARY]

Upvotes: 2

Views: 1023

Answers (1)

Andrew Whitaker
Andrew Whitaker

Reputation: 126042

A quick (possibly not ideal) solution:

var specialTypeToCompare = new SpecialType("1", "some_description");

var results = session.QueryOver<Person>()
    .Where(x => x.SpecialType.Code == specialTypeToCompare).List();

This is probably not ideal though, since you have to fill some fake value in for the description. NHibernate should generate the correct SQL though.

Another solution that's a little more involved is to modify NullSafeSet to allow strings and SpecialTypes to be handled by the custom type:

public void NullSafeSet(System.Data.IDbCommand cmd, object value, int index)
{
    // set the value using the NullSafeSet implementation for string from NHibernateUtil


    if (value == null)
    {
        global::NHibernate.NHibernateUtil.String.NullSafeSet(cmd, null, index);

        return;
    }

    /* Allow for the possibility of a string */
    string valueToSet = null;

    if (value.GetType() == typeof(string))
    {
        valueToSet = (string)value;
    }
    else if (value.GetType() == typeof(SpecialType))
    {
        valueToSet = ((SpecialType)value).Code;
    }

    global::NHibernate.NHibernateUtil.String.NullSafeSet(cmd, valueToSet, index);
}

And then modify your query to use Restrictions.Where, which is a little more verbose:

var results = session.QueryOver<Person>()
    .Where(
        Restrictions.Eq(
            Projections.Property<Person>(p => p.SpecialType), "1"))
    .List();

One way to clean the above up would be to implement an explicit operator for SpecialType that allows the cast from string to SpecialType:

public static explicit operator SpecialType(string s)
{
    return new SpecialType(s, null);
}

Now you can shorten your QueryOver code:

var results = session.QueryOver<Person>()
    .Where(p => p.SpecialType == (SpecialType)"1")
    .List();

However the huge downside to this is that people will be able to explicitly cast strings to SpecialTypes in your application--probably not something you want.

Upvotes: 2

Related Questions