Small improvements

- ExpressionComparer uses zipping without Funcs, ValueTuple used instead
- SubqueryDefalutResultRewriter uses type cast only when needed
- Translator.ConstructQueryable is optimized to not have making generic type,
  it uses already given type by methodcallexpression. Additionally, by having
  overload that gets element type, we skip MethodCallExpression construction.
- Small improvements in Translator.VisitSequence. Less operations for checking
  for entity set and no double search for type
- typeof (Func<>) is cached within Translator
- Small improvement for Union/Concat/Intersect/etc. operations by getting
  rid of extra enumerations
- RecordSetHeader.Add(IReadOnlyList<Column>) substitutes counterpart with
  IEnumerable<Column> which produce less memory fluctuations.
- RecordSetHeader.Add(Column) also doesn't use IEnumerable

Author: alex-kulakov

Orm/Xtensive.Orm/Linq/Internals/ExpressionComparer.cs

@@ -111,7 +111,7 @@ private bool VisitListInit(ListInitExpression x, ListInitExpression y)
       return VisitNew(x.NewExpression, y.NewExpression)
         && x.Initializers.Count==y.Initializers.Count
         && x.Initializers
-          .Zip(y.Initializers, (first, second) => new Pair<ElementInit>(first, second))
+          .Zip(y.Initializers)
           .All(p => VisitElementInit(p.First, p.Second));
     }
 
@@ -126,7 +126,7 @@ private bool VisitMemberInit(MemberInitExpression x, MemberInitExpression y)
       return VisitNew(x.NewExpression, y.NewExpression)
         && x.Bindings.Count==y.Bindings.Count
         && x.Bindings
-          .Zip(y.Bindings, (first, second) => new Pair<MemberBinding>(first, second))
+          .Zip(y.Bindings)
           .All(p => VisitMemberBinding(p.First, p.Second));
     }
 
@@ -145,14 +145,14 @@ private bool VisitMemberBinding(MemberBinding x, MemberBinding y)
           var mby = (MemberMemberBinding)y;
           return mbx.Bindings.Count==mby.Bindings.Count
                  && mbx.Bindings
-                    .Zip(mby.Bindings, (first, second) => new Pair<MemberBinding>(first, second))
+                    .Zip(mby.Bindings)
                     .All(p => VisitMemberBinding(p.First, p.Second));
         case MemberBindingType.ListBinding:
           var mlx = (MemberListBinding)x;
           var mly = (MemberListBinding)y;
           return mlx.Initializers.Count==mly.Initializers.Count
                  && mlx.Initializers
-                    .Zip(mly.Initializers, (first, second) => new Pair<ElementInit>(first, second))
+                    .Zip(mly.Initializers)
                     .All(p => VisitElementInit(p.First, p.Second));
         default:
           throw new ArgumentOutOfRangeException();
@@ -189,7 +189,7 @@ private bool VisitNew(NewExpression x, NewExpression y)
         return false;
       if (x.Members.Count != y.Members.Count)
         return false;
-      for (int i = 0; i < x.Members.Count; i++)
+      for (int i = 0, count = x.Members.Count; i < count; i++)
         if (x.Members[i] != y.Members[i])
           return false;
       return true;
