Add support for generating ToInsertStatement/ToUpdateStatement and merging params into SQL

Author: mythz

src/ServiceStack.OrmLite/IOrmLiteDialectProvider.cs

@@ -201,5 +201,9 @@ string ToCreateIndexStatement<T>(Expression<Func<T, object>> field,
 
         string GetLoadChildrenSubSelect<From>(SqlExpression<From> expr);
         string ToRowCountStatement(string innerSql);
+
+        string ToUpdateStatement<T>(IDbCommand dbCmd, T item, ICollection<string> updateFields = null);
+        string ToInsertStatement<T>(IDbCommand dbCmd, T item, ICollection<string> insertFields = null);
+        string MergeParamsIntoSql(string sql, IEnumerable<IDbDataParameter> dbParams);
     }
 }

src/ServiceStack.OrmLite/OrmLiteDialectProviderBase.cs

@@ -627,6 +627,20 @@ public virtual string ToInsertRowStatement(IDbCommand cmd, object objWithPropert
             return sql;
         }
 
+        public virtual string ToInsertStatement<T>(IDbCommand dbCmd, T item, ICollection<string> insertFields = null)
+        {
+            dbCmd.Parameters.Clear();
+            var dialectProvider = dbCmd.GetDialectProvider();
+            dialectProvider.PrepareParameterizedInsertStatement<T>(dbCmd);
+
+            if (string.IsNullOrEmpty(dbCmd.CommandText))
+                return null;
+
+            dialectProvider.SetParameterValues<T>(dbCmd, item);
+
+            return MergeParamsIntoSql(dbCmd.CommandText, ToArray(dbCmd.Parameters));
+        }
+
         public virtual void PrepareParameterizedInsertStatement<T>(IDbCommand cmd, ICollection<string> insertFields = null)
         {
             var sbColumnNames = StringBuilderCache.Allocate();
@@ -670,6 +684,41 @@ public virtual void PrepareParameterizedInsertStatement<T>(IDbCommand cmd, IColl
                 StringBuilderCacheAlt.ReturnAndFree(sbColumnValues));
         }
 
+        public virtual string ToUpdateStatement<T>(IDbCommand dbCmd, T item, ICollection<string> updateFields = null)
+        {
+            dbCmd.Parameters.Clear();
+            var dialectProvider = dbCmd.GetDialectProvider();
+            dialectProvider.PrepareParameterizedUpdateStatement<T>(dbCmd);
+
+            if (string.IsNullOrEmpty(dbCmd.CommandText))
+                return null;
+
+            dialectProvider.SetParameterValues<T>(dbCmd, item);
+
+            return MergeParamsIntoSql(dbCmd.CommandText, ToArray(dbCmd.Parameters));
+        }
+
+        IDbDataParameter[] ToArray(IDataParameterCollection dbParams)
+        {
+            var to = new IDbDataParameter[dbParams.Count];
+            for (int i = 0; i < dbParams.Count; i++)
+            {
+                to[i] = (IDbDataParameter) dbParams[i];
+            }
+            return to;
+        }
+
+        public virtual string MergeParamsIntoSql(string sql, IEnumerable<IDbDataParameter> dbParams)
+        {
+            foreach (var dbParam in dbParams)
+            {
+                var varName = dbParam.ParameterName;
+                var quotedValue = GetQuotedValue(dbParam.Value, dbParam.Value.GetType());
+                sql = sql.Replace(varName, quotedValue);
+            }
+            return sql;
+        }
+
         public virtual bool PrepareParameterizedUpdateStatement<T>(IDbCommand cmd, ICollection<string> updateFields = null)
         {
             var sql = StringBuilderCache.Allocate();

src/ServiceStack.OrmLite/OrmLiteWriteApi.cs

@@ -322,5 +322,21 @@ public static void ExecuteProcedure<T>(this IDbConnection dbConn, T obj)
         {
             dbConn.Exec(dbCmd => dbCmd.ExecuteProcedure(obj));
         }
+
+        /// <summary>
+        /// Generates inline UPDATE SQL Statement
+        /// </summary>
+        public static string ToUpdateStatement<T>(this IDbConnection dbConn, T item, ICollection<string> updateFields = null)
+        {
+            return dbConn.Exec(dbCmd => dbCmd.GetDialectProvider().ToUpdateStatement(dbCmd, item, updateFields));
+        }
+
+        /// <summary>
+        /// Generates inline INSERT SQL Statement
+        /// </summary>
+        public static string ToInsertStatement<T>(this IDbConnection dbConn, T item, ICollection<string> insertFields = null)
+        {
+            return dbConn.Exec(dbCmd => dbCmd.GetDialectProvider().ToInsertStatement(dbCmd, item, insertFields));
+        }
     }
 }

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

@@ -142,6 +142,7 @@
     <Compile Include="Support\ArtistTrackTestBase.cs" />
     <Compile Include="Support\JoinSqlBuilder.cs" />
     <Compile Include="TemporaryNamingStrategy.cs" />
+    <Compile Include="ToInsertAndUpdateStatementTests.cs" />
     <Compile Include="UseCase\ArtistTrackSqlExpressions.cs" />
     <Compile Include="UseCase\ExpressionsAuthorTests.cs" />
     <Compile Include="Expression\ComplexJoinTests.cs" />

tests/ServiceStack.OrmLite.Tests/ToInsertAndUpdateStatementTests.cs

@@ -0,0 +1,48 @@
+using NUnit.Framework;
+using ServiceStack.OrmLite.Tests.Shared;
+using ServiceStack.Text;
+
+namespace ServiceStack.OrmLite.Tests
+{
+    [TestFixture]
+    public class ToInsertAndUpdateStatementTests
+        : OrmLiteTestBase
+    {
+        [Test]
+        public void Can_use_ToUpdateStatement_to_generate_inline_SQL()
+        {
+            using (var db = OpenDbConnection())
+            {
+                db.DropAndCreateTable<Person>();
+                db.InsertAll(Person.Rockstars);
+
+                var row = db.SingleById<Person>(1);
+                row.Age = 42;
+
+                var sql = db.ToUpdateStatement(row);
+                sql.Print();
+                db.ExecuteSql(sql);
+
+                var updatedRow = db.SingleById<Person>(1);
+                Assert.That(updatedRow.Equals(row));
+            }
+        }
+
+        [Test]
+        public void Can_use_ToInsertStatement_to_generate_inline_SQL()
+        {
+            using (var db = OpenDbConnection())
+            {
+                db.DropAndCreateTable<Person>();
+                var row = Person.Rockstars[0];
+
+                var sql = db.ToInsertStatement(row);
+                sql.Print();
+                db.ExecuteSql(sql);
+
+                var insertedRow = db.SingleById<Person>(row.Id);
+                Assert.That(insertedRow.Equals(row));
+            }
+        }
+    }
+}