Optmize BuildFieldCheck: avoid double-calculation of field.ValueType.ToNullable() (#265)

* Optmize `BuildFieldCheck`: avoid double-calculation of `field.ValueType.ToNullable()`

* Optimize ToConstantExpression()

* Rename to StructDefaultConstantExpressions

* Optimize BindParameters()

* Optimize BindParameters()

* Optimize BindParameters()

* Simplify

* Fix ToConstantExpression

Author: SergeiPavlov

Orm/Xtensive.Orm/Core/Extensions/ExpressionExtensions.cs

@@ -22,7 +22,7 @@ namespace Xtensive.Core
   /// </summary>
   public static class ExpressionExtensions
   {
-    private readonly static ConcurrentDictionary<Type, object> StructDefaultValues = new();
+    private readonly static ConcurrentDictionary<Type, ConstantExpression> StructDefaultConstantExpressions = new();
 
     /// <summary>
     /// Formats the <paramref name="expression"/>.
@@ -73,26 +73,31 @@ public static bool IsNull(this Expression expression)
     /// <exception cref="InvalidOperationException">Something went wrong :(.</exception>
     public static Expression BindParameters(this LambdaExpression lambdaExpression, params Expression[] parameters)
     {
-      if (lambdaExpression.Parameters.Count!=parameters.Length)
+      var lambdaExpressionParameters = lambdaExpression.Parameters;
+      var lambdaExpressionParametersCount = lambdaExpressionParameters.Count;
+      if (lambdaExpressionParametersCount != parameters.Length)
         throw new InvalidOperationException(String.Format(
           Strings.ExUnableToBindParametersToLambdaXParametersCountIsIncorrect,
           lambdaExpression.ToString(true)));
-      if (parameters.Length==0)
+      if (parameters.Length == 0)
         return lambdaExpression;
       var convertedParameters = new Expression[parameters.Length];
-      for (int i = 0; i < lambdaExpression.Parameters.Count; i++) {
-        var expressionParameter = lambdaExpression.Parameters[i];
-        if (expressionParameter.Type.IsAssignableFrom(parameters[i].Type))
-          convertedParameters[i] = expressionParameter.Type==parameters[i].Type
-            ? parameters[i]
-            : Expression.Convert(parameters[i], expressionParameter.Type);
+      for (int i = 0; i < lambdaExpressionParametersCount; i++) {
+        var expressionParameter = lambdaExpressionParameters[i];
+        var parameter = parameters[i];
+        var parameterType = parameter.Type;
+        var expressionParameterType = expressionParameter.Type;
+        if (expressionParameterType.IsAssignableFrom(parameterType))
+          convertedParameters[i] = expressionParameterType == parameterType
+            ? parameter
+            : Expression.Convert(parameter, expressionParameterType);
         else
           throw new InvalidOperationException(String.Format(
             Strings.ExUnableToUseExpressionXAsXParameterOfLambdaXBecauseOfTypeMistmatch,
-            parameters[i].ToString(true), i, lambdaExpression.Parameters[i].ToString(true)));
+            parameters[i].ToString(true), i, expressionParameter.ToString(true)));
       }
       return ExpressionReplacer.ReplaceAll(
-        lambdaExpression.Body, lambdaExpression.Parameters, convertedParameters);
+        lambdaExpression.Body, lambdaExpressionParameters, convertedParameters);
     }
 
     /// <summary>
@@ -121,28 +126,15 @@ public static Expression ToExpression(this SerializableExpression expression)
     /// </summary>
     /// <param name="defaultExpression">The expression to convert.</param>
     /// <returns>Result constant expression.</returns>
-    public static ConstantExpression ToConstantExpression(this DefaultExpression defaultExpression)
-    {
-      var value = GetDefaultValue(defaultExpression);
-
-      return Expression.Constant(value, defaultExpression.Type);
-    }
-
-    /// <summary>
-    /// Gets the value represented by given <see cref="DefaultExpression"/>.
-    /// </summary>
-    /// <param name="defaultExpression">The default value expression.</param>
-    /// <returns>Object value of default value.</returns>
-    public static object GetDefaultValue(this DefaultExpression defaultExpression)
-    {
-      if (defaultExpression.Type.IsValueType) {
-        return StructDefaultValues.GetOrAdd<DefaultExpression>(
-          defaultExpression.Type,
-          (type, expr) => { return ((Func<object>) Expression.Lambda(Expression.Convert(expr, WellKnownTypes.Object)).Compile()).Invoke(); },
-          defaultExpression);
-      }
-      return null;
-    }
+    public static ConstantExpression ToConstantExpression(this DefaultExpression defaultExpression) =>
+      StructDefaultConstantExpressions.GetOrAdd(
+        defaultExpression.Type,
+        static (t, expr) => Expression.Constant(
+          t.IsValueType
+            ? ((Func<object>) Expression.Lambda(Expression.Convert(expr, WellKnownTypes.Object)).Compile()).Invoke()
+            : null,
+          t),
+        defaultExpression);
 
     /// <summary>
     /// Gets return type of <see cref="LambdaExpression"/>.
