Add tracer bullet impl of supporting parameterized queries in SqlExpression<T>

Author: mythz

src/ServiceStack.OrmLite/Expressions/ReadExpressionCommandExtensions.cs

@@ -35,7 +35,7 @@ internal static List<T> Select<T>(this IDbCommand dbCmd, SqlExpression<T> expres
         {
             string sql = expression.SelectInto<T>();
 
-            return dbCmd.ExprConvertToList<T>(sql);
+            return dbCmd.ExprConvertToList<T>(sql, expression.Params);
         }
 
         internal static List<T> Select<T>(this IDbCommand dbCmd, Expression<Func<T, bool>> predicate)

src/ServiceStack.OrmLite/Expressions/SqlExpression.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
+using System.Data;
 using System.Linq;
 using System.Reflection;
 using System.Text;
@@ -31,6 +32,7 @@ public abstract partial class SqlExpression<T> : ISqlExpression
         public bool PrefixFieldWithTableName { get; set; }
         public bool WhereStatementWithoutWhereString { get; set; }
         public IOrmLiteDialectProvider DialectProvider { get; set; }
+        public List<IDbDataParameter> Params { get; set; } 
 
         protected string Sep
         {
@@ -43,6 +45,7 @@ public SqlExpression(IOrmLiteDialectProvider dialectProvider)
             PrefixFieldWithTableName = false;
             WhereStatementWithoutWhereString = false;
             DialectProvider = dialectProvider;
+            Params = new List<IDbDataParameter>();
             tableDefs.Add(modelDef);
         }
 
@@ -68,6 +71,7 @@ protected virtual SqlExpression<T> CopyTo(SqlExpression<T> to)
             to.modelDef = modelDef;
             to.PrefixFieldWithTableName = PrefixFieldWithTableName;
             to.WhereStatementWithoutWhereString = WhereStatementWithoutWhereString;
+            to.Params = new List<IDbDataParameter>(Params);
             return to;
         }
 
@@ -1148,8 +1152,6 @@ protected virtual object VisitParameter(ParameterExpression p)
             return p.Name;
         }
 
-        public Dictionary<string, object> Params = new Dictionary<string, object>();
-
         protected virtual object VisitConstant(ConstantExpression c)
         {
             if (c.Value == null)
@@ -1606,10 +1608,36 @@ protected virtual object VisitColumnAccessMethod(MethodCallExpression m)
             }
             return new PartialSqlString(statement);
         }
+
+        public IDbDataParameter CreateParam(string name,
+            object value = null,
+            ParameterDirection direction = ParameterDirection.Input,
+            DbType? dbType = null)
+        {
+            var p = new OrmLiteDataParameter {
+                ParameterName = DialectProvider.GetParam(name), 
+                Direction = direction
+            };
+            if (value != null)
+            {
+                p.Value = value;
+                p.DbType = DialectProvider.GetColumnDbType(value.GetType());
+            }
+            if (dbType != null)
+                p.DbType = dbType.Value;
+
+            if (p.DbType == DbType.String)
+                p.Size = DialectProvider.DefaultStringLength;
+
+            return p;
+        }
+
     }
 
     public interface ISqlExpression
     {
+        List<IDbDataParameter> Params { get; }
+
         string ToSelectStatement();
         string SelectInto<TModel>();
     }
@@ -1640,5 +1668,18 @@ public EnumMemberAccess(string text, Type enumType)
         public Type EnumType { get; private set; }
     }
 
+    public class OrmLiteDataParameter : IDbDataParameter
+    {
+        public DbType DbType { get; set; }
+        public ParameterDirection Direction { get; set; }
+        public bool IsNullable { get; set; }
+        public string ParameterName { get; set; }
+        public string SourceColumn { get; set; }
+        public DataRowVersion SourceVersion { get; set; }
+        public object Value { get; set; }
+        public byte Precision { get; set; }
+        public byte Scale { get; set; }
+        public int Size { get; set; }
+    }
 }
 

src/ServiceStack.OrmLite/JoinSqlBuilder.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Data;
 using System.Linq;
 using System.Linq.Expressions;
 using System.Text;
@@ -603,6 +604,8 @@ public string ToSql()
             return SelectInto<TNewPoco>();
         }
 
