Proposed improvements before merging into original DO repo (#124)

* Move SqlInsertValuesCollection to Dml.Collections folder

* Add rows collection to SqlInsert

+ mark Values as obsolete

* Test for SqlInsert

* Correct switch from strict number of conditions to default number of conditions

- Return back WellKnown.MaxNumberOfConditions as [Obsolete];
- Add WellKnown.DefaultMaxNumberOfConditions as replacement;
- Initialize MultiRowInsertLevel2BatchSize with
  DefalultMaxNumberOfConditions;

* Proper implementation of DomainConfiguration.MaxNumberOfConditions

- check if configuration instance is locked and deny changing if it is;
- initialized with well-known constant instead of literal value;
- added configuration element to have support for this parameter in
  *.config files

* fix

* Add test for loading of DomainConfiguration with new property from config files

Offtop: tagLocation and other forgotten-to-add properties are tested

* Fix wrong translation of values section

* DomainConfiguration cloning clones MaxNumberOfConditions

* Return original types of properties in IPersistDescriptor

Keeps backwards compatibility

* Multi-row insert not only for 1-column tuples

- adds PersistParameterBinding.RowIndex + ctors to init the value,
  by default row index is 0. This property will keep track of what row
  of SqlPersistTask.Tuples is the source of value
- CommandFactory uses dedicated algorithms for Tuple and for collection
  of Tuples. First one keeps original algorithm before any changes, and
  the second one uses RowIndex to get required row and FieldIndex to
  find value within row
- return original private SqlSessionHandler.Store() method, it works
  without checking for count of values in tuples.

* No use of SqlInsert.Values, SqlInsert.ValueRows

- new InsertSection.NewRow removed, no need in it
- SqlInsert.Values type returned to original Dictionary, removed
  internal collection type and.
- all usages of SqlInsert.Values

* IMultiRecordPersistDescriptor-related changes

- the interface properties renamed
- added lazy alternative for one-row request with default implementation
  to IPersistRecord.StoreRequest. This keeps original interface API and
  have lazy request. TemporaryTableDescriptor uses only lazy properties
  as well as TemporaryTableManager, original StoreRequest implementaion in
  TemporaryTableDescriptor returns Lazy<>.Value and hidded.
- WellKnown constants renamed accordingly to IMultiRecordPersistDescriptor
  properties
- added summaries for interfaces' properties and WellKnown constants

* Rename file containing interfaces

* Remove unused code + commited code

Author: alex-kulakov

Extensions/Xtensive.Orm.BulkOperations/Internals/AddValueContext.cs

@@ -1,3 +1,4 @@
+using System.Collections.Generic;
 using System.Linq.Expressions;
 using Xtensive.Linq;
 using Xtensive.Orm.Model;
@@ -14,9 +15,9 @@ internal class AddValueContext
     public LambdaExpression Lambda { get; set; }
     public SetStatement Statement { get; set; }
 
-    public FieldInfo Field { get; set; }
+    public FieldInfo Field => Descriptor.Field;
 
-    public bool SubqueryExists { get; set; }
+    public Dictionary<SqlColumn, SqlExpression> Values { get; set; }
 
     public object EvalLambdaBody() =>
       Lambda.Body is ConstantExpression ce

Extensions/Xtensive.Orm.BulkOperations/Internals/BaseSqlVisitor.cs

@@ -1,4 +1,5 @@
 using System.Collections.Generic;
+using System.Linq;
 using Xtensive.Sql;
 using Xtensive.Sql.Ddl;
 using Xtensive.Sql.Dml;
@@ -318,10 +319,11 @@ public virtual void Visit(SqlInsert node)
     {
       VisitInternal(node.From);
       VisitInternal(node.Into);
-      foreach (var column in node.Values.Columns) {
-        VisitInternal(column);
-        foreach (var value in node.Values.ValuesByColumn(column)) {
-          VisitInternal(value);
+      
+      foreach(var row in node.ValueRows) {
+        foreach(var columnvalue in row.Zip(node.ValueRows.Columns)) {
+          VisitInternal(columnvalue.Second);
+          VisitInternal(columnvalue.First);
         }
       }
     }

Extensions/Xtensive.Orm.BulkOperations/Internals/SetOperation.cs

@@ -1,4 +1,5 @@
-using System;
+using System;
+using System.Collections.Generic;
 using Xtensive.Sql;
 using Xtensive.Sql.Dml;
 
@@ -20,9 +21,9 @@ public override SqlTable Table
         get { return insert.Into; }
       }
 
-      public override void AddValue(SqlTableColumn column, SqlExpression value)
+      public override void AddValues(Dictionary<SqlColumn, SqlExpression> values)
       {
-        insert.Values.Add(column, value);
+        insert.ValueRows.Add(values);
       }
     }
 
@@ -42,30 +43,33 @@ public override SqlTable Table
         get { return update.Update; }
       }
 
