CompiledQueryRunner: Improved check whether query is cacheable

Author: alex-kulakov

Orm/Xtensive.Orm/Orm/Internals/CompiledQueryRunner.cs

@@ -5,6 +5,7 @@
 // Created:    2012.01.27
 
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using System.Linq.Expressions;
 using System.Reflection;
@@ -20,14 +21,16 @@ namespace Xtensive.Orm.Internals
 {
   internal class CompiledQueryRunner
   {
-    private static readonly Func<FieldInfo, bool> FieldIsSimple = fieldInfo => IsSimpleType(fieldInfo.FieldType);
+    private static readonly Func<FieldInfo, IReadOnlySet<Type>, bool> IsFieldReadyToCache = (fieldInfo, supportedTypes) =>
+      IsTypeCacheable(fieldInfo.FieldType, supportedTypes);
 
     private readonly Domain domain;
     private readonly Session session;
     private readonly QueryEndpoint endpoint;
     private readonly object queryKey;
     private readonly object queryTarget;
     private readonly ParameterContext outerContext;
+    private readonly IReadOnlySet<Type> supportedTypes;
 
     private Parameter queryParameter;
     private ExtendedExpressionReplacer queryParameterReplacer;
@@ -200,23 +203,49 @@ private bool AllocateParameterAndReplacer()
         return null;
       });
 
+
       return !TypeHelper.IsClosure(closureType)
-        || closureType.GetFields().All(FieldIsSimple);
+        || closureType.GetFields().All(f => IsFieldReadyToCache(f, supportedTypes));
     }
 
-    private static bool IsSimpleType(Type type)
+    private static bool IsTypeCacheable(Type type, IReadOnlySet<Type> supportedTypes)
     {
-      var typeInfo = type.GetTypeInfo();
-      if (typeInfo.IsGenericType) {
-        var genericDef = typeInfo.GetGenericTypeDefinition();
-        return (genericDef == WellKnownTypes.NullableOfT || genericDef.IsAssignableTo(WellKnownTypes.IReadOnlyListOfT))
-          && IsSimpleType(typeInfo.GetGenericArguments()[0]);
+      var type1 = type.StripNullable();
+      if (type1.IsGenericType) {
+        // IReadOnlyList<T> implementations + ValueTuple<> with different number of argument types
+        if (type1.IsValueTuple() && type1.GetGenericArguments().All(t => IsTypeCacheable(t, supportedTypes))) {
+          return true;
+        }
+        var genericDef = type1.GetGenericTypeDefinition();
+        return genericDef.IsAssignableTo(WellKnownTypes.IReadOnlyListOfT) && IsTypeCacheable(type1.GetGenericArguments()[0], supportedTypes);
       }
-      else if (typeInfo.IsArray) {
-        return IsSimpleType(typeInfo.GetElementType());
+      else if (type1.IsArray) {
+        return IsTypeCacheable(type1.GetElementType(), supportedTypes);
       }
       else {
-        return typeInfo.IsPrimitive || typeInfo.IsEnum || type == WellKnownTypes.String || type == WellKnownTypes.Decimal;
+        // enums are handled by their base type so no need to check them
+        return Type.GetTypeCode(type1) switch {
+          TypeCode.Boolean => true,
+          TypeCode.Byte => true,
+          TypeCode.SByte => true,
+          TypeCode.Int16 => true,
+          TypeCode.UInt16 => true,
+          TypeCode.Int32 => true,
+          TypeCode.UInt32 => true,
+          TypeCode.Int64 => true,
+          TypeCode.UInt64 => true,
+          TypeCode.Single => true,
+          TypeCode.Double => true,
+          TypeCode.Decimal => true,
+          TypeCode.Char => true,
+          TypeCode.String => true,
+          TypeCode.DateTime => true,
+          TypeCode.Object => type1 == WellKnownTypes.Guid
+            || type1 == WellKnownTypes.TimeSpan
+            || type1 == WellKnownTypes.DateTimeOffset
+            || supportedTypes.Contains(type1),
+          _ => false
+        };
       }
     }
 
@@ -245,6 +274,7 @@ public CompiledQueryRunner(QueryEndpoint endpoint, object queryKey, object query
       this.queryKey = new Pair<object, string>(queryKey, session.StorageNodeId);
       this.queryTarget = queryTarget;
       this.outerContext = outerContext;
+      supportedTypes = domain.StorageProviderInfo.SupportedTypes;
     }
   }
 }

