Add cache of root method call expressions

For every Query.All<T> one .MakeGenericMethod required and the result is only visited.
The same root expressions are re-used many times during domain lifetime
The number of items in the cache is finite and limit is the number of entities and interfaces
in domain model (auxilary types included). In future we may change type of cache from concurrent
dictionary to LRU cache and limit it to have only hot query roots represented

Author: alex-kulakov

Orm/Xtensive.Orm/Orm/Domain.cs

@@ -125,6 +125,8 @@ public static Domain Demand()
 
     internal ICache<Key, Key> KeyCache { get; private set; }
 
+    internal ConcurrentDictionary<Type, System.Linq.Expressions.MethodCallExpression> RootCallExpressionsCache { get; private set; }
+
     internal object UpgradeContextCookie { get; private set; }
 
     internal SqlConnection SingleConnection { get; private set; }
@@ -423,6 +425,7 @@ internal Domain(DomainConfiguration configuration, object upgradeContextCookie,
       PrefetchFieldDescriptorCache = new ConcurrentDictionary<TypeInfo, ReadOnlyList<PrefetchFieldDescriptor>>();
       KeyCache = new LruCache<Key, Key>(Configuration.KeyCacheSize, k => k);
       QueryCache = new FastConcurrentLruCache<object, Pair<object, ParameterizedQuery>>(Configuration.QueryCacheSize, k => k.First);
+      RootCallExpressionsCache = new ConcurrentDictionary<Type, System.Linq.Expressions.MethodCallExpression>();
       PrefetchActionMap = new Dictionary<TypeInfo, Action<SessionHandler, IEnumerable<Key>>>();
       Extensions = new ExtensionCollection();
       UpgradeContextCookie = upgradeContextCookie;

Orm/Xtensive.Orm/Orm/EntitySet{T}.cs

@@ -225,14 +225,14 @@ public Expression Expression
     /// <inheritdoc/>
     protected sealed override Func<QueryEndpoint,Int64> GetItemCountQueryDelegate(FieldInfo field)
     {
-      return qe => GetItemsQuery(qe, field).LongCount();
+      return qe => GetItemsQuery(qe, field, this.Session.Domain).LongCount();
     }
 
-    private static IQueryable<TItem> GetItemsQuery(QueryEndpoint qe, FieldInfo field)
+    private static IQueryable<TItem> GetItemsQuery(QueryEndpoint qe, FieldInfo field, Domain domain)
     {
       var owner = Expression.Property(Expression.Constant(ownerParameter), ownerParameter.GetType()
         .GetProperty("Value", WellKnownOrmTypes.Entity));
-      var queryExpression = QueryHelper.CreateEntitySetQuery(owner, field);
+      var queryExpression = QueryHelper.CreateEntitySetQuery(owner, field, domain);
       return qe.Provider.CreateQuery<TItem>(queryExpression);
     }
 

Orm/Xtensive.Orm/Orm/Linq/QueryHelper.cs

@@ -63,10 +63,9 @@ public static Expression<Func<Tuple, bool>> BuildFilterLambda(int startIndex, IR
       return FastExpression.Lambda<Func<Tuple, bool>>(filterExpression, TupleParameter);
     }
 
-    private static Expression CreateEntityQuery(Type elementType)
+    private static Expression CreateEntityQuery(Type elementType, Domain domain)
     {
-      var queryAll = WellKnownMembers.Query.All.MakeGenericMethod(elementType);
-      return Expression.Call(null, queryAll);
+      return domain.RootCallExpressionsCache.GetOrAdd(elementType, (t) => Expression.Call(null, WellKnownMembers.Query.All.MakeGenericMethod(elementType)));
     }
 
     public static bool IsDirectEntitySetQuery(Expression entitySet)
@@ -106,7 +105,7 @@ public static Expression CreateDirectEntitySetQuery(EntitySetBase entitySet)
       return Expression.Convert(Expression.Call(Expression.Constant(owner),indexers.Single(), new []{Expression.Constant(entitySet.Field.Name)}), entitySet.Field.ValueType);
     }
 