@@ -253,7 +253,7 @@ private bool CompareExpressionSequences<T>(
     {
       if (x.Count != y.Count)
         return false;
-      for (int i = 0; i < x.Count; i++)
+      for (int i = 0, count = x.Count; i < count; i++)
         if (!Visit(x[i], y[i]))
           return false;
       return true;

Orm/Xtensive.Orm/Orm/Linq/Rewriters/SubqueryDefaultResultRewriter.cs

@@ -33,9 +33,11 @@ private static Expression ApplyCorrection(Expression originalExpression)
       if (expression.NodeType == ExpressionType.Convert) {
         expression = ((UnaryExpression) expression).Operand;
       }
+      if (expression.NodeType is not ExpressionType.Call)
+        return originalExpression;
 
       var methodCall = expression as MethodCallExpression;
-      if (methodCall == null || !IsDefaultingMethod(methodCall.Method) || !HasNonNullDefault(methodCall.Type)) {
+      if (!IsDefaultingMethod(methodCall.Method) || !HasNonNullDefault(methodCall.Type)) {
         return originalExpression;
       }
 

Orm/Xtensive.Orm/Orm/Linq/Translator.Expressions.cs

@@ -1274,13 +1274,23 @@ private static bool ContainsEntityExpression(Expression expression)
     private Expression ConstructQueryable(MethodCallExpression mc)
     {
       var elementType = mc.Method.GetGenericArguments()[0];
-      TypeInfo type;
-      if (!context.Model.Types.TryGetValue(elementType, out type))
-        throw new InvalidOperationException(String.Format(Strings.ExTypeNotFoundInModel, elementType.FullName));
+      if (!context.Model.Types.TryGetValue(elementType, out var type))
+        throw new InvalidOperationException(string.Format(Strings.ExTypeNotFoundInModel, elementType.FullName));
       var index = type.Indexes.PrimaryIndex;
       var entityExpression = EntityExpression.Create(type, 0, false);
       var itemProjector = new ItemProjectorExpression(entityExpression, index.GetQuery(), context);
-      return new ProjectionExpression(WellKnownInterfaces.QueryableOfT.MakeGenericType(elementType), itemProjector, new Dictionary<Parameter<Tuple>, Tuple>());
+      return new ProjectionExpression(mc.Type, itemProjector, new Dictionary<Parameter<Tuple>, Tuple>());
+    }
+
+    private Expression ConstructQueryable(Type elementType)
+    {
+      if (!context.Model.Types.TryGetValue(elementType, out var type))
+        throw new InvalidOperationException(string.Format(Strings.ExTypeNotFoundInModel, elementType.FullName));
+      var index = type.Indexes.PrimaryIndex;
+      var entityExpression = EntityExpression.Create(type, 0, false);
+      var itemProjector = new ItemProjectorExpression(entityExpression, index.GetQuery(), context);
+      return new ProjectionExpression(WellKnownInterfaces.QueryableOfT.MakeGenericType(elementType),
+        itemProjector, new Dictionary<Parameter<Tuple>, Tuple>());
     }
 
     private Expression BuildSubqueryResult(ProjectionExpression subQuery, Type resultType)

Orm/Xtensive.Orm/Orm/Linq/Translator.Materialization.cs

@@ -212,10 +212,9 @@ private ProjectionExpression GetIndexBinding(LambdaExpression le, ref Projection
     private Expression VisitQuerySingle(MethodCallExpression mc)
     {
       var returnType = mc.Method.ReturnType;
-
       var argument = mc.Arguments[0];
-      var queryAll = Expression.Call(null, WellKnownMembers.Query.All.MakeGenericMethod(returnType));
-      var source = ConstructQueryable(queryAll);
+
+      var source = ConstructQueryable(returnType);
       var parameter = Expression.Parameter(returnType, "entity");
       var keyAccessor = Expression.MakeMemberAccess(parameter, WellKnownMembers.IEntityKey);
       var equility = Expression.Equal(keyAccessor, argument);

Orm/Xtensive.Orm/Orm/Linq/Translator.Queryable.cs

@@ -27,6 +27,7 @@ namespace Xtensive.Orm.Linq
   internal sealed partial class Translator : QueryableVisitor
   {
     private static readonly Type IEnumerableOfKeyType = typeof(IEnumerable<Key>);
+    private static readonly Type GenericFuncDefType = typeof(Func<>);
 
     public TranslatorState state;
     private readonly TranslatorContext context;
@@ -1570,22 +1571,27 @@ private Expression VisitSetOperations(Expression outerSource, Expression innerSo
       var innerItemProjector = inner.ItemProjector.RemoveOwner();
       var outerColumnList = outerItemProjector.GetColumns(ColumnExtractionModes.Distinct);
       var innerColumnList = innerItemProjector.GetColumns(ColumnExtractionModes.Distinct);
+
+      int[] outerColumns, innerColumns;
       if (!outerColumnList.Except(innerColumnList).Any() && outerColumnList.Count == innerColumnList.Count) {
-        var outerColumnListCopy = outerColumnList.ToList();
-        outerColumnListCopy.Sort();
-        outerColumnList = outerColumnListCopy;
+        var outerColumnListCopy = outerColumnList.ToArray();
+        Array.Sort(outerColumnListCopy);
+        outerColumns = outerColumnListCopy;
 
-        var innerColumnListCopy = innerColumnList.ToList();
-        innerColumnListCopy.Sort();
-        innerColumnList = innerColumnListCopy;
+        var innerColumnListCopy = innerColumnList.ToArray();
+        Array.Sort(innerColumnListCopy);
+        innerColumns = innerColumnListCopy;
+      }
+      else {
+        outerColumns = outerColumnList.ToArray();
+        innerColumns = innerColumnList.ToArray();
       }
 
-      var outerColumns = outerColumnList.ToArray();
-      var outerRecordSet = ShouldWrapDataSourceWithSelect(outerItemProjector, outerColumnList)
+      var outerRecordSet = ShouldWrapDataSourceWithSelect(outerItemProjector, outerColumns)
         ? outerItemProjector.DataSource.Select(outerColumns)
         : outerItemProjector.DataSource;
-      var innerRecordSet = ShouldWrapDataSourceWithSelect(innerItemProjector, innerColumnList)
-        ? innerItemProjector.DataSource.Select(innerColumnList.ToArray())
+      var innerRecordSet = ShouldWrapDataSourceWithSelect(innerItemProjector, innerColumns)
+        ? innerItemProjector.DataSource.Select(innerColumns)
         : innerItemProjector.DataSource;
 
       var recordSet = outerItemProjector.DataSource;
@@ -1647,24 +1653,21 @@ private ProjectionExpression VisitSequence(Expression sequenceExpression, Expres
           Strings.ExDirectQueryingForEntitySetInCompiledQueriesIsNotSupportedUseQueryEndpointItemsInstead);
       }
 
-      if (sequence.GetMemberType() == MemberType.EntitySet) {
+      if (WellKnownOrmTypes.EntitySetBase.IsAssignableFrom(sequence.StripMarkers().Type)) {
         if (sequence.NodeType == ExpressionType.MemberAccess) {
           var memberAccess = (MemberExpression) sequence;
           if (memberAccess.Member is PropertyInfo propertyInfo
             && memberAccess.Expression != null
-            && context.Model.Types.Contains(memberAccess.Expression.Type)) {
-            var field = context
-              .Model
-              .Types[memberAccess.Expression.Type]
+            && context.Model.Types.TryGetValue(memberAccess.Expression.Type, out var ti)) {
+            var field = ti
               .Fields[context.Domain.Handlers.NameBuilder.BuildFieldName(propertyInfo)];
             sequenceExpression = QueryHelper.CreateEntitySetQuery(memberAccess.Expression, field, context.Domain);
           }
         }
       }
 
       if (sequence.IsLocalCollection(context)) {
-        var sequenceType = (sequence.Type.IsGenericType
-          && sequence.Type.GetGenericTypeDefinition() == typeof(Func<>))
+        var sequenceType = sequence.Type.IsGenericType && sequence.Type.IsOfGenericType(GenericFuncDefType)
           ? sequence.Type.GetGenericArguments()[0]
           : sequence.Type;
 

Orm/Xtensive.Orm/Orm/Rse/RecordSetHeader.cs

@@ -96,7 +96,18 @@ public RecordSetHeader Alias(string alias)
     /// <returns>The constructed header.</returns>
     public RecordSetHeader Add(Column column)
     {
-      return Add(EnumerableUtils.One(column));
+      var newColumns = new List<Column>(Columns.Count + 1);
+      newColumns.AddRange(Columns);
+      newColumns.Add(column);
+
+      var newTupleDescriptor = CreateTupleDescriptor(newColumns);
+
+      return new RecordSetHeader(
+        newTupleDescriptor,
+        newColumns,
+        ColumnGroups,
+        OrderTupleDescriptor,
+        Order);
     }
 
     /// <summary>
@@ -109,10 +120,28 @@ public RecordSetHeader Add(IEnumerable<Column> columns)
       var newColumns = new List<Column>(Columns);
       newColumns.AddRange(columns);
 
-      var newFieldTypes = new Type[newColumns.Count];
-      for (var i = 0; i < newColumns.Count; i++)
-        newFieldTypes[i] = newColumns[i].Type;
-      var newTupleDescriptor = TupleDescriptor.Create(newFieldTypes);
+      var newTupleDescriptor = CreateTupleDescriptor(newColumns);
+
+      return new RecordSetHeader(
+        newTupleDescriptor,
+        newColumns,
+        ColumnGroups,
+        OrderTupleDescriptor,
+        Order);
+    }
+
+    /// <summary>
+    /// Adds the specified columns to header.
+    /// </summary>
+    /// <param name="columns">The columns to add.</param>
+    /// <returns>The constructed header.</returns>
+    public RecordSetHeader Add(IReadOnlyList<Column> columns)
+    {
+      var newColumns = new List<Column>(Columns.Count + columns.Count);
+      newColumns.AddRange(Columns);
+      newColumns.AddRange(columns);
+
+      var newTupleDescriptor = CreateTupleDescriptor(newColumns);
 
       return new RecordSetHeader(
         newTupleDescriptor,
@@ -136,10 +165,7 @@ public RecordSetHeader Join(RecordSetHeader joined)
         newColumns.Add(c.Clone(columnCount + c.Index));
       }
 
-      var newFieldTypes = new Type[newColumns.Count];
-      for (var i = 0; i < newColumns.Count; i++)
-        newFieldTypes[i] = newColumns[i].Type;
-      var newTupleDescriptor = TupleDescriptor.Create(newFieldTypes);
+      var newTupleDescriptor = CreateTupleDescriptor(newColumns);
 
       var columnGroupCount = ColumnGroups.Count;
       var groups = new List<ColumnGroup>(columnGroupCount + joined.ColumnGroups.Count);
@@ -282,6 +308,16 @@ private static RecordSetHeader CreateHeader(IndexInfo indexInfo)
         order);
     }
 
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+    private static TupleDescriptor CreateTupleDescriptor(List<Column> newColumns)
+    {
+      var newFieldTypes = new Type[newColumns.Count];
+      for (var i = 0; i < newColumns.Count; i++) {
+        newFieldTypes[i] = newColumns[i].Type;
+      }
+      return TupleDescriptor.Create(newFieldTypes);
+    }
+
     /// <inheritdoc/>
     public override string ToString()
     {