Caching IPreCompiler wrappers for rewriters

Author: alex-kulakov

Orm/Xtensive.Orm/Orm/Providers/DomainHandler.cs

@@ -20,8 +20,6 @@ namespace Xtensive.Orm.Providers
   /// </summary>
   public abstract class DomainHandler : DomainBoundHandler
   {
-    private static readonly OrderingCorrector OrderingCorrector = new OrderingCorrector(ResolveOrderingDescriptor);
-
     private Dictionary<Type, IMemberCompilerProvider> memberCompilerProviders;
 
     /// <summary>
@@ -91,16 +89,13 @@ protected virtual IPreCompiler CreatePreCompiler(CompilerConfiguration configura
     {
       var providerInfo = Handlers.ProviderInfo;
 
-      var applyCorrector = new ApplyProviderCorrector(
-        !providerInfo.Supports(ProviderFeatures.Apply));
-      var skipTakeCorrector = new SkipTakeCorrector(
-        providerInfo.Supports(ProviderFeatures.NativeTake),
-        providerInfo.Supports(ProviderFeatures.NativeSkip));
       return new CompositePreCompiler(
-        applyCorrector,
-        skipTakeCorrector,
+        ApplyProviderCorrector.GetOrCreate(!providerInfo.Supports(ProviderFeatures.Apply)),
+        SkipTakeCorrector.GetOrCreate(
+          providerInfo.Supports(ProviderFeatures.NativeTake),
+          providerInfo.Supports(ProviderFeatures.NativeSkip)),
         RedundantColumnOptimizer.Instance,
-        OrderingCorrector);
+        OrderingCorrector.DefaultResolverInstance);
     }
 
     /// <summary>
@@ -171,29 +166,6 @@ private void BuildQueryPreprocessors()
       QueryPreprocessors = ordered ?? throw new InvalidOperationException(Strings.ExCyclicDependencyInQueryPreprocessorGraphIsDetected);
     }
 
-    private static ProviderOrderingDescriptor ResolveOrderingDescriptor(CompilableProvider provider)
-    {
-      var isOrderSensitive = provider.Type is ProviderType.Skip
-        or ProviderType.Take
-        or ProviderType.Seek
-        or ProviderType.Paging
-        or ProviderType.RowNumber;
-      var preservesOrder = provider.Type is ProviderType.Skip
-        or ProviderType.Take
-        or ProviderType.Seek
-        or ProviderType.Paging
-        or ProviderType.RowNumber
-        or ProviderType.Distinct
-        or ProviderType.Alias;
-      var isOrderBreaker = provider.Type is ProviderType.Except
-        or ProviderType.Intersect
-        or ProviderType.Union
-        or ProviderType.Concat
-        or ProviderType.Existence;
-      var isSorter = provider.Type is ProviderType.Sort or ProviderType.Index;
-      return new ProviderOrderingDescriptor(isOrderSensitive, preservesOrder, isOrderBreaker, isSorter);
-    }
-
     #endregion
 
 

Orm/Xtensive.Orm/Orm/Rse/Transformation/ApplyProviderCorrector.cs