@@ -318,4 +310,4 @@ public static Expression StripMemberAccessChain(this Expression expression)
 
     #endregion
   }
-}
+}

Orm/Xtensive.Orm/Linq/Internals/ExpressionHashCodeCalculator.cs

@@ -64,7 +64,7 @@ protected override int VisitConstant(ConstantExpression c)
     protected override int VisitDefault(DefaultExpression d)
     {
       if (d.Type.IsValueType) {
-        return d.GetDefaultValue().GetHashCode();
+        return d.ToConstantExpression().Value.GetHashCode();
       }
       else {
         return NullHashCode;
@@ -151,4 +151,4 @@ private int HashExpressionSequence(IEnumerable<Expression> expressions)
 
     #endregion
   }
-}
+}

Orm/Xtensive.Orm/Orm/Building/Builders/PartialIndexFilterBuilder.cs

@@ -94,13 +94,9 @@ protected override Expression VisitBinary(BinaryExpression b)
 
       return base.VisitBinary(b);
 
-      static bool EnumRewritableOperations(BinaryExpression b)
-      {
-        var nt = b.NodeType;
-        return nt == ExpressionType.Equal || nt == ExpressionType.NotEqual
-          || nt == ExpressionType.GreaterThan || nt == ExpressionType.GreaterThanOrEqual
-          || nt == ExpressionType.LessThan || nt == ExpressionType.LessThanOrEqual;
-      }
+      static bool EnumRewritableOperations(BinaryExpression b) =>
+        b.NodeType is ExpressionType.Equal or ExpressionType.NotEqual or ExpressionType.GreaterThan or ExpressionType.GreaterThanOrEqual
+          or ExpressionType.LessThan or ExpressionType.LessThanOrEqual;
     }
 
     protected override Expression VisitMember(MemberExpression originalMemberAccess)
@@ -142,7 +138,7 @@ protected override Expression VisitMember(MemberExpression originalMemberAccess)
       }
       if (field.IsPrimitive) {
         EnsureCanBeUsedInFilter(originalMemberAccess, field);
-        return BuildFieldAccess(field, false);
+        return BuildFieldAccess(field, field.ValueType);
       }
       throw UnableToTranslate(originalMemberAccess, Strings.OnlyPrimitiveAndReferenceFieldsAreSupported);
     }
@@ -156,10 +152,9 @@ private void EnsureCanBeUsedInFilter(Expression expression, FieldInfo field)
         throw UnableToTranslate(expression, string.Format(Strings.FieldXDoesNotExistInTableForY, field.Name, field.ReflectedType));
     }
 
-    private Expression BuildFieldAccess(FieldInfo field, bool addNullability)
+    private Expression BuildFieldAccess(FieldInfo field, Type valueType)
     {
       var fieldIndex = usedFields.Count;
-      var valueType = addNullability ? field.ValueType.ToNullable() : field.ValueType;
       usedFields.Add(field);
       return Expression.Call(Parameter,
         WellKnownMembers.Tuple.GenericAccessor.CachedMakeGenericMethod(valueType),
@@ -168,18 +163,12 @@ private Expression BuildFieldAccess(FieldInfo field, bool addNullability)
 
     private Expression BuildFieldCheck(FieldInfo field, ExpressionType nodeType)
     {
-      return Expression.MakeBinary(nodeType, BuildFieldAccess(field, true), Expression.Constant(null, field.ValueType.ToNullable()));
+      var nullableValueType = field.ValueType.ToNullable();
+      return Expression.MakeBinary(nodeType, BuildFieldAccess(field, nullableValueType), Expression.Constant(null, nullableValueType));
     }
 
-    private Expression BuildEntityCheck(FieldInfo field, ExpressionType nodeType)
-    {
-      var fields = field.Fields.Where(f => f.Column!=null).ToList();
-      if (fields.Count==0)
-        throw new InvalidOperationException();
-      return fields
-        .Skip(1)
-        .Aggregate(BuildFieldCheck(fields[0], nodeType), (c, f) => Expression.AndAlso(c, BuildFieldCheck(f, nodeType)));
-    }
+    private Expression BuildEntityCheck(FieldInfo field, ExpressionType nodeType) =>
+      field.Fields.Where(f => f.Column != null).Select(f => BuildFieldCheck(f, nodeType)).Aggregate(Expression.AndAlso);
 
     private bool IsNull(Expression expression)
     {
@@ -231,4 +220,4 @@ private PartialIndexFilterBuilder(IndexInfo index)
       reflectedType = index.ReflectedType;
     }
   }
-}
+}