Add support for case-insensitive references in POCO References support

Author: mythz

src/ServiceStack.OrmLite/OrmLiteConfig.cs

@@ -193,5 +193,7 @@ public static IOrmLiteExecFilter ExecFilter
         /// Only supported in Oracle DialectProvider
         /// </summary>
         public static bool UseParameterizeSqlExpressions { get; set; }
+
+        public static bool IsCaseInsensitive { get; set; }
     }
 }

src/ServiceStack.OrmLite/Support/LoadList.cs

@@ -113,9 +113,42 @@ protected string GetRefFieldSql(ModelDefinition refModelDef, FieldDefinition ref
             return sqlRef;
         }
 
+        protected Dictionary<object, object> CreateRefMap()
+        {
+            return OrmLiteConfig.IsCaseInsensitive
+                ? new Dictionary<object, object>(CaseInsensitiveObjectComparer.Instance)
+                : new Dictionary<object, object>(); 
+        }
+
+        public class CaseInsensitiveObjectComparer : IEqualityComparer<object>
+        {
+            public static CaseInsensitiveObjectComparer Instance = new CaseInsensitiveObjectComparer();
+
+            public bool Equals(object x, object y)
+            {
+                if (x == null && y == null) return true;
+                if (x == null || y == null) return false;
+
+                var xStr = x as string;
+                var yStr = y as string;
+
+                return xStr != null && yStr != null
+                    ? xStr.Equals(yStr, StringComparison.OrdinalIgnoreCase)
+                    : x.Equals(y);
+            }
+
+            public int GetHashCode(object obj)
+            {
+                var str = obj as string;
+                return str != null
+                    ? str.ToUpper().GetHashCode()
+                    : obj.GetHashCode();
+            }
+        }
+
         protected void SetRefSelfChildResults(FieldDefinition fieldDef, ModelDefinition refModelDef, FieldDefinition refSelf, IList childResults)
         {
-            var map = new Dictionary<object, object>();
+            var map = CreateRefMap();
 
             foreach (var result in childResults)
             {
@@ -136,7 +169,7 @@ protected void SetRefSelfChildResults(FieldDefinition fieldDef, ModelDefinition
 
         protected void SetRefFieldChildResults(FieldDefinition fieldDef, FieldDefinition refField, IList childResults)
         {
-            var map = new Dictionary<object, object>();
+            var map = CreateRefMap();
 
             foreach (var result in childResults)
             {

tests/ServiceStack.OrmLite.Tests/Issues/LoadReferencesCaseSensitiveTest.cs

@@ -0,0 +1,102 @@
+using ServiceStack.DataAnnotations;
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using ServiceStack.Text;
+
+namespace ServiceStack.OrmLite.Tests.Issues
+{
+    /// <summary>This test set is used to demonstrate that the OrmLite Load methods are unexpectedly case-sensitive for
+    /// string-based columns. A reference will not be loaded if there is a difference in case between otherwise matching parent
+    /// value and child values. For example, parent table has RegionCode = "WEST" while it's related lookup table Region has
+    /// RegionCode = "West".</summary>
+    /// <remarks>Target database must be setup as case-insensitive or this exercise is pointless. Refer to custom
+    /// openDbConnection method included in this test set.</remarks>
+    public class CustomerWithRegion
+    {
+        [AutoIncrement]
+        public int Id { get; set; }
+
+        public string Name { get; set; }
+
+        [CustomField("VARCHAR(8000) COLLATE Latin1_General_CI_AS")]
+        public string RegionId { get; set; }
+
+        [Reference]
+        public Region RegionDetail { get; set; }
+    }
+
+    public class Region
+    {
+        [PrimaryKey]
+        [CustomField("VARCHAR(8000) COLLATE Latin1_General_CI_AS")]
+        public string Id { get; set; }
+
+        public string RegionName { get; set; }
+    }
+
+    public class LoadReferencesCaseSensitiveTest : OrmLiteTestBase
+    {
+        const string regionCode = "West";
+        const string regionName = "Western Region";
+
+        /// <summary>This test is used to demonstrate that the OrmLite Load methods are unexpectedly case-sensitive for
+        /// string-based columns. A reference will not be loaded if there is a difference in case between otherwise matching parent
+        /// value and child values. For example, parent table has RegionCode = "WEST" while it's related lookup table Region has
+        /// RegionCode = "West".</summary>
+        [Test]
+        public void LoadReference_with_Case_Variance()
+        {
+            if (Dialect != Dialect.SqlServer) return;
+            OrmLiteConfig.IsCaseInsensitive = true;
+
+            using (var db = OpenDbConnection())
+            {
+                db.DropAndCreateTable<CustomerWithRegion>();
+                //db.GetLastSql().Print();
+                db.DropAndCreateTable<Region>();
+                //db.GetLastSql().Print();
+
+                var region = new Region { Id = regionCode, RegionName = regionName };
+                db.Save(region);
+
+                var caseInsensitiveRegion = db.Single<Region>(x => x.Id == regionCode.ToUpper());
+                Assert.That(caseInsensitiveRegion.Id, Is.EqualTo(regionCode));
+
+                var customers = new List<CustomerWithRegion>
+                {
+                    new CustomerWithRegion { Name = "Acme Anvil Co.", RegionId = regionCode }, 
+                    new CustomerWithRegion { Name = "Penny's Poodle Emporium", RegionId = regionCode.ToUpper() }, 
+                };
+
+                foreach (var customer in customers)
+                {
+                    db.Save(customer);
+
+                    var dbCustomer = db.LoadSelect<CustomerWithRegion>(s => s.Name == customer.Name).FirstOrDefault();
+
+                    dbCustomer.PrintDump();
+
+                    Assert.That(
+                        dbCustomer.RegionId,
+                        Is.Not.Null,
+                        string.Format("Region code missing for {0}", customer.Name));
+                    Assert.That(
+                        dbCustomer.RegionId.ToLower() == regionCode.ToLower(),
+                        string.Format("Region code incorrect for {0}", customer.Name));
+
+                    // The following assertion will fail because LoadSelect considers CustomWithRegion.RegionCode of "WEST" != to Region.RegionCode of "West".
+                    Assert.That(
+                        dbCustomer.RegionDetail,
+                        Is.Not.Null,
+                        string.Format("Region detail record missing for {0}", customer.Name));
+                    Assert.That(
+                        dbCustomer.RegionDetail.RegionName == regionName,
+                        string.Format("Region name incorrect for {0}", customer.Name));
+                }
+            }
+
+            OrmLiteConfig.IsCaseInsensitive = false;
+        }
+    }
+}

tests/ServiceStack.OrmLite.Tests/ServiceStack.OrmLite.Tests.csproj

@@ -132,6 +132,7 @@
     <Compile Include="Expression\SelectExpressionTests.cs" />
     <Compile Include="Issues\ComplexJoinWithAlias.cs" />
     <Compile Include="Issues\CustomFieldTests.cs" />
+    <Compile Include="Issues\LoadReferencesCaseSensitiveTest.cs" />
     <Compile Include="Issues\LoadSelectIssue.cs" />
     <Compile Include="Issues\MultipleSelfJoinsWithNullableInts.cs" />
     <Compile Include="Issues\UtcDateTimeIssueTests.cs" />