@@ -15,8 +15,24 @@ namespace Xtensive.Orm.Rse.Transformation
   /// </summary>
   public sealed class ApplyProviderCorrector : IPreCompiler
   {
+    private static readonly Lazy<ApplyProviderCorrector> exceptionThrowingCorrector = new(() => new ApplyProviderCorrector(true));
+    private static readonly Lazy<ApplyProviderCorrector> silentCorrector = new(() => new ApplyProviderCorrector(false));
+
     private readonly bool throwOnCorrectionFault;
 
+    /// <summary>
+    /// Gets existing instance or creates new one and cache it.
+    /// </summary>
+    /// <param name="throwOnCorrectionFault">if set to <see langword="true"/> 
+    /// then <see cref="InvalidOperationException"/> will be thrown in case of 
+    /// the correction's fault; otherwise the origin <see cref="CompilableProvider"/> 
+    /// will be returned.</param>
+    public static ApplyProviderCorrector GetOrCreate(bool throwOnCorrectionFault) =>
+      (throwOnCorrectionFault)
+        ? exceptionThrowingCorrector.Value
+        : silentCorrector.Value;
+    
+
     /// <inheritdoc/>
     public CompilableProvider Process(CompilableProvider rootProvider)
     {
@@ -33,7 +49,7 @@ public CompilableProvider Process(CompilableProvider rootProvider)
     /// then <see cref="InvalidOperationException"/> will be thrown in case of 
     /// the correction's fault; otherwise the origin <see cref="CompilableProvider"/> 
     /// will be returned.</param>
-    public ApplyProviderCorrector(bool throwOnCorrectionFault)
+    private ApplyProviderCorrector(bool throwOnCorrectionFault)
     {
       this.throwOnCorrectionFault = throwOnCorrectionFault;
     }

Orm/Xtensive.Orm/Orm/Rse/Transformation/OrderingCorrector.cs

@@ -18,6 +18,8 @@ namespace Xtensive.Orm.Rse.Transformation
   [Serializable]
   public sealed class OrderingCorrector : IPreCompiler
   {
+    public static OrderingCorrector DefaultResolverInstance { get; } = new OrderingCorrector();
+
     private readonly Func<CompilableProvider, ProviderOrderingDescriptor> orderingDescriptorResolver;
 
     /// <inheritdoc/>
@@ -26,6 +28,28 @@ CompilableProvider IPreCompiler.Process(CompilableProvider rootProvider)
       return OrderingRewriter.Rewrite(rootProvider, orderingDescriptorResolver);
     }
 
+    private static ProviderOrderingDescriptor ResolveOrderingDescriptor(CompilableProvider provider)
+    {
+      var isOrderSensitive = provider.Type is ProviderType.Skip
+        or ProviderType.Take
+        or ProviderType.Seek
+        or ProviderType.Paging
+        or ProviderType.RowNumber;
+      var preservesOrder = provider.Type is ProviderType.Skip
+        or ProviderType.Take
+        or ProviderType.Seek
+        or ProviderType.Paging
+        or ProviderType.RowNumber
+        or ProviderType.Distinct
+        or ProviderType.Alias;
+      var isOrderBreaker = provider.Type is ProviderType.Except
+        or ProviderType.Intersect
+        or ProviderType.Union
+        or ProviderType.Concat
+        or ProviderType.Existence;
+      var isSorter = provider.Type is ProviderType.Sort or ProviderType.Index;
+      return new ProviderOrderingDescriptor(isOrderSensitive, preservesOrder, isOrderBreaker, isSorter);
+    }
 
     // Constructors
 
@@ -39,5 +63,13 @@ public OrderingCorrector(Func<CompilableProvider, ProviderOrderingDescriptor> or
       ArgumentValidator.EnsureArgumentNotNull(orderingDescriptorResolver, "orderingDescriptorResolver");
       this.orderingDescriptorResolver = orderingDescriptorResolver;
     }
+
+    /// <summary>
+    /// Initializes a new instance of this class with default resolver
+    /// </summary>
+    public OrderingCorrector()
+    {
+      this.orderingDescriptorResolver = ResolveOrderingDescriptor;
+    }
   }
 }

Orm/Xtensive.Orm/Orm/Rse/Transformation/SkipTakeCorrector.cs

@@ -16,9 +16,31 @@ namespace Xtensive.Orm.Rse.Transformation
   [Serializable]
   public sealed class SkipTakeCorrector : IPreCompiler
   {
+    private static readonly Lazy<SkipTakeCorrector> fullPagingSupport = new(() => new SkipTakeCorrector(true, true));
+    private static readonly Lazy<SkipTakeCorrector> takeOnlySupport = new(() => new SkipTakeCorrector(true, false));
+    private static readonly Lazy<SkipTakeCorrector> skipOnlySupport = new(() => new SkipTakeCorrector(false, true));
+    private static readonly Lazy<SkipTakeCorrector> noPagingSupport = new(() => new SkipTakeCorrector(false, false));
+
     private readonly bool takeSupported;
     private readonly bool skipSupported;
 
+
+    /// <summary>
+    /// Gets cached instance of create and cache new one
+    /// </summary>
+    /// <param name="takeSupported">Take operation is supported.</param>
+    /// <param name="skipSupported">Skip operation is supported.</param>
+    /// <returns>Cached instance of corrector.</returns>
+    public static SkipTakeCorrector GetOrCreate(bool takeSupported, bool skipSupported)
+    {
+      return (takeSupported, skipSupported) switch {
+        (true, true) => fullPagingSupport.Value,
+        (false, true) => skipOnlySupport.Value,
+        (true, false) => takeOnlySupport.Value,
+        (false, false) => noPagingSupport.Value
+      };
+    }
+
     /// <inheritdoc/>
     CompilableProvider IPreCompiler.Process(CompilableProvider rootProvider)
     {
@@ -28,7 +50,7 @@ CompilableProvider IPreCompiler.Process(CompilableProvider rootProvider)
 
     // Constructors
 
-    public SkipTakeCorrector(bool takeSupported, bool skipSupported)
+    private SkipTakeCorrector(bool takeSupported, bool skipSupported)
     {
       this.takeSupported = takeSupported;
       this.skipSupported = skipSupported;