-      public override void AddValue(SqlTableColumn column, SqlExpression value)
+      public override void AddValues(Dictionary<SqlColumn, SqlExpression> values)
       {
-        update.Values.Add(column, value);
+        if (update.Values.Count!=0) {
+          throw new InvalidOperationException("Update values have already been initialized");
+        }
+        foreach (var keyValue in values) {
+          update.Values.Add((SqlTableColumn)keyValue.Key, keyValue.Value);
+        }
       }
     }
 
     #endregion
 
     private SqlQueryStatement statement;
 
-    public static SetStatement Create(SqlQueryStatement statement)
+    public static SetStatement Create(SqlUpdate updateStatement)
     {
-      SetStatement result;
-      if (statement is SqlUpdate)
-        result = new Update();
-      else if (statement is SqlInsert)
-        result = new Insert();
-      else
-        throw new InvalidOperationException("Statement must be SqlUpdate or SqlInsert");
-      result.statement = statement;
-      return result;
+      return new Update() { statement = updateStatement };
+    }
+
+    public static SetStatement Create(SqlInsert insertStatement)
+    {
+      return new Insert() { statement = insertStatement };
     }
 
     public abstract SqlTable Table { get; }
-    public abstract void AddValue(SqlTableColumn column, SqlExpression value);
+
+    public abstract void AddValues(Dictionary<SqlColumn, SqlExpression> values);
   }
 }

Extensions/Xtensive.Orm.BulkOperations/Internals/SetStatement.cs

@@ -1,4 +1,4 @@
-// Copyright (C) 2020 Xtensive LLC.
+// Copyright (C) 2020-2023 Xtensive LLC.
 // This code is distributed under MIT license terms.
 // See the License.txt file in the project root for more information.
 
@@ -16,7 +16,9 @@ internal static class WellKnownMembers
     public static readonly Type FuncOfTArgTResultType = typeof(Func<,>);
 
     public static readonly Type IncludeAlgorithmType = typeof(IncludeAlgorithm);
+    public static readonly Type QueryableType = typeof(Queryable);
     public static readonly Type QueryableExtensionsType = typeof(QueryableExtensions);
+
     public const string InMethodName = nameof(QueryableExtensions.In);
 
     public static readonly MethodInfo TranslateQueryMethod =

Extensions/Xtensive.Orm.BulkOperations/Internals/WellKnownMembers.cs

@@ -1,11 +1,13 @@
-// Copyright (C) 2008-2021 Xtensive LLC.
+// Copyright (C) 2008-2023 Xtensive LLC.
 // This code is distributed under MIT license terms.
 // See the License.txt file in the project root for more information.
 // Created by: Alex Yakunin
 // Created:    2008.02.09
 
 using System;
+using System.Collections.Generic;
 using System.Threading;