Orm/Xtensive.Orm/Reflection/TypeHelper.cs

@@ -42,47 +42,42 @@ public int GetHashCode((Type, Type[]) obj)
       }
     }
 
-    private const string invokeMethodName = "Invoke";
-
-    private static readonly ConcurrentDictionary<(Type, Type[]), ConstructorInfo> constructorInfoByTypes =
-      new ConcurrentDictionary<(Type, Type[]), ConstructorInfo>(new TypesEqualityComparer());
+    private const string InvokeMethodName = "Invoke";
 
     private static readonly object EmitLock = new object();
     private static readonly int NullableTypeMetadataToken = WellKnownTypes.NullableOfT.MetadataToken;
-    private static readonly Module NullableTypeModule = WellKnownTypes.NullableOfT.Module;
+    private static readonly int ValueTuple1 = typeof(ValueTuple<>).MetadataToken;
+    private static readonly int ValueTuple8 = typeof(ValueTuple<,,,,,,,>).MetadataToken;
+    private static readonly Module SystemCoreLibModule = WellKnownTypes.NullableOfT.Module;
     private static readonly Type CompilerGeneratedAttributeType = typeof(CompilerGeneratedAttribute);
     private static readonly string TypeHelperNamespace = typeof(TypeHelper).Namespace;
 
-    private static readonly ConcurrentDictionary<Type, Type[]> OrderedInterfaces =
-      new ConcurrentDictionary<Type, Type[]>();
+    private static readonly ConcurrentDictionary<(Type, Type[]), ConstructorInfo> ConstructorInfoByTypes =
+      new(new TypesEqualityComparer());
+
+    private static readonly ConcurrentDictionary<Type, Type[]> OrderedInterfaces = new();
+
+    private static readonly ConcurrentDictionary<Type, Type[]> OrderedCompatibles = new();
+
+    private static readonly ConcurrentDictionary<Pair<Type, Type>, InterfaceMapping> interfaceMaps = new();
 
-    private static readonly ConcurrentDictionary<Type, Type[]> OrderedCompatibles =
-      new ConcurrentDictionary<Type, Type[]>();
+    private static readonly ConcurrentDictionary<(MethodInfo, Type), MethodInfo> GenericMethodInstances1 = new();
 
-    private static readonly ConcurrentDictionary<Pair<Type, Type>, InterfaceMapping> interfaceMaps =
-      new ConcurrentDictionary<Pair<Type, Type>, InterfaceMapping>();
+    private static readonly ConcurrentDictionary<(MethodInfo, Type, Type), MethodInfo> GenericMethodInstances2 = new();
 
-    private static readonly ConcurrentDictionary<(MethodInfo, Type), MethodInfo> GenericMethodInstances1 =
-      new ConcurrentDictionary<(MethodInfo, Type), MethodInfo>();
+    private static readonly ConcurrentDictionary<(Type, Type), Type> GenericTypeInstances1 = new();
+
+    private static readonly ConcurrentDictionary<(Type, Type, Type), Type> GenericTypeInstances2 = new();
 
     private static readonly Func<(MethodInfo genericDefinition, Type typeArgument), MethodInfo> GenericMethodFactory1 =
       key => key.genericDefinition.MakeGenericMethod(key.typeArgument);
 
