fixed filtering with anonymous types and aliases

changed SetParemeter in OrmLiteReadExtensions
to handle the conversion to aliased field names
when filtering using anonymous type declarations
which reference the original field name

Author: mishfit

src/ServiceStack.OrmLite/OrmLiteReadExtensions.cs

@@ -215,18 +215,20 @@ private static void SetFilter<T>(IDbCommand dbCmd, string name, object value)
 
 		public static void SetFilters<T>(this IDbCommand dbCmd, object anonType, bool excludeNulls)
 		{
-			SetParameters(dbCmd, anonType, excludeNulls);
+			SetParameters<T>(dbCmd, anonType, excludeNulls);
 
 			dbCmd.CommandText = GetFilterSql<T>(dbCmd);
 		}
 
-		private static void SetParameters(this IDbCommand dbCmd, object anonType, bool excludeNulls)
+		private static void SetParameters<T>(this IDbCommand dbCmd, object anonType, bool excludeNulls)
 		{
 			dbCmd.Parameters.Clear();
 			lastQueryType = null;
 			if (anonType == null) return;
 
-			var pis = anonType.GetType().GetSerializableProperties();
+            var pis = anonType.GetType().GetSerializableProperties();
+                ModelDefinition model = ModelDefinition<T>.Definition;
+
 			foreach (var pi in pis)
 			{
 				var mi = pi.GetGetMethod();
@@ -235,8 +237,15 @@ private static void SetParameters(this IDbCommand dbCmd, object anonType, bool e
 				var value = mi.Invoke(anonType, new object[0]);
 				if (excludeNulls && value == null) continue;
 
+
 				var p = dbCmd.CreateParameter();
-				p.ParameterName = pi.Name;
+
+                FieldDefinition targetField = model.FieldDefinitions.FirstOrDefault(f => string.Equals(f.Name, pi.Name));
+                if (targetField != null && !string.IsNullOrEmpty(targetField.Alias))
+                    p.ParameterName = targetField.Alias;
+                else
+                    p.ParameterName = pi.Name;
+
 				p.DbType = OrmLiteConfig.DialectProvider.GetColumnDbType(pi.PropertyType);
 				p.Direction = ParameterDirection.Input;
 				p.Value = value;
@@ -328,7 +337,7 @@ internal static T QuerySingle<T>(this IDbCommand dbCmd, string sql, object anonT
 		{
 			if (IsScalar<T>()) return QueryScalar<T>(dbCmd, sql, anonType);
 
-			dbCmd.SetParameters(anonType, true);
+			dbCmd.SetParameters<T>(anonType, true);
             dbCmd.CommandText = OrmLiteConfig.DialectProvider.ToSelectStatement(typeof(T), sql);
 
 			using (var dbReader = dbCmd.ExecuteReader())
@@ -359,7 +368,7 @@ internal static List<T> Where<T>(this IDbCommand dbCmd, object anonType)
 
         internal static List<T> Query<T>(this IDbCommand dbCmd, string sql, object anonType = null)
 		{
-            if (anonType != null) dbCmd.SetParameters(anonType, true);
+            if (anonType != null) dbCmd.SetParameters<T>(anonType, true);
             dbCmd.CommandText = OrmLiteConfig.DialectProvider.ToSelectStatement(typeof(T), sql);
 
 			using (var dbReader = dbCmd.ExecuteReader())
@@ -389,7 +398,7 @@ internal static T QueryScalar<T>(this IDbCommand dbCmd, object anonType)
 
 	    internal static T QueryScalar<T>(this IDbCommand dbCmd, string sql, object anonType = null)
 		{
-            if (anonType != null) dbCmd.SetParameters(anonType, true);
+            if (anonType != null) dbCmd.SetParameters<T>(anonType, true);
             dbCmd.CommandText = OrmLiteConfig.DialectProvider.ToSelectStatement(typeof(T), sql);
 
 			using (var dbReader = dbCmd.ExecuteReader())
@@ -398,7 +407,7 @@ internal static T QueryScalar<T>(this IDbCommand dbCmd, string sql, object anonT
 
         internal static List<T> SqlList<T>(this IDbCommand dbCmd, string sql, object anonType = null)
         {
-            if (anonType != null) dbCmd.SetParameters(anonType, true);
+            if (anonType != null) dbCmd.SetParameters<T>(anonType, true);
             dbCmd.CommandText = sql;
 
             using (var dbReader = dbCmd.ExecuteReader())
@@ -420,7 +429,7 @@ internal static List<T> SqlList<T>(this IDbCommand dbCmd, string sql, Dictionary
 
 	    internal static T SqlScalar<T>(this IDbCommand dbCmd, string sql, object anonType = null)
         {
-            if (anonType != null) dbCmd.SetParameters(anonType, true);
+            if (anonType != null) dbCmd.SetParameters<T>(anonType, true);
             dbCmd.CommandText = sql;
 
             using (var dbReader = dbCmd.ExecuteReader())
@@ -446,7 +455,7 @@ internal static List<T> ByExampleWhere<T>(this IDbCommand dbCmd, object anonType
 
 	    internal static List<T> QueryByExample<T>(this IDbCommand dbCmd, string sql, object anonType = null)
 		{
-            if (anonType != null) dbCmd.SetParameters(anonType, true);
+            if (anonType != null) dbCmd.SetParameters<T>(anonType, true);
             dbCmd.CommandText = OrmLiteConfig.DialectProvider.ToSelectStatement(typeof(T), sql);
 
 			using (var dbReader = dbCmd.ExecuteReader())

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

@@ -147,6 +147,7 @@
     <Compile Include="SqlBuilderTests.cs" />
     <Compile Include="SqlServerProviderTests.cs" />
     <Compile Include="TypeWithByteArrayFieldTests.cs" />
+    <Compile Include="UseCase\AliasedFieldUseCase.cs" />
     <Compile Include="UseCase\CustomerOrdersUseCase.cs" />
     <Compile Include="UseCase\SchemaUseCase.cs" />
     <Compile Include="UseCase\ShardingUseCase.cs" />

tests/ServiceStack.OrmLite.Tests/UseCase/AliasedFieldUseCase.cs

@@ -0,0 +1,47 @@
+using System;
+using System.Collections.Generic;
+using System.Data;
+using NUnit.Framework;
+using ServiceStack.DataAnnotations;
+
+namespace ServiceStack.OrmLite.Tests.UseCase
+{
+    [TestFixture]
+    public class AliasedFieldUseCase
+    {
+        [TestFixtureSetUp]
+        public void TestFixtureSetup() {
+            OrmLiteConfig.DialectProvider = SqliteDialect.Provider;
+        }
+
+        public class Foo
+        {
+            [Alias("SOME_COLUMN_NAME")]
+            public string Bar { get; set; }
+        }
+
+        [Test]
+        public void CanResolveAliasedFieldNameInAnonymousType()
+        {
+            using (IDbConnection db = ":memory:".OpenDbConnection())
+            {
+                db.CreateTable<Foo>(false);
+
+                db.Insert(new Foo { Bar = "some_value" });
+                db.Insert(new Foo { Bar = "a totally different value" });
+                db.Insert(new Foo { Bar = "whatever" });
+
+                // the original classes property name is used to create the anonymous type
+                List<Foo> foos = db.Where<Foo>(new { Bar = "some_value" });
+
+                Assert.That(foos, Has.Count.EqualTo(1));
+
+                // the aliased column name is used to create the anonymous type
+                foos = db.Where<Foo>(new { SOME_COLUMN_NAME = "some_value" });
+
+                Assert.That(foos, Has.Count.EqualTo(1));
+            }
+        }
+
+    }
+}