Merge branch 'master' into master-firebird4-support

# Conflicts:
#	ChangeLog/7.1.0-dev.txt

Author: alex-kulakov

ChangeLog/7.1.0-dev.txt

@@ -68,5 +68,13 @@
 [main] CompositePreCompiler.Items became readonly field and changed its type to IReadOnlyList<IPreCompiler>
 [main] SqlCompilerConfiguration's SchemaMapping and DatabaseMapping changed return types to IReadOnlyDictionary<string, string>
 [main] TypeMappingRegistry.Mappings and .ReverseMappings changed return types to IReadOnlyDictionary<TKey, TValue>
+[main] Xtensive.Orm.Services.QueryTranslationResult became read-only structure
+[main] Query and ParameterBindings properties of Xtensive.Orm.Services.QueryTranslationResult changed their types and became read-only
+[main] SqlTranslator.BuildBatch method changed its parameter from string[] to IReadOnlyList<string>
+[main] TypeReference, QueryRequest QueryParameterBinding types became read-only structures
+[main] TypeInfoRef, ColumnInfoRef, ColumnGroup and ComparisonRule types became read-only structures
+[main] RecordSetHeader constructors changed IEnumerable<T> paremters to IReadOnlyList<T>
+[main] ColumnGroupCollection no longer takes IEnumerable<T> as parameter of constructor
+[main] ColumnCollection no longer takes IEnumerable<T> as parameter of constructor, only constructor with IReadOnlyList<T> is available now
 [firebird] Add support for Firebird 4
-[sqlserver] Microsoft.Data.SqlClient is updated to verson 4.0.0
+[sqlserver] Microsoft.Data.SqlClient is updated to verson 4.0.0

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

@@ -51,10 +51,10 @@ protected async override Task<int> ExecuteInternalAsync(CancellationToken token
       }
     }
 
-    private QueryCommand CreateCommand(QueryTranslationResult request)
+    private QueryCommand CreateCommand(in QueryTranslationResult request)
     {
       var delete = SqlDml.Delete(SqlDml.TableRef(PrimaryIndexes[0].Table));
-      Join(delete, (SqlSelect) request.Query);
+      Join(delete, request.Query);
       return ToCommand(delete);
     }
 

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

@@ -54,11 +54,11 @@ protected async override Task<int> ExecuteInternalAsync(CancellationToken token
       }
     }
 
-    private QueryCommand CreateCommand(QueryTranslationResult request)
+    private QueryCommand CreateCommand(in QueryTranslationResult request)
     {
       var update = SqlDml.Update(SqlDml.TableRef(PrimaryIndexes[0].Table));
       setOperation.Statement = SetStatement.Create(update);
-      Join(update, (SqlSelect) request.Query);
+      Join(update, request.Query);
       setOperation.AddValues();
       return ToCommand(update);
     }

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

@@ -103,7 +103,7 @@ private void AddComputedStaticExpression(AddValueContext addContext)
         all,
         addContext.Lambda);
       QueryTranslationResult request = parent.GetRequest(parent.QueryProvider.CreateQuery<T>(selectExpression));
-      var sqlSelect = ((SqlSelect)request.Query);
+      var sqlSelect = request.Query;
       SqlExpression ex = sqlSelect.OrderBy[0].Expression;
       var placeholder = ex as SqlPlaceholder;
       if (placeholder == null)
@@ -133,7 +133,7 @@ private void AddComputedExpression(AddValueContext addContext)
         all,
         addContext.Lambda);
       QueryTranslationResult request = parent.GetRequest(parent.QueryProvider.CreateQuery<T>(selectExpression));
-      var sqlSelect = ((SqlSelect) request.Query);
+      var sqlSelect = request.Query;
       SqlExpression ex = sqlSelect.OrderBy[0].Expression;
       parent.Bindings.AddRange(request.ParameterBindings);
 
@@ -217,7 +217,7 @@ private void AddEntityValue(AddValueContext addContext)
             QueryTranslationResult request = parent.GetRequest(field.ValueType, q);
             parent.Bindings.AddRange(request.ParameterBindings);
             SqlTableColumn c = SqlDml.TableColumn(addContext.Statement.Table, addContext.Field.Columns[i].Name);
-            addContext.Statement.AddValue(c, SqlDml.SubQuery((ISqlQueryExpression) request.Query));
+            addContext.Statement.AddValue(c, SqlDml.SubQuery(request.Query));
           }
           return;
         }

Orm/Xtensive.Orm.Tests/Storage/Prefetch/PrefetchManagerAdvancedTest.cs

@@ -20,6 +20,7 @@
 using Xtensive.Orm.Providers;
 using Xtensive.Orm.Rse.Providers;
 using Xtensive.Orm.Tests.Storage.Prefetch.Model;