-    private static readonly ConcurrentDictionary<(MethodInfo, Type, Type), MethodInfo> GenericMethodInstances2 =
-      new ConcurrentDictionary<(MethodInfo, Type, Type), MethodInfo>();
-
     private static readonly Func<(MethodInfo genericDefinition, Type typeArgument1, Type typeArgument2), MethodInfo> GenericMethodFactory2 =
       key => key.genericDefinition.MakeGenericMethod(key.typeArgument1, key.typeArgument2);
 
-    private static readonly ConcurrentDictionary<(Type, Type), Type> GenericTypeInstances1 =
-      new ConcurrentDictionary<(Type, Type), Type>();
-
     private static readonly Func<(Type genericDefinition, Type typeArgument), Type> GenericTypeFactory1 = key =>
       key.genericDefinition.MakeGenericType(key.typeArgument);
 
-    private static readonly ConcurrentDictionary<(Type, Type, Type), Type> GenericTypeInstances2 =
-      new ConcurrentDictionary<(Type, Type, Type), Type>();
-
     private static readonly Func<(Type genericDefinition, Type typeArgument1, Type typeArgument2), Type> GenericTypeFactory2 = key =>
       key.genericDefinition.MakeGenericType(key.typeArgument1, key.typeArgument2);
 
@@ -646,7 +641,7 @@ public static ConstructorInfo GetConstructor(this Type type, object[] arguments)
       GetSingleConstructor(type, arguments.Select(a => a?.GetType()).ToArray());
 
     public static ConstructorInfo GetSingleConstructor(this Type type, Type[] argumentTypes) =>
-      constructorInfoByTypes.GetOrAdd((type, argumentTypes), ConstructorExtractor);
+      ConstructorInfoByTypes.GetOrAdd((type, argumentTypes), ConstructorExtractor);
 
     private static readonly Func<(Type, Type[]), ConstructorInfo> ConstructorExtractor = t => {
       (var type, var argumentTypes) = t;
@@ -899,7 +894,7 @@ private static string GetShortNameBase(this Type type)
     /// <returns><see langword="True"/> if type is nullable type;
     /// otherwise, <see langword="false"/>.</returns>
     public static bool IsNullable(this Type type) =>
-      (type.MetadataToken ^ NullableTypeMetadataToken) == 0 && ReferenceEquals(type.Module, NullableTypeModule);
+      (type.MetadataToken ^ NullableTypeMetadataToken) == 0 && ReferenceEquals(type.Module, SystemCoreLibModule);
 
     /// <summary>
     /// Indicates whether <typeparamref name="T"/> type is a <see cref="Nullable{T}"/> type.
@@ -931,7 +926,7 @@ public static bool IsNullable(this Type type) =>
     /// </summary>
     /// <param name="delegateType">Type of the delegate to get the "Invoke" method of.</param>
     /// <returns><see cref="MethodInfo"/> object describing the delegate "Invoke" method.</returns>
-    public static MethodInfo GetInvokeMethod(this Type delegateType) => delegateType.GetMethod(invokeMethodName);
+    public static MethodInfo GetInvokeMethod(this Type delegateType) => delegateType.GetMethod(InvokeMethodName);
 
 
     /// <summary>
@@ -1167,6 +1162,20 @@ public static bool IsNumericType(this Type type)
       }
     }
 
+    /// <summary>
+    /// Determines whether <paramref name="type"/> is generic form of <see cref="ValueTuple"/>
+    /// </summary>
+    /// <param name="type"></param>
+    /// <returns></returns>
+    internal static bool IsValueTuple(this Type type)
+    {
+      // this stands on the theory that tokens for all generic versions of ValueTuple
+      // go one after another.
+      var currentToken = type.MetadataToken;
+      return ((currentToken >= ValueTuple1) && currentToken <= ValueTuple8)
+        && ReferenceEquals(type.Module, SystemCoreLibModule);
+    }
+
     #region Private \ internal methods
 
     /// <summary>