-    public static Expression CreateEntitySetQuery(Expression ownerEntity, FieldInfo field)
+    public static Expression CreateEntitySetQuery(Expression ownerEntity, FieldInfo field, Domain domain)
     {
       if (!field.IsDynamicallyDefined && !field.UnderlyingProperty.PropertyType.IsOfGenericType(WellKnownOrmTypes.EntitySetOfT)) {
         throw Exceptions.InternalError(Strings.ExFieldMustBeOfEntitySetType, OrmLog.Instance);
@@ -131,7 +130,7 @@ public static Expression CreateEntitySetQuery(Expression ownerEntity, FieldInfo
           );
         return Expression.Call(
           WellKnownMembers.Queryable.Where.MakeGenericMethod(elementType),
-          CreateEntityQuery(elementType),
+          CreateEntityQuery(elementType, domain),
           FastExpression.Lambda(whereExpression, whereParameter)
           );
       }
@@ -156,7 +155,7 @@ public static Expression CreateEntitySetQuery(Expression ownerEntity, FieldInfo
 
       var outerQuery = Expression.Call(
         WellKnownMembers.Queryable.Where.MakeGenericMethod(connectorType),
-        CreateEntityQuery(connectorType),
+        CreateEntityQuery(connectorType, domain),
         FastExpression.Lambda(filterExpression, filterParameter)
         );
 
@@ -168,7 +167,7 @@ public static Expression CreateEntitySetQuery(Expression ownerEntity, FieldInfo
       var innerSelector = FastExpression.Lambda(innerSelectorParameter, innerSelectorParameter);
       var resultSelector = FastExpression.Lambda(innerSelectorParameter, outerSelectorParameter, innerSelectorParameter);
 
-      var innerQuery = CreateEntityQuery(elementType);
+      var innerQuery = CreateEntityQuery(elementType, domain);
       var joinMethodInfo = WellKnownMembers.Queryable.Join
         .MakeGenericMethod(new[] {
           connectorType,

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

@@ -1657,7 +1657,7 @@ private ProjectionExpression VisitSequence(Expression sequenceExpression, Expres
               .Model
               .Types[memberAccess.Expression.Type]
               .Fields[context.Domain.Handlers.NameBuilder.BuildFieldName(propertyInfo)];
-            sequenceExpression = QueryHelper.CreateEntitySetQuery(memberAccess.Expression, field);
+            sequenceExpression = QueryHelper.CreateEntitySetQuery(memberAccess.Expression, field, context.Domain);
           }
         }
       }
@@ -1684,7 +1684,7 @@ private ProjectionExpression VisitSequence(Expression sequenceExpression, Expres
       if (visitedExpression.IsEntitySetExpression()) {
         var entitySetExpression = (EntitySetExpression) visitedExpression;
         var entitySetQuery =
-          QueryHelper.CreateEntitySetQuery((Expression) entitySetExpression.Owner, entitySetExpression.Field);
+          QueryHelper.CreateEntitySetQuery((Expression) entitySetExpression.Owner, entitySetExpression.Field, context.Domain);
         result = (ProjectionExpression) Visit(entitySetQuery);
       }
 

Orm/Xtensive.Orm/Orm/QueryEndpoint.cs

@@ -938,7 +938,7 @@ private Expression BuildRootExpression(Type elementType)
     {
       return RootBuilder!=null
         ? RootBuilder.BuildRootExpression(elementType)
-        : Expression.Call(null, WellKnownMembers.Query.All.MakeGenericMethod(elementType));
+        : session.Domain.RootCallExpressionsCache.GetOrAdd(elementType, (t) => Expression.Call(null, WellKnownMembers.Query.All.MakeGenericMethod(t)));
     }
 
     #endregion