+using Xtensive.Sql.Dml;
 
 namespace Xtensive.Orm.Tests
 {
@@ -82,5 +84,16 @@ public static DateTime FixDateTimeForProvider(this DateTime origin, StorageProvi
       var newTicks = ticks - (ticks % divider.Value);
       return new DateTime(newTicks);
     }
+
+    public static void AddValueRow(this SqlInsert insert, in (SqlColumn column, SqlExpression value) first, params (SqlColumn column, SqlExpression value)[] additional)
+    {
+      var additional1 = additional ?? Array.Empty<(SqlColumn,SqlExpression)>();
+      var row = new Dictionary<SqlColumn, SqlExpression>(1 + additional1.Length);
+      row.Add(first.column, first.value);
+      foreach (var keyValue in additional1) {
+        row.Add(keyValue.column, keyValue.value);
+      }
+      insert.ValueRows.Add(row);
+    }
   }
 }

Orm/Xtensive.Orm.Tests.Framework/TestHelper.cs

@@ -1,4 +1,4 @@
-// Copyright (C) 2019-2022 Xtensive LLC.
+// Copyright (C) 2019-2023 Xtensive LLC.
 // This code is distributed under MIT license terms.
 // See the License.txt file in the project root for more information.
 // Created by: Alexey Kulakov
@@ -325,13 +325,14 @@ private static void ExecuteInsert(SqlConnection connection, Table table, Diction
     {
       var tableRef = SqlDml.TableRef(table);
       var insertQuery = SqlDml.Insert(tableRef);
+      var row = new Dictionary<SqlColumn, SqlExpression>(values.Count);
       foreach (var nameValue in values) {
         var value = nameValue.Value != null
           ? (SqlExpression) SqlDml.Literal(nameValue.Value)
           : SqlDml.Null;
-        insertQuery.Values.Add(tableRef[nameValue.Key], value);
+        row.Add(tableRef[nameValue.Key], value);
       }
-
+      insertQuery.ValueRows.Add(row);
       using var command = connection.CreateCommand(insertQuery);
       Console.WriteLine(command.CommandText);
       _ = command.ExecuteNonQuery();

Orm/Xtensive.Orm.Tests.Sql/ChinookSchemaCreator.cs

@@ -1,6 +1,6 @@
-// Copyright (C) 2003-2010 Xtensive LLC.
-// All rights reserved.
-// For conditions of distribution and use, see license.
+// Copyright (C) 2003-2023 Xtensive LLC.
+// This code is distributed under MIT license terms.
+// See the License.txt file in the project root for more information.
 
 using NUnit.Framework;
 using System;
@@ -598,18 +598,19 @@ public void SqlInsertCloneTest()
     {
       SqlTableRef t = SqlDml.TableRef(table1);
       SqlInsert i = SqlDml.Insert(t);
-      i.Values.SetValueByColumn(t[0], 1);
-      i.Values.SetValueByColumn(t[1], "Anonym");
+      i.AddValueRow(( t[0], 1 ), ( t[1], "Anonym" ));
       i.Hints.Add(SqlDml.FastFirstRowsHint(10));
       SqlInsert iClone = (SqlInsert)i.Clone();
 
       Assert.AreNotEqual(i, iClone);
       Assert.AreNotEqual(i.Into, iClone.Into);
       Assert.AreEqual(i.NodeType, iClone.NodeType);
-      Assert.AreEqual(i.Values.Count, iClone.Values.Count);
-      foreach (var column in i.Values.Columns) {
-        Assert.IsFalse(iClone.Values.ContainsColumn(column));
-        Assert.IsFalse(i.Values.ValuesByColumn(column).Any(v => iClone.Values.ContainsValue(v)));
+      Assert.AreEqual(i.ValueRows.Count, iClone.ValueRows.Count);
+      Assert.AreEqual(i.ValueRows.Columns.Count, iClone.ValueRows.Columns.Count);
+      for(var indx = 0; indx < i.ValueRows.Count; indx++) {
+        var iRow = i.ValueRows[indx];
+        var iClonedRow = iClone.ValueRows[indx];
+        Assert.IsFalse(iRow.SequenceEqual(iClonedRow));
       }
       Assert.AreEqual(i.Hints.Count, iClone.Hints.Count);
     }