Mapping composite user types with multiple columns now working. Resolves issues 129 and 365.

Author: James Freiwirth

src/FluentNHibernate.Testing/AutoMapping/Apm/AutoPersistenceModelTests.cs

@@ -508,6 +508,20 @@ public void TypeConventionShouldForcePropertyToBeMapped()
                 .Element("class/property").HasAttribute("name", "Custom");
         }
 
+        [Test]
+        public void TypeConventionShouldForceCompositePropertyToBeMappedWithCorrectNumberOfColumns()
+        {
+            var autoMapper = AutoMap.AssemblyOf<ClassWithCompositeUserType>()
+                .Conventions.Add<CustomCompositeTypeConvention>()
+                .Where(t => t.Namespace == "FluentNHibernate.Automapping.TestFixtures" && t != typeof(DoubleString));
+
+            var mappedColumns = new
+            AutoMappingTester<ClassWithCompositeUserType>(autoMapper)
+                .Element("class/property");
+
+            mappedColumns.HasThisManyChildNodes(2);
+        }
+
         [Test]
         public void ComponentTypesAutoMapped()
         {

src/FluentNHibernate.Testing/AutoMapping/TestFixtures.cs

@@ -6,6 +6,9 @@
 using FluentNHibernate.Automapping.TestFixtures.ComponentTypes;
 using FluentNHibernate.Automapping.TestFixtures.CustomCompositeTypes;
 using FluentNHibernate.Automapping.TestFixtures.CustomTypes;
+using FluentNHibernate.Conventions.AcceptanceCriteria;
+using FluentNHibernate.Conventions.Inspections;
+using FluentNHibernate.Conventions.Instances;
 using FluentNHibernate.Mapping;
 using FluentNHibernate.Conventions;
 using Iesi.Collections.Generic;
@@ -135,7 +138,7 @@ public class ClassWithUserType
     public class ClassWithCompositeUserType
     {
         public int Id { get; set; }
-        public DoubleStringType DoubleStringType { get; set; }
+        public DoubleString SomeStringTuple { get; set; }
     }
 
     public class Customer
@@ -189,9 +192,28 @@ public class Custom
 
     }
 
+    public class DoubleString
+    {
+        public string s1 { get; set; }
+        public string s2 { get; set; }
+    }
+
     public class CustomTypeConvention : UserTypeConvention<CustomUserType>
     {}
 
+    public class CustomCompositeTypeConvention : IUserTypeConvention
+    {
+        public void Accept(IAcceptanceCriteria<IPropertyInspector> criteria)
+        {
+           criteria.Expect(x => x.Type == typeof(DoubleString));
+        }
+
+        public void Apply(IPropertyInstance instance)
+        {
+            instance.CustomType<DoubleStringType>();
+        }
+    }
+
     public class CustomUserType : IUserType
     {
         public new bool Equals(object x, object y)
@@ -264,28 +286,29 @@ public System.Type ReturnedClass
         {
             if (x == y) return true;
             if (x == null || y == null) return false;
-            string[] lhs = (string[])x;
-            string[] rhs = (string[])y;
 
-            return lhs[0].Equals(rhs[0]) && lhs[1].Equals(rhs[1]);
+            DoubleString lhs = (DoubleString)x;
+            DoubleString rhs = (DoubleString)y;
+
+            return lhs.s1 == rhs.s1 && lhs.s2 == rhs.s2;
         }
 
         public int GetHashCode(object x)
         {
             unchecked
             {
-                string[] a = (string[])x;
-                return a[0].GetHashCode() + 31 * a[1].GetHashCode();
+                DoubleString a = (DoubleString)x;
+                return a.s1.GetHashCode() + 31 * a.s2.GetHashCode();
             }
         }
 
         public Object DeepCopy(Object x)
         {
             if (x == null) return null;
-            string[] result = new string[2];
-            string[] input = (string[])x;
-            result[0] = input[0];
-            result[1] = input[1];
+            DoubleString result = new DoubleString();
+            DoubleString input = (DoubleString)x;
+            result.s1 = input.s1;
+            result.s2 = input.s2;
             return result;
         }
 
@@ -305,10 +328,10 @@ public Object NullSafeGet(IDataReader rs, string[] names, ISessionImplementor se
 
         public void NullSafeSet(IDbCommand st, Object value, int index, ISessionImplementor session)
         {
-            string[] strings = (value == null) ? new string[2] : (string[])value;
+            DoubleString ds = value as DoubleString ?? new DoubleString();
 
-            NHibernateUtil.String.NullSafeSet(st, strings[0], index, session);
-            NHibernateUtil.String.NullSafeSet(st, strings[1], index + 1, session);
+            NHibernateUtil.String.NullSafeSet(st, ds.s1, index, session);
+            NHibernateUtil.String.NullSafeSet(st, ds.s2, index + 1, session);
         }
 
         public string[] PropertyNames
@@ -352,103 +375,6 @@ public object Replace(object original, object target, ISessionImplementor sessio
             return DeepCopy(original);
         }
     }
-
-    /// <summary>
-    /// Extracted from the NHibernate.Model
-    /// </summary>
-    public class CustomCompositeUserType : ICompositeUserType
-    {
-        public System.Type ReturnedClass
-        {
-            get { return typeof(string[]); }
-        }
-
-        public new bool Equals(object x, object y)
-        {
-            if (x == y) return true;
-            if (x == null || y == null) return false;
-            string[] lhs = (string[])x;
-            string[] rhs = (string[])y;
-
-            return lhs[0].Equals(rhs[0]) && lhs[1].Equals(rhs[1]);
-        }
-
-        public int GetHashCode(object x)
-        {
-            unchecked
-            {
-                string[] a = (string[])x;
-                return a[0].GetHashCode() + 31 * a[1].GetHashCode();
-            }
-        }
-
-        public Object DeepCopy(Object x)
-        {
-            if (x == null) return null;
-            string[] result = new string[2];
-            string[] input = (string[])x;
-            result[0] = input[0];
-            result[1] = input[1];
-            return result;
-        }
-
-        public bool IsMutable
-        {
-            get { return true; }
-        }
-
-        public Object NullSafeGet(IDataReader rs, string[] names, ISessionImplementor session, Object owner)
-        {
-            string first = (string)NHibernateUtil.String.NullSafeGet(rs, names[0], session, owner);
-            string second = (string)NHibernateUtil.String.NullSafeGet(rs, names[1], session, owner);
-
-            return (first == null && second == null) ? null : new string[] { first, second };
-        }
-
-        public void NullSafeSet(IDbCommand st, Object value, int index, ISessionImplementor session)
-        {
-            string[] strings = (value == null) ? new string[2] : (string[])value;
-
-            NHibernateUtil.String.NullSafeSet(st, strings[0], index, session);
-            NHibernateUtil.String.NullSafeSet(st, strings[1], index + 1, session);
-        }
-
-        public string[] PropertyNames
-        {
-            get { return new string[] { "s1", "s2" }; }
-        }
-
-        public IType[] PropertyTypes
-        {
-            get { return new IType[] { NHibernateUtil.String, NHibernateUtil.String }; }
-        }
-
-        public Object GetPropertyValue(Object component, int property)
-        {
-            return ((string[])component)[property];
-        }
-
-        public void SetPropertyValue(Object component, int property, Object value)
-        {
-            ((string[])component)[property] = (string)value;
-        }
-
-        public object Assemble(object cached, ISessionImplementor session, object owner)
-        {
-            return DeepCopy(cached);
-        }
-
-        public object Disassemble(Object value, ISessionImplementor session)
-        {
-            return DeepCopy(value);
-        }
-
-        public object Replace(object original, object target, ISessionImplementor session, object owner)
-        {
-            return DeepCopy(original);
-        }
-    }
-
 }
 
 namespace FluentNHibernate.Automapping.TestFixtures.SuperTypes

