Replace SqlNodeActualizer with special placeholder

Author: alex-kulakov

Orm/Xtensive.Orm/Sql/Compiler/Internals/Nodes/ContainerNode.cs

@@ -8,6 +8,7 @@
 using System.Globalization;
 using System.Linq;
 using System.Text;
+using Xtensive.Sql.Model;
 
 namespace Xtensive.Sql.Compiler
 {
@@ -135,6 +136,9 @@ public StringBuilder StringBuilder
 
     public void AppendPlaceholderWithId(object id) => Add(new PlaceholderNode(id));
 
+    public void AppendSchemaNodePlaceholder(SchemaNode schemaNode, SqlHelper.EscapeSetup escapeSetup, bool databaseNameRequired) =>
+      Add(new SchemaNodePlaceholderNode(schemaNode, escapeSetup, databaseNameRequired));
+
     public void AppendIndent()
     {
       if (Indent > 0) {

Orm/Xtensive.Orm/Sql/Compiler/Internals/Nodes/SchemaNodePlaceholderNode.cs

@@ -0,0 +1,29 @@
+// Copyright (C) 2003-2010 Xtensive LLC.
+// All rights reserved.
+// For conditions of distribution and use, see license.
+// Created by: Denis Krjuchkov
+// Created:    2009.07.15
+
+using Xtensive.Sql.Model;
+
+namespace Xtensive.Sql.Compiler
+{
+  internal sealed class SchemaNodePlaceholderNode : PlaceholderNode
+  {
+    public readonly SchemaNode SchemaNode;
+
+    public readonly SqlHelper.EscapeSetup EscapeSetup;
+
+    public readonly bool DbQualified;
+
+    internal override void AcceptVisitor(NodeVisitor visitor) => base.AcceptVisitor(visitor);
+
+    public SchemaNodePlaceholderNode(SchemaNode table, in SqlHelper.EscapeSetup escapeSetup, bool requireDatabaseName)
+      : base(table)
+    {
+      SchemaNode = table;
+      EscapeSetup = escapeSetup;
+      DbQualified = requireDatabaseName;
+    }
+  }
+}

Orm/Xtensive.Orm/Sql/Compiler/Internals/PostCompiler.cs

@@ -47,10 +47,25 @@ public override void Visit(VariantNode node)
 
     public override void Visit(PlaceholderNode node)
     {
-      string value;
-      if (!configuration.PlaceholderValues.TryGetValue(node.Id, out value))
-        throw new InvalidOperationException(string.Format(Strings.ExValueForPlaceholderXIsNotSet, node.Id));
-      result.Append(value);
+      if (node is SchemaNodePlaceholderNode schemaPlaceHolder) {
+        Visit(schemaPlaceHolder);
+      }
+      else {
+        if (!configuration.PlaceholderValues.TryGetValue(node.Id, out var value))
+          throw new InvalidOperationException(string.Format(Strings.ExValueForPlaceholderXIsNotSet, node.Id));
+        _ = result.Append(value);
+      }
+    }
+
+    private void Visit(SchemaNodePlaceholderNode node)
+    {
+      var schema = node.SchemaNode.Schema;
+
+      var names = (node.DbQualified)
+        ? new string[] { schema.Catalog.GetActualDbName(configuration.DatabaseMapping), schema.GetActualDbName(configuration.SchemaMapping), node.SchemaNode.DbName }
+        : new string[] { schema.GetActualDbName(configuration.SchemaMapping), node.SchemaNode.DbName };
+
+      _ = result.Append(SqlHelper.Quote(node.EscapeSetup, names));
     }
 
     public override void Visit(CycleItemNode node)

Orm/Xtensive.Orm/Sql/Compiler/SqlCompilerConfiguration.cs

@@ -4,6 +4,7 @@
 // Created by: Denis Krjuchkov
 // Created:    2009.07.15
 
+using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using JetBrains.Annotations;
@@ -34,14 +35,21 @@ public sealed class SqlCompilerConfiguration
     /// </summary>
     public SqlCommentLocation CommentLocation { get; set; } = SqlCommentLocation.Nowhere;
 
+    /// <summary>
+    /// Indicated whether storage schema was shared over several storage nodes.
+    /// </summary>
+    public bool SharedStorageSchema { get; init; } = false;
+
     /// <summary>
     /// Gets database mapping.
     /// </summary>
+    [Obsolete("No longer in use")]
     public IReadOnlyDictionary<string, string> SchemaMapping { get; private set; }
 
     /// <summary>
     /// Gets database mapping.
     /// </summary>
+    [Obsolete("No longer in use")]
     public IReadOnlyDictionary<string, string> DatabaseMapping { get; private set; }
 
     /// <summary>
@@ -58,11 +66,14 @@ public SqlCompilerConfiguration Clone()
 
     public SqlCompilerConfiguration()
     {
+#pragma warning disable CS0612 // Type or member is obsolete
       SchemaMapping = null;
       DatabaseMapping = null;
+#pragma warning restore CS0612 // Type or member is obsolete
     }
 
-    public SqlCompilerConfiguration([NotNull]IDictionary<string, string> databaseMapping, [NotNull]IDictionary<string, string> schemaMapping)
+    [Obsolete]
+    public SqlCompilerConfiguration([NotNull] IDictionary<string, string> databaseMapping, [NotNull] IDictionary<string, string> schemaMapping)
     {
       ArgumentValidator.EnsureArgumentNotNull(databaseMapping, "databaseMapping");
       ArgumentValidator.EnsureArgumentNotNull(schemaMapping, "schemaMapping");

Orm/Xtensive.Orm/Sql/Compiler/SqlCompilerContext.cs

@@ -24,11 +24,14 @@ public class SqlCompilerContext
 
     public SqlCompilerNamingOptions NamingOptions { get; private set; }
 
+    [Obsolete("No longer in use")]
     public SqlNodeActualizer SqlNodeActualizer { get; private set; }
 
     public SqlNode[] GetTraversalPath() =>
       traversalPath ??= traversalStack.ToArray();
 
+    public bool SharedStorageSchema { get; }
+
     public bool HasOptions(SqlCompilerNamingOptions requiredOptions)
     {
       return (NamingOptions & requiredOptions)==requiredOptions;
@@ -143,10 +146,14 @@ internal SqlCompilerContext(SqlCompilerConfiguration configuration)
       if (configuration.DatabaseQualifiedObjects)
         NamingOptions |= SqlCompilerNamingOptions.DatabaseQualifiedObjects;
 
+      SharedStorageSchema = configuration.SharedStorageSchema;
+
       TableNameProvider = new SqlTableNameProvider(this);
       ParameterNameProvider = new SqlParameterNameProvider(configuration);
       Output = new ContainerNode();
+#pragma warning disable CS0618 // Type or member is obsolete
       SqlNodeActualizer = new SqlNodeActualizer(configuration.DatabaseMapping, configuration.SchemaMapping);
+#pragma warning restore CS0618 // Type or member is obsolete
     }
   }
 }

Orm/Xtensive.Orm/Sql/Compiler/SqlNodeActualizer.cs

@@ -4,6 +4,7 @@
 // Created by: Alexey Kulakov
 // Created:    2017.03.24
 
+using System;
 using System.Collections.Generic;
 using Xtensive.Sql.Model;
 
@@ -12,6 +13,7 @@ namespace Xtensive.Sql.Compiler
   /// <summary>
   /// Applies configured mappings to <see cref="Catalog"/>'s or <see cref="Schema"/>'s name to get actual name.
   /// </summary>
+  [Obsolete]
   public sealed class SqlNodeActualizer
   {
     private readonly IReadOnlyDictionary<string, string> databaseMapping;

Orm/Xtensive.Orm/Sql/Compiler/SqlPostCompilerConfiguration.cs

@@ -5,6 +5,9 @@
 // Created:    2009.11.07
 
 using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using JetBrains.Annotations;
+using Xtensive.Core;
 
 namespace Xtensive.Sql.Compiler
 {
@@ -13,20 +16,39 @@ namespace Xtensive.Sql.Compiler
   /// </summary>
   public sealed class SqlPostCompilerConfiguration
   {
-    public HashSet<object> AlternativeBranches { get; private set; }
+    public HashSet<object> AlternativeBranches { get; private set; } = new HashSet<object>();
 
-    public Dictionary<object, string> PlaceholderValues { get; private set; }
+    public Dictionary<object, string> PlaceholderValues { get; private set; } = new Dictionary<object, string>();
 
-    public Dictionary<object, List<string[]>> DynamicFilterValues { get; private set; }
+    public Dictionary<object, List<string[]>> DynamicFilterValues { get; private set; } = new Dictionary<object, List<string[]>>();
+
+    /// <summary>
+    /// Gets database mapping.
+    /// </summary>
+    public IReadOnlyDictionary<string, string> SchemaMapping { get; private set; }
+
+    /// <summary>
+    /// Gets database mapping.
+    /// </summary>
+    public IReadOnlyDictionary<string, string> DatabaseMapping { get; private set; }
 
 
     // Constructors
 
     public SqlPostCompilerConfiguration()
     {
-      AlternativeBranches = new HashSet<object>();
-      PlaceholderValues = new Dictionary<object, string>();
-      DynamicFilterValues = new Dictionary<object, List<string[]>>();
+      // this prevents wrong query to be executed.
+      SchemaMapping = null;
+      DatabaseMapping = null;
+    }
+
+    public SqlPostCompilerConfiguration([NotNull] IReadOnlyDictionary<string, string> databaseMapping, [NotNull] IReadOnlyDictionary<string, string> schemaMapping)
+    {
+      ArgumentValidator.EnsureArgumentNotNull(databaseMapping, "databaseMapping");
+      ArgumentValidator.EnsureArgumentNotNull(schemaMapping, "schemaMapping");
+
+      DatabaseMapping = databaseMapping;
+      SchemaMapping = schemaMapping;
     }
   }
 }

Orm/Xtensive.Orm/Sql/Compiler/SqlTranslator.cs

@@ -1954,13 +1954,19 @@ public virtual void Translate(SqlCompilerContext context, SchemaNode node)
 
       var dbQualified = node.Schema.Catalog != null
         && context.HasOptions(SqlCompilerNamingOptions.DatabaseQualifiedObjects);
-      var actualizer = context.SqlNodeActualizer;
 
-      if (dbQualified) {
-        TranslateIdentifier(output, actualizer.Actualize(node.Schema.Catalog), actualizer.Actualize(node.Schema), node.GetDbNameInternal());
+      if (context.SharedStorageSchema) {
+        // if schema is shared we use placeholders to translate
+        // schema node in PostCompiler
+        output.AppendSchemaNodePlaceholder(node, EscapeSetup, dbQualified);
       }
       else {
-        TranslateIdentifier(output, actualizer.Actualize(node.Schema), node.DbName);
+        if (dbQualified) {
+          TranslateIdentifier(output, node.Schema.Catalog.DbName, node.Schema.DbName, node.DbName);
+        }
+        else {
+          TranslateIdentifier(output, node.Schema.DbName, node.DbName);
+        }
       }
     }