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

This is very useful when querying legacy databases that cannot be changed (views, stored procedures, ...)
that contains fields with underscores and/or special characters and/or prefixes that either wouldn't be
possible to be declared in C#, or wouldn't comply with standard naming conventions

Examples of mappings that are now possible with this change:
[Database]       [C#]
customer_id   => public int CustomerId { get; set; }
quantity_%    => public decimal Quantity { get; set; }
t040_name     => public string Name { get; set; }

Author: augustoproiete

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)));
+            }
+        }
+    }
 }