src/FluentNHibernate/Conventions/Instances/PropertyInstance.cs

@@ -3,6 +3,8 @@
 using System.Linq;
 using FluentNHibernate.Conventions.Inspections;
 using FluentNHibernate.MappingModel;
+using NHibernate.Type;
+using NHibernate.UserTypes;
 
 namespace FluentNHibernate.Conventions.Instances
 {
@@ -59,28 +61,30 @@ public PropertyInstance(PropertyMapping mapping)
             }
         }
 
-        public void CustomType<T>()
+        public void CustomType(TypeReference type)
         {
             if (!mapping.IsSpecified("Type"))
-                mapping.Type = new TypeReference(typeof(T));
+            {
+                mapping.Type = type;
+
+                if (typeof(ICompositeUserType).IsAssignableFrom(mapping.Type.GetUnderlyingSystemType()))
+                    AddColumnsForCompositeUserType();
+            }
         }
 
-        public void CustomType(TypeReference type)
+        public void CustomType<T>()
         {
-            if (!mapping.IsSpecified("Type"))
-                mapping.Type = type;
+            CustomType(typeof(T));
         }
 
         public void CustomType(Type type)
         {
-            if (!mapping.IsSpecified("Type"))
-                mapping.Type = new TypeReference(type);
+            CustomType(new TypeReference(type));
         }
 
         public void CustomType(string type)
         {
-            if (!mapping.IsSpecified("Type"))
-                mapping.Type = new TypeReference(type);
+            CustomType(new TypeReference(type));
         }
 
         public void CustomSqlType(string sqlType)
@@ -210,5 +214,26 @@ public void Column(string columnName)
             foreach (var column in mapping.Columns)
                 column.Index = value;
         }
+
+        private void AddColumnsForCompositeUserType()
+        {
+            var inst = (ICompositeUserType)Activator.CreateInstance(mapping.Type.GetUnderlyingSystemType());
+
+            if (inst.PropertyNames.Length > 1)
+            {
+                var existingColumn = mapping.Columns.Single();
+                mapping.ClearColumns();
+                var propertyPrefix = existingColumn.Name;
+                for (int i = 0; i < inst.PropertyNames.Length; i++)
+                {
+                    var propertyName = inst.PropertyNames[i];
+                    var propertyType = inst.PropertyTypes[i];
+
+                    var column = ColumnMapping.BaseOn(existingColumn);
+                    column.Name = propertyPrefix + "_" + propertyName;
+                    mapping.AddColumn(column);
+                }
+            }
+        }
     }
 }