Add support for SqlConflict using command filter

Author: mythz

src/ServiceStack.OrmLite.MySql/MySqlDialectProviderBase.cs

@@ -200,6 +200,12 @@ public override string GetColumnDefinition(FieldDefinition fieldDef)
             return ret;
         }
 
+        public override string SqlConflict(string sql, string conflictResolution)
+        {
+            var parts = sql.SplitOnFirst(' ');
+            return parts[0] + " " + conflictResolution + " " + parts[1];
+        }
+
         public override string SqlCurrency(string fieldOrValue, string currencySymbol) =>
             SqlConcat(new[] { "'" + currencySymbol + "'", "cast(" + fieldOrValue + " as decimal(15,2))" });
 

src/ServiceStack.OrmLite.PostgreSQL/PostgreSQLDialectProvider.cs

@@ -448,6 +448,14 @@ public override void PrepareStoredProcedureStatement<T>(IDbCommand cmd, T obj)
             SetParameterValues<T>(cmd, obj);
         }
 
+        public override string SqlConflict(string sql, string conflictResolution)
+        {
+            //https://www.postgresql.org/docs/current/static/sql-insert.html
+            return sql + " ON CONFLICT " + (conflictResolution == ConflictResolution.Ignore
+                       ? " DO NOTHING"
+                       : conflictResolution);
+        }
+
         public override string SqlConcat(IEnumerable<object> args) => string.Join(" || ", args);
 
         public override string SqlCurrency(string fieldOrValue, string currencySymbol) => currencySymbol == "$"

src/ServiceStack.OrmLite.Sqlite/SqliteOrmLiteDialectProviderBase.cs

@@ -204,6 +204,13 @@ public override string GetColumnDefinition(FieldDefinition fieldDef)
             return ret;
         }
 
+        public override string SqlConflict(string sql, string conflictResolution)
+        {
+            // http://www.sqlite.org/lang_conflict.html
+            var parts = sql.SplitOnFirst(' ');
+            return parts[0] + " OR " + conflictResolution + " " + parts[1];
+        }
+
         public override string SqlConcat(IEnumerable<object> args) => string.Join(" || ", args);
 
         public override string SqlCurrency(string fieldOrValue, string currencySymbol) => SqlConcat(new []{ "'" + currencySymbol + "'", "printf(\"%.2f\", " + fieldOrValue + ")" });

src/ServiceStack.OrmLite/IOrmLiteDialectProvider.cs