+using GraphContainerDictionary = System.Collections.Generic.Dictionary<(Xtensive.Orm.Key key, Xtensive.Orm.Model.TypeInfo type), Xtensive.Orm.Internals.Prefetch.GraphContainer>;
 
 namespace Xtensive.Orm.Tests.Storage.Prefetch
 {
@@ -103,9 +104,9 @@ public void ReferencedEntityHasBeenFullyLoadedBeforeTaskActivationTest()
 
         prefetchManager.InvokePrefetch(order0Key, null, new PrefetchFieldDescriptor(EmployeeField, true, true));
         prefetchManager.InvokePrefetch(order1Key, null, new PrefetchFieldDescriptor(EmployeeField, true, true));
-        var graphContainers = (HashSet<GraphContainer>) GraphContainersField.GetValue(prefetchManager);
+        var graphContainers = (GraphContainerDictionary) GraphContainersField.GetValue(prefetchManager);
         Assert.AreEqual(2, graphContainers.Count);
-        Func<Key, ReferencedEntityContainer> taskSelector = containerKey => graphContainers
+        Func<Key, ReferencedEntityContainer> taskSelector = containerKey => graphContainers.Values
           .Where(container => container.Key==containerKey)
           .SelectMany(container => container.ReferencedEntityContainers).Single();
         var entityContainer0 = taskSelector.Invoke(order0Key);
@@ -180,7 +181,7 @@ public void PrefetchEmptyEntitySetTest()
         var prefetchManager = (PrefetchManager) PrefetchProcessorField.GetValue(session.Handler);
         session.Handler.FetchEntityState(orderKey);
         prefetchManager.InvokePrefetch(orderKey, null, new PrefetchFieldDescriptor(DetailsField, null));
-        var graphContainers = (HashSet<GraphContainer>) GraphContainersField.GetValue(prefetchManager);
+        var graphContainers = (GraphContainerDictionary) GraphContainersField.GetValue(prefetchManager);
         Assert.AreEqual(1, graphContainers.Count);
         prefetchManager.ExecuteTasks(true);
         EntitySetState actualState;
@@ -202,8 +203,8 @@ public void PrefetchReferencedEntityWhenTypeSpecifiedForOwnerIsInvalidTest()
         prefetchManager.InvokePrefetch(keyWithoutType, Domain.Model.Types[typeof (PersonalProduct)],
           new PrefetchFieldDescriptor(Domain.Model.Types[typeof (PersonalProduct)].Fields["Employee"],
             true, true));
-        var graphContainers = (HashSet<GraphContainer>) GraphContainersField.GetValue(prefetchManager);
-        var referencedEntityContainer = graphContainers
+        var graphContainers = (GraphContainerDictionary) GraphContainersField.GetValue(prefetchManager);
+        var referencedEntityContainer = graphContainers.Values
           .Where(container => container.ReferencedEntityContainers!=null).Single()
           .ReferencedEntityContainers.Single();
         prefetchManager.ExecuteTasks(true);
@@ -218,10 +219,10 @@ public void DeletingOfTasksAtTransactionCommitOrRollbackTest()
 
       using (var session = Domain.OpenSession()) {
         var prefetchManager = (PrefetchManager) PrefetchProcessorField.GetValue(session.Handler);
-        HashSet<GraphContainer> graphContainers;
+        GraphContainerDictionary graphContainers;
         using (var tx = session.OpenTransaction()) {
           prefetchManager.InvokePrefetch(orderKey, null, new PrefetchFieldDescriptor(CustomerField));
-          graphContainers = (HashSet<GraphContainer>) GraphContainersField.GetValue(prefetchManager);
+          graphContainers = (GraphContainerDictionary) GraphContainersField.GetValue(prefetchManager);
           Assert.AreEqual(1, graphContainers.Count);
           tx.Complete();
         }
@@ -251,7 +252,7 @@ public void TasksAreExecutedAutomaticallyWhenCountLimitIsReachedTest()
       using (var session = Domain.OpenSession())
       using (var tx = session.OpenTransaction()) {
         var prefetchManager = (PrefetchManager) PrefetchProcessorField.GetValue(session.Handler);
-        var graphContainers = (HashSet<GraphContainer>) GraphContainersField.GetValue(prefetchManager);
+        var graphContainers = (GraphContainerDictionary) GraphContainersField.GetValue(prefetchManager);
         var idField = BookType.Fields["Id"];
         for (var i = 1; i < keys.Count; i++) {
           prefetchManager.InvokePrefetch(keys[i - 1], null, new PrefetchFieldDescriptor(idField));

Orm/Xtensive.Orm.Tests/Storage/Prefetch/PrefetchManagerBasicTest.cs

@@ -20,6 +20,7 @@
 using Xtensive.Orm.Rse;
 using Xtensive.Orm.Services;
 using Xtensive.Orm.Tests.Storage.Prefetch.Model;
+using GraphContainerDictionary = System.Collections.Generic.Dictionary<(Xtensive.Orm.Key key, Xtensive.Orm.Model.TypeInfo type), Xtensive.Orm.Internals.Prefetch.GraphContainer>;
 
 namespace Xtensive.Orm.Tests.Storage.Prefetch
 {
@@ -380,12 +381,12 @@ public void ReferencedEntityByKnownForeignKeyPrefetchTest()
         var prefetchManager = (PrefetchManager) PrefetchProcessorField.GetValue(session.Handler);
 
         prefetchManager.InvokePrefetch(orderKey, null, new PrefetchFieldDescriptor(EmployeeField, true, true));
-        var graphContainers = (HashSet<GraphContainer>) GraphContainersField.GetValue(prefetchManager);
+        var graphContainers = (GraphContainerDictionary) GraphContainersField.GetValue(prefetchManager);
         Assert.AreEqual(2, graphContainers.Count);
-        foreach (var container in graphContainers)
+        foreach (var container in graphContainers.Values)
           Assert.IsNull(container.ReferencedEntityContainers);
-        var orderContainer = graphContainers.Where(container => container.Key==orderKey).SingleOrDefault();
-        var employeeContainer = graphContainers.Where(container => container.Key!=orderKey).SingleOrDefault();
+        var orderContainer = graphContainers.Values.Where(container => container.Key==orderKey).SingleOrDefault();
+        var employeeContainer = graphContainers.Values.Where(container => container.Key!=orderKey).SingleOrDefault();
         Assert.IsNotNull(orderContainer);
         Assert.IsNotNull(employeeContainer);
         prefetchManager.ExecuteTasks();
@@ -431,9 +432,9 @@ public void ReferencedEntityByNullAsForeignKeyPrefetchTest()
         var prefetchManager = (PrefetchManager) PrefetchProcessorField.GetValue(session.Handler);
         session.Handler.FetchEntityState(orderKey);
         prefetchManager.InvokePrefetch(orderKey, null, new PrefetchFieldDescriptor(EmployeeField, true, true));
-        var taskContainers = (HashSet<GraphContainer>) GraphContainersField.GetValue(prefetchManager);
+        var taskContainers = (GraphContainerDictionary) GraphContainersField.GetValue(prefetchManager);
         Assert.AreEqual(1, taskContainers.Count);
-        Assert.AreEqual(orderKey, taskContainers.Single().Key);
+        Assert.AreEqual(orderKey, taskContainers.Values.Single().Key);
       }
     }
 

Orm/Xtensive.Orm.Tests/Storage/Prefetch/PrefetchManagerTestBase.cs

@@ -17,6 +17,7 @@
 using Xtensive.Orm.Tests.Storage.Prefetch.Model;
 using FieldInfo=Xtensive.Orm.Model.FieldInfo;
 using TypeInfo = Xtensive.Orm.Model.TypeInfo;
+using GraphContainerDictionary = System.Collections.Generic.Dictionary<(Xtensive.Orm.Key key, Xtensive.Orm.Model.TypeInfo type), Xtensive.Orm.Internals.Prefetch.GraphContainer>;
 
 namespace Xtensive.Orm.Tests.Storage.Prefetch
 {
@@ -103,7 +104,7 @@ internal static void ValidateLoadedEntitySet(Key key, FieldInfo field, int count
 
     internal GraphContainer GetSingleGraphContainer(PrefetchManager prefetchManager)
     {
-      return ((IEnumerable<GraphContainer>) GraphContainersField.GetValue(prefetchManager)).Single();
+      return ((GraphContainerDictionary) GraphContainersField.GetValue(prefetchManager)).Values.Single();
     }
 
     internal static bool IsFieldKeyOrSystem(FieldInfo field)

Orm/Xtensive.Orm.Tests/Storage/QueryBuilderTest.cs

@@ -56,7 +56,7 @@ public void ModifyQueryTest()
         Assert.That(translated.Query, Is.Not.Null);
         Assert.That(translated.ParameterBindings, Is.Not.Null);
 
-        var select = (SqlSelect) translated.Query;
+        var select = translated.Query;
         select.Columns.Clear();
         select.Columns.Add(SqlDml.Count());
         var compiled = builder.CompileQuery(translated.Query);

Orm/Xtensive.Orm/Caching/WeakestCache.cs

@@ -236,9 +236,7 @@ public override TItem Add(TItem item, bool replaceIfExists)
     public override void RemoveKey(TKey key)
     {
       ArgumentValidator.EnsureArgumentNotNull(key, "key");
-      WeakEntry entry;
-      if (items.TryGetValue(key, out entry)) {
-        items.Remove(key);
+      if (items.Remove(key, out var entry)) {
         entry.Dispose();
       }
     }

Orm/Xtensive.Orm/Collections/ExtensionCollection.cs

@@ -153,12 +153,13 @@ public ExtensionCollection(IExtensionCollection source)
       ArgumentValidator.EnsureArgumentNotNull(source, "source");
       if (source.Count==0)
         return;
-      var sourceLikeMe = source as ExtensionCollection;
-      if (sourceLikeMe!=null)
+      if (source is ExtensionCollection sourceLikeMe) {
         extensions = new Dictionary<Type, object>(sourceLikeMe.extensions);
-      else
+      }
+      else {
         foreach (Type extensionType in source)
           Set(extensionType, source.Get(extensionType));
+      }
     }
   }
 }