Merge pull request sqlkata#557 from mathijs-dumon/OracleInsertMany

Fix for Oracle insert many

Author: ahmad-moussawi

QueryBuilder.Tests/Oracle/OracleInsertManyTests.cs

@@ -0,0 +1,61 @@
+using SqlKata.Compilers;
+using SqlKata.Tests.Infrastructure;
+using Xunit;
+
+namespace SqlKata.Tests.Oracle
+{
+    public class OracleInsertManyTests : TestSupport
+    {
+        private const string TableName = "Table";
+        private readonly OracleCompiler compiler;
+
+        public OracleInsertManyTests()
+        {
+            compiler = Compilers.Get<OracleCompiler>(EngineCodes.Oracle);
+        }
+
+        [Fact]
+        public void InsertManyForOracle_ShouldRepeatColumnsAndAddSelectFromDual()
+        {
+            // Arrange:
+            var cols = new[] { "Name", "Price" };
+
+            var data = new[] {
+                new object[] { "A", 1000 },
+                new object[] { "B", 2000 },
+                new object[] { "C", 3000 },
+            };
+
+            var query = new Query(TableName)
+                .AsInsert(cols, data);
+
+
+            // Act:
+            var ctx = compiler.Compile(query);
+
+            // Assert:
+            Assert.Equal($@"INSERT ALL INTO ""{TableName}"" (""Name"", ""Price"") VALUES (?, ?) INTO ""{TableName}"" (""Name"", ""Price"") VALUES (?, ?) INTO ""{TableName}"" (""Name"", ""Price"") VALUES (?, ?) SELECT 1 FROM DUAL", ctx.RawSql);
+        }
+
+        [Fact]
+        public void InsertForOracle_SingleInsertShouldNotAddALLKeywordAndNotHaveSelectFromDual()
+        {
+            // Arrange:
+            var cols = new[] { "Name", "Price" };
+
+            var data = new[] {
+                new object[] { "A", 1000 }
+            };
+
+            var query = new Query(TableName)
+                .AsInsert(cols, data);
+
+
+            // Act:
+            var ctx = compiler.Compile(query);
+
+            // Assert:
+            Assert.Equal($@"INSERT INTO ""{TableName}"" (""Name"", ""Price"") VALUES (?, ?)", ctx.RawSql);
+        }
+    }
+}

QueryBuilder/Compilers/Compiler.cs

@@ -17,6 +17,11 @@ public partial class Compiler
         protected virtual string LastId { get; set; } = "";
         protected virtual string EscapeCharacter { get; set; } = "\\";
 
+
+        protected virtual string SingleInsertStartClause { get; set; } = "INSERT INTO";
+        protected virtual string MultiInsertStartClause { get; set; } = "INSERT INTO";
+
+
         protected Compiler()
         {
             _compileConditionMethodsProvider = new ConditionsCompilerProvider(this);
@@ -391,81 +396,84 @@ protected virtual SqlResult CompileInsertQuery(Query query)
             };
 
             if (!ctx.Query.HasComponent("from", EngineCode))
-            {
                 throw new InvalidOperationException("No table set to insert");
-            }
 
             var fromClause = ctx.Query.GetOneComponent<AbstractFrom>("from", EngineCode);
-
             if (fromClause is null)
-            {
                 throw new InvalidOperationException("Invalid table expression");
-            }
 
             string table = null;
-
             if (fromClause is FromClause fromClauseCast)
-            {
                 table = Wrap(fromClauseCast.Table);
-            }
-
             if (fromClause is RawFromClause rawFromClause)
             {
                 table = WrapIdentifiers(rawFromClause.Expression);
                 ctx.Bindings.AddRange(rawFromClause.Bindings);
             }
 
             if (table is null)
-            {
                 throw new InvalidOperationException("Invalid table expression");
-            }
 
             var inserts = ctx.Query.GetComponents<AbstractInsertClause>("insert", EngineCode);
+            if (inserts[0] is InsertQueryClause insertQueryClause)
+                return CompileInsertQueryClause(ctx, table, insertQueryClause);
+            else
+                return CompileValueInsertClauses(ctx, table, inserts.Cast<InsertClause>());
+        }
 