@@ -207,6 +207,8 @@ string ToCreateIndexStatement<T>(Expression<Func<T, object>> field,
         string ToInsertStatement<T>(IDbCommand dbCmd, T item, ICollection<string> insertFields = null);
         string MergeParamsIntoSql(string sql, IEnumerable<IDbDataParameter> dbParams);
 
+        string SqlConflict(string sql, string conflictResolution);
+
         string SqlConcat(IEnumerable<object> args);
         string SqlCurrency(string fieldOrValue);
         string SqlCurrency(string fieldOrValue, string currencySymbol);

src/ServiceStack.OrmLite/OrmLiteConflictResolutions.cs

@@ -0,0 +1,26 @@
+using System;
+using System.Data;
+using ServiceStack.Text;
+
+namespace ServiceStack.OrmLite
+{
+    public class ConflictResolution
+    {
+        public const string Ignore = "IGNORE";
+    }
+
+    public static class OrmLiteConflictResolutions
+    {
+        public static void OnConflictIgnore(this IDbCommand dbCmd) => dbCmd.OnConflict(ConflictResolution.Ignore);
+
+        public static void OnConflict(this IDbCommand dbCmd, string conflictResolution)
+        {
+            var pos = dbCmd.CommandText?.IndexOf(' ') ?? -1;
+            if (pos == -1)
+                throw new NotSupportedException("Cannot specify ON CONFLICT resolution on Invalid SQL starting with: " + dbCmd.CommandText.SubstringWithElipsis(0, 50));
+
+            var sqlConflict = dbCmd.GetDialectProvider().SqlConflict(dbCmd.CommandText, conflictResolution);
+            dbCmd.CommandText = sqlConflict;
+        }
+    }
+}

src/ServiceStack.OrmLite/OrmLiteDialectProviderBase.cs

@@ -1523,6 +1523,8 @@ protected virtual string ToDropColumnStatement(Type modelType, string columnName
                    $"DROP COLUMN {provider.GetQuotedColumnName(columnName)};";
         }
 
+        public virtual string SqlConflict(string sql, string conflictResolution) => sql; //NOOP
+
         public virtual string SqlConcat(IEnumerable<object> args) => $"CONCAT({string.Join(", ", args)})";
 
         public virtual string SqlCurrency(string fieldOrValue) => SqlCurrency(fieldOrValue, "$");

tests/ServiceStack.OrmLite.Tests/ConflictResolutionTests.cs

@@ -0,0 +1,95 @@
+using System.Threading.Tasks;
+using NUnit.Framework;
+using ServiceStack.Common.Tests.Models;
+using ServiceStack.Logging;
+
+namespace ServiceStack.OrmLite.Tests
+{
+    public class ConflictResolutionTests : OrmLiteTestBase
+    {
+        //public ConflictResolutionTests() : base(Dialect.Sqlite) { }
+        //[SetUp] public void SetUp() => LogManager.LogFactory = new ConsoleLogFactory(debugEnabled:true);
+
+        [Test]
+        public void Can_change_conflict_resolutiion_with_Insert()
+        {
+            using (var db = OpenDbConnection())
+            {
+                db.DropAndCreateTable<ModelWithIdAndName>();
+
+                var row = new ModelWithIdAndName(1);
+                db.Insert(row, dbCmd => dbCmd.OnConflictIgnore());
+
+                //Equivalent to: 
+                db.Insert(row, dbCmd => dbCmd.OnConflict(ConflictResolution.Ignore));
+            }
+        }
+
+        [Test]
+        public async Task Can_change_conflict_resolutiion_with_Insert_Async()
+        {
+            using (var db = OpenDbConnection())
+            {
+                db.DropAndCreateTable<ModelWithIdAndName>();
+
+                var row = new ModelWithIdAndName(1);
+                await db.InsertAsync(row, dbCmd => dbCmd.OnConflictIgnore());
+
+                //Equivalent to: 
+                await db.InsertAsync(row, dbCmd => dbCmd.OnConflict(ConflictResolution.Ignore));
+            }
+        }
+
+        [Test]
+        public void Can_change_conflict_resolutiion_with_Insert_AutoIncrement()
+        {
+            using (var db = OpenDbConnection())
+            {
+                db.DropAndCreateTable<ModelWithIdAndName>();
+
+                var row = new ModelWithIdAndName(1);
+                var insertId = db.Insert(row, dbCmd => dbCmd.OnConflictIgnore(), selectIdentity: true);
+                Assert.That(insertId, Is.GreaterThan(0));
+            }
+        }
+
+        [Test]
+        public async Task Can_change_conflict_resolutiion_with_Insert_AutoIncrement_Async()
+        {
+            using (var db = OpenDbConnection())
+            {
+                db.DropAndCreateTable<ModelWithIdAndName>();
+
+                var row = new ModelWithIdAndName(1);
+                var insertId = await db.InsertAsync(row, dbCmd => dbCmd.OnConflictIgnore(), selectIdentity: true);
+                Assert.That(insertId, Is.GreaterThan(0));
+            }
+        }
+
+        [Test]
+        public void Can_change_conflict_resolutiion_with_InsertAll()
+        {
+            using (var db = OpenDbConnection())
+            {
+                var rows = 5.Times(i => new ModelWithIdAndName(i));
+
+                db.DropAndCreateTable<ModelWithIdAndName>();
+
+                db.InsertAll(rows, dbCmd => dbCmd.OnConflictIgnore());
+            }
+        }
+
+        [Test]
+        public async Task Can_change_conflict_resolutiion_with_InsertAll_Async()
+        {
+            using (var db = OpenDbConnection())
+            {
+                var rows = 5.Times(i => new ModelWithIdAndName(i));
+
+                db.DropAndCreateTable<ModelWithIdAndName>();
+
+                await db.InsertAllAsync(rows, dbCmd => dbCmd.OnConflictIgnore());
+            }
+        }
+    }
+}