+        public List<IDbDataParameter> Params { get; private set; }
+
         public string ToSelectStatement()
         {
             return SelectInto<TNewPoco>();

src/ServiceStack.OrmLite/OrmLiteResultsFilterExtensions.cs

@@ -89,11 +89,36 @@ public static IList ConvertToList(this IDbCommand dbCmd, Type refType, string sq
             }
         }
 
-        internal static List<T> ExprConvertToList<T>(this IDbCommand dbCmd, string sql = null)
+        public static IDbDataParameter PopulateWith(this IDbDataParameter to, IDbDataParameter from)
+        {
+            to.DbType = from.DbType;
+            to.Direction = from.Direction;
+            to.ParameterName = from.ParameterName;
+            to.SourceColumn = from.SourceColumn;
+            to.SourceVersion = from.SourceVersion;
+            to.Value = from.Value;
+            to.Precision = from.Precision;
+            to.Scale = from.Scale;
+            to.Size = from.Size;
+
+            return to;
+        }
+
+        internal static List<T> ExprConvertToList<T>(this IDbCommand dbCmd, string sql = null, IEnumerable<IDbDataParameter> sqlParams = null)
         {
             if (sql != null)
                 dbCmd.CommandText = sql;
 
+            if (sqlParams != null)
+            {
+                foreach (var sqlParam in sqlParams)
+                {
+                    var p = dbCmd.CreateParameter();
+                    p.PopulateWith(sqlParam);
+                    dbCmd.Parameters.Add(p);
+                }
+            }
+
             if (OrmLiteConfig.ResultsFilter != null)
             {
                 return OrmLiteConfig.ResultsFilter.GetList<T>(dbCmd);

src/ServiceStack.OrmLite/SqlBuilder.cs

@@ -1,11 +1,13 @@
 using System;
 using System.Collections.Generic;
+using System.Data;
 using System.Linq;
 using System.Reflection;
 using System.Reflection.Emit;
 using System.Text.RegularExpressions;
 using System.Threading;
 using ServiceStack.Text;
+using PropertyAttributes = System.Reflection.PropertyAttributes;
 
 namespace ServiceStack.OrmLite
 {
@@ -215,6 +217,8 @@ void ResolveSql()
             public string RawSql { get { ResolveSql(); return rawSql; } }
             public object Parameters { get { ResolveSql(); return parameters; } }
 
+            public List<IDbDataParameter> Params { get; private set; }
+
             public string ToSelectStatement()
             {
                 return RawSql;

tests/ServiceStack.OrmLite.Tests/Expression/SqlExpressionParamTests.cs

@@ -0,0 +1,29 @@
+using NUnit.Framework;
+using ServiceStack.Text;
+
+namespace ServiceStack.OrmLite.Tests.Expression
+{
+    [TestFixture]
+    public class SqlExpressionParamTests : OrmLiteTestBase
+    {
+        [Test]
+        public void Can_add_DbParam_to_SqlExpression()
+        {
+            using (var db = OpenDbConnection())
+            {
+                SqlExpressionTests.InitLetters(db);
+
+                var q = db.From<LetterFrequency>()
+                    .UnsafeWhere("Letter = {0}".Fmt(db.GetDialectProvider().GetParam("p1")));
+
+                q.Params.Add(q.CreateParam("p1", "B"));
+
+                var results = db.Select(q);
+
+                results.PrintDump();
+
+                Assert.That(results.Count, Is.EqualTo(2));
+            }
+        } 
+    }
+}

tests/ServiceStack.OrmLite.Tests/Expression/SqlExpressionTests.cs

@@ -35,7 +35,7 @@ public class LetterStat
 
     public class SqlExpressionTests : ExpressionsTestBase
     {
-        private static void InitLetters(IDbConnection db)
+        public static void InitLetters(IDbConnection db)
         {
             db.DropAndCreateTable<LetterFrequency>();
 

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

@@ -126,6 +126,7 @@
     <Compile Include="Expression\FromExpressionTests.cs" />
     <Compile Include="Expression\GenericTableExpressions.cs" />
     <Compile Include="Expression\MethodExpressionTests.cs" />
+    <Compile Include="Expression\SqlExpressionParamTests.cs" />
     <Compile Include="Expression\SqlExpressionTests.cs" />
     <Compile Include="Expression\SelectExpressionTests.cs" />
     <Compile Include="Issues\ComplexJoinWithAlias.cs" />