-            if (inserts[0] is InsertClause insertClause)
-            {
-                var columns = string.Join(", ", WrapArray(insertClause.Columns));
-                var values = string.Join(", ", Parameterize(ctx, insertClause.Values));
+        protected virtual SqlResult CompileInsertQueryClause(
+            SqlResult ctx, string table, InsertQueryClause clause)
+        {
+            string columns = GetInsertColumnsList(clause.Columns);
 
-                ctx.RawSql = $"INSERT INTO {table} ({columns}) VALUES ({values})";
+            var subCtx = CompileSelectQuery(clause.Query);
+            ctx.Bindings.AddRange(subCtx.Bindings);
 
-                if (insertClause.ReturnId && !string.IsNullOrEmpty(LastId))
-                {
-                    ctx.RawSql += ";" + LastId;
-                }
-            }
-            else
-            {
-                var clause = inserts[0] as InsertQueryClause;
+            ctx.RawSql = $"{SingleInsertStartClause} {table}{columns} {subCtx.RawSql}";
 
-                var columns = "";
+            return ctx;
+        }
 
-                if (clause.Columns.Any())
-                {
-                    columns = $" ({string.Join(", ", WrapArray(clause.Columns))}) ";
-                }
+        protected virtual SqlResult CompileValueInsertClauses(
+            SqlResult ctx, string table, IEnumerable<InsertClause> insertClauses)
+        {
+            bool isMultiValueInsert = insertClauses.Skip(1).Any();
 
-                var subCtx = CompileSelectQuery(clause.Query);
-                ctx.Bindings.AddRange(subCtx.Bindings);
+            var insertInto = (isMultiValueInsert) ? MultiInsertStartClause : SingleInsertStartClause;
 
-                ctx.RawSql = $"INSERT INTO {table}{columns}{subCtx.RawSql}";
-            }
+            var firstInsert = insertClauses.First();
+            string columns = GetInsertColumnsList(firstInsert.Columns);
+            var values = string.Join(", ", Parameterize(ctx, firstInsert.Values));
 
-            if (inserts.Count > 1)
-            {
-                foreach (var insert in inserts.GetRange(1, inserts.Count - 1))
-                {
-                    var clause = insert as InsertClause;
+            ctx.RawSql = $"{insertInto} {table}{columns} VALUES ({values})";
 
-                    ctx.RawSql += ", (" + string.Join(", ", Parameterize(ctx, clause.Values)) + ")";
+            if (isMultiValueInsert)
+                return CompileRemainingInsertClauses(ctx, table, insertClauses);
 
-                }
-            }
+            if (firstInsert.ReturnId && !string.IsNullOrEmpty(LastId))
+                ctx.RawSql += ";" + LastId;
 
+            return ctx;
+        }
 
+        protected virtual SqlResult CompileRemainingInsertClauses(SqlResult ctx, string table, IEnumerable<InsertClause> inserts)
+        {
+            foreach (var insert in inserts.Skip(1))
+            {
+                string values = string.Join(", ", Parameterize(ctx, insert.Values));
+                ctx.RawSql += $", ({values})";
+            }
             return ctx;
         }
 
+        protected string GetInsertColumnsList(List<string> columnList)
+        {
+            var columns = "";
+            if (columnList.Any())
+                columns = $" ({string.Join(", ", WrapArray(columnList))})";
+
+            return columns;
+        }
 
         protected virtual SqlResult CompileCteQuery(SqlResult ctx, Query query)
         {

QueryBuilder/Compilers/OracleCompiler.cs

@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
+using System.Text.RegularExpressions;
 
 namespace SqlKata.Compilers
 {
@@ -12,6 +13,7 @@ public OracleCompiler()
             ColumnAsKeyword = "";
             TableAsKeyword = "";
             parameterPrefix = ":p";
+            MultiInsertStartClause = "INSERT ALL INTO";
         }
 
         public override string EngineCode { get; } = EngineCodes.Oracle;
@@ -152,5 +154,23 @@ protected override string CompileBasicDateCondition(SqlResult ctx, BasicDateCond
             return sql;
 
         }
+
+        protected override SqlResult CompileRemainingInsertClauses(
+            SqlResult ctx, string table, IEnumerable<InsertClause> inserts)
+        {
+            foreach (var insert in inserts.Skip(1))
+            {
+                string columns = GetInsertColumnsList(insert.Columns);
+                string values = string.Join(", ", Parameterize(ctx, insert.Values));
+
+                string intoFormat = " INTO {0}{1} VALUES ({2})";
+                var nextInsert = string.Format(intoFormat, table, columns, values);
+
+                ctx.RawSql += nextInsert;
+            }
+
+            ctx.RawSql += " SELECT 1 FROM DUAL";
+            return ctx;
+        }
     }
 }