Merge pull request #291 from CaioProiete/improve-mappings-for-legacy-databases

Add some fall-back guesses when mapping between datareader and object to better support legacy databases

Author: mythz

src/ServiceStack.OrmLite/OrmLiteWriteExtensions.cs

@@ -15,6 +15,7 @@
 using System.Data;
 using System.Diagnostics;
 using System.Linq;
+using System.Text.RegularExpressions;
 using ServiceStack.Common.Utils;
 using ServiceStack.Logging;
 
@@ -235,18 +236,27 @@ public static T PopulateWithSqlReader<T>(this T objWithProperties, IDataReader d
 			{
 				foreach (var fieldDef in fieldDefs)
 				{
-                    int index = NotFound;
+                    int index;
                     if (indexCache != null)
                     {
                         if (!indexCache.TryGetValue(fieldDef.Name, out index))
                         {
                             index = dataReader.GetColumnIndex(fieldDef.FieldName);
+                            if (index == NotFound)
+                            {
+                                index = TryGuessColumnIndex(fieldDef.FieldName, dataReader);
+                            }
+
                             indexCache.Add(fieldDef.Name, index);
                         }
                     }
                     else
                     {
                         index = dataReader.GetColumnIndex(fieldDef.FieldName);
+                        if (index == NotFound)
+                        {
+                            index = TryGuessColumnIndex(fieldDef.FieldName, dataReader);
+                        }
                     }
 
 					if (index == NotFound) continue;
@@ -261,6 +271,71 @@ public static T PopulateWithSqlReader<T>(this T objWithProperties, IDataReader d
 			return objWithProperties;
         }
 
+        private static readonly Regex AllowedPropertyCharsRegex = new Regex(@"[^0-9a-zA-Z_]",
+            RegexOptions.Compiled | RegexOptions.CultureInvariant);
+
+        private static int TryGuessColumnIndex(string fieldName, IDataReader dataReader)
+        {
+            var fieldCount = dataReader.FieldCount;
+            for (var i = 0; i < fieldCount; i++)
+            {
+                var dbFieldName = dataReader.GetName(i);
+
+                // First guess: Maybe the DB field has underscores? (most common)
+                // e.g. CustomerId (C#) vs customer_id (DB)
+                var dbFieldNameWithNoUnderscores = dbFieldName.Replace("_", "");
+                if (string.Compare(fieldName, dbFieldNameWithNoUnderscores, StringComparison.InvariantCultureIgnoreCase) == 0)
+                {
+                    return i;
+                }
+
+                // Next guess: Maybe the DB field has special characters?
+                // e.g. Quantity (C#) vs quantity% (DB)
+                var dbFieldNameSanitized = AllowedPropertyCharsRegex.Replace(dbFieldName, string.Empty);
+                if (string.Compare(fieldName, dbFieldNameSanitized, StringComparison.InvariantCultureIgnoreCase) == 0)
+                {
+                    return i;
+                }
+
+                // Next guess: Maybe the DB field has special characters *and* has underscores?
+                // e.g. Quantity (C#) vs quantity_% (DB)
+                if (string.Compare(fieldName, dbFieldNameSanitized.Replace("_", string.Empty), StringComparison.InvariantCultureIgnoreCase) == 0)
+                {
+                    return i;
+                }
+
+                // Next guess: Maybe the DB field has some prefix that we don't have in our C# field?
+                // e.g. CustomerId (C#) vs t130CustomerId (DB)
+                if (dbFieldName.EndsWith(fieldName, StringComparison.InvariantCultureIgnoreCase))
+                {
+                    return i;
+                }
+
+                // Next guess: Maybe the DB field has some prefix that we don't have in our C# field *and* has underscores?
+                // e.g. CustomerId (C#) vs t130_CustomerId (DB)
+                if (dbFieldNameWithNoUnderscores.EndsWith(fieldName, StringComparison.InvariantCultureIgnoreCase))
+                {
+                    return i;
+                }
+
+                // Next guess: Maybe the DB field has some prefix that we don't have in our C# field *and* has special characters?
+                // e.g. CustomerId (C#) vs t130#CustomerId (DB)
+                if (dbFieldNameSanitized.EndsWith(fieldName, StringComparison.InvariantCultureIgnoreCase))
+                {
+                    return i;
+                }
+
+                // Next guess: Maybe the DB field has some prefix that we don't have in our C# field *and* has underscores *and* has special characters?
+                // e.g. CustomerId (C#) vs t130#Customer_I#d (DB)
+                if (dbFieldNameSanitized.Replace("_", "").EndsWith(fieldName, StringComparison.InvariantCultureIgnoreCase))
+                {
+                    return i;
+                }
+            }
+
+            return NotFound;
+        }
+
         internal static void Update<T>(this IDbCommand dbCmd, params T[] objs)
 		{
 			foreach (var obj in objs)

tests/ServiceStack.OrmLite.Tests/OrmLiteQueryTests.cs

@@ -218,5 +218,44 @@ FROM Note
                 Assert.That(notes[0].NoteText, Is.EqualTo("Hello world 5"));
             }
         }
-	}
+
+        class CustomerDto
+        {
+            public int CustomerId { get; set; }
+            public string @CustomerName { get; set; }
+            public DateTime Customer_Birth_Date { get; set; }
+        }
+
+        [Test]
+        [TestCase("customer_id", "customer_name", "customer_birth_date")]
+        [TestCase("customerid%", "@customername", "customer_b^irth_date")]
+        [TestCase("customerid_%", "@customer_name", "customer$_birth_#date")]
+        [TestCase("c!u@s#t$o%m^e&r*i(d_%", "__cus_tomer__nam_e__", "~cus`tomer$_birth_#date")]
+        [TestCase("t030CustomerId", "t030CustomerName", "t030Customer_birth_date")]
+        [TestCase("t030_customer_id", "t030_customer_name", "t130_customer_birth_date")]
+        [TestCase("t030#Customer_I#d", "t030CustomerNa$^me", "t030Cust^omer_birth_date")]
+        public void Can_query_CustomerDto_and_map_db_fields_not_identical_by_guessing_the_mapping(string field1Name, string field2Name, string field3Name)
+        {
+            using (var db = ConnectionString.OpenDbConnection())
+            {
+                var sql = string.Format(@"
+                    SELECT 1 AS [{0}], 'John' AS [{1}], '1970-01-01' AS [{2}]
+                    UNION ALL
+                    SELECT 2 AS [{0}], 'Jane' AS [{1}], '1980-01-01' AS [{2}]",
+                                        field1Name, field2Name, field3Name);
+
+                var customers = db.Query<CustomerDto>(sql);
+
+                Assert.That(customers.Count, Is.EqualTo(2));
+
+                Assert.That(customers[0].CustomerId, Is.EqualTo(1));
+                Assert.That(customers[0].CustomerName, Is.EqualTo("John"));
+                Assert.That(customers[0].Customer_Birth_Date, Is.EqualTo(new DateTime(1970, 01, 01)));
+
+                Assert.That(customers[1].CustomerId, Is.EqualTo(2));
+                Assert.That(customers[1].CustomerName, Is.EqualTo("Jane"));
+                Assert.That(customers[1].Customer_Birth_Date, Is.EqualTo(new DateTime(1980, 01, 01)));
+            }
+        }
+    }
 }