Optimize JoinSequence (#223)

* Optimize `JoinSequence`

* Optimize TryFindJoinHint

Author: SergeiPavlov

Orm/Xtensive.Orm.SqlServer/Sql.Drivers.SqlServer/v09/Translator.cs

@@ -266,42 +266,29 @@ public override void Translate(SqlCompilerContext context, SqlJoinExpression nod
                 _ = output.Append("OUTER APPLY");
                 return;
             }
-          var joinHint = TryFindJoinHint(context, node);
+
+          var right = node.Right;
+          var joinHint = context.GetTraversalPath()
+            .OfType<SqlQueryStatement>()
+            .LastOrDefault()?.Hints.OfType<SqlJoinHint>().FirstOrDefault(hint => hint.Table == right);
 
           Translate(output, node.JoinType);
           if (joinHint != null) {
             _ = output.AppendSpace().Append(Translate(joinHint.Method));
           }
+
           _ = output.Append(" JOIN");
           break;
         default:
           base.Translate(context, node, section);
           break;
       }
-
-      static SqlJoinHint TryFindJoinHint(SqlCompilerContext context, SqlJoinExpression node)
-      {
-        SqlQueryStatement statement = null;
-        for (int i = 0, count = context.GetTraversalPath().Length; i < count; i++) {
-          if (context.GetTraversalPath()[i] is SqlQueryStatement) {
-            statement = context.GetTraversalPath()[i] as SqlQueryStatement;
-          }
-        }
-        if (statement == null || statement.Hints.Count == 0) {
-          return null;
-        }
-
-        var candidate = statement.Hints
-          .OfType<SqlJoinHint>()
-          .FirstOrDefault(hint => hint.Table == node.Right);
-        return candidate;
-      }
     }
 
     /// <inheritdoc/>
     public override void Translate(SqlCompilerContext context, SqlQueryExpression node, QueryExpressionSection section)
     {
-      if (node.All && section == QueryExpressionSection.All && (node.NodeType == SqlNodeType.Except || node.NodeType == SqlNodeType.Intersect))
+      if (node.All && section == QueryExpressionSection.All && (node.NodeType is SqlNodeType.Except or SqlNodeType.Intersect))
         return;
       base.Translate(context, node, section);
     }

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

@@ -5,71 +5,55 @@
 // Created:    2012.05.18
 
 using System.Collections.Generic;
-using System.Collections.ObjectModel;
 using Xtensive.Sql.Dml;
 
 namespace Xtensive.Sql.Compiler
 {
-  internal sealed class JoinSequence
+  internal readonly record struct JoinSequence
+  (
+    SqlTable Pivot,
+    IReadOnlyList<SqlTable> Tables,
+    IReadOnlyList<SqlJoinType> JoinTypes,
+    IReadOnlyList<SqlExpression> Conditions
+  )
   {
-    public SqlTable Pivot { get; private set; }
-
-    public IList<SqlTable> Tables { get; private set; }
-
-    public IList<SqlJoinType> JoinTypes { get; private set; }
-
-    public IList<SqlExpression> Conditions { get; private set; }
-
     public static JoinSequence Build(SqlJoinedTable root)
     {
-      var joins = new List<SqlJoinExpression>();
+      var joins = new List<SqlJoinExpression>(1);
       Traverse(root, joins);
 
-      var result = new JoinSequence();
+      List<SqlTable> tables = new();
+      List<SqlJoinType> joinTypes = new();
+      List<SqlExpression> conditions = new();
 
       foreach (var item in joins) {
-        if (!(item.Left is SqlJoinedTable))
-          result.Tables.Add(item.Left);
-        if (!(item.Right is SqlJoinedTable))
-          result.Tables.Add(item.Right);
-        result.JoinTypes.Add(item.JoinType);
-        result.Conditions.Add(item.Expression);
+        var left = item.Left;
+        if (!(left is SqlJoinedTable))
+          tables.Add(left);
+        var right = item.Right;
+        if (!(right is SqlJoinedTable))
+          tables.Add(right);
+        joinTypes.Add(item.JoinType);
+        conditions.Add(item.Expression);
       }
 
-      var pivot = result.Tables[0];
-      result.Pivot = pivot;
-      result.Tables.RemoveAt(0);
-
-      result.Tables = new ReadOnlyCollection<SqlTable>(result.Tables);
-      result.JoinTypes = new ReadOnlyCollection<SqlJoinType>(result.JoinTypes);
-      result.Conditions = new ReadOnlyCollection<SqlExpression>(result.Conditions);
-
-      return result;
+      var pivot = tables[0];
+      tables.RemoveAt(0);
+      return new(pivot, tables, joinTypes, conditions);
     }
 
-    private static void Traverse(SqlJoinedTable root, ICollection<SqlJoinExpression> output)
+    private static void Traverse(SqlJoinedTable root, List<SqlJoinExpression> output)
     {
-      var left = root.JoinExpression.Left;
-      var joinedLeft = left as SqlJoinedTable;
-      if (joinedLeft!=null)
+      var joinExpression = root.JoinExpression;
+      if (joinExpression.Left is SqlJoinedTable joinedLeft) {
         Traverse(joinedLeft, output);
+      }
 
-      output.Add(root.JoinExpression);
+      output.Add(joinExpression);
 
-      var right = root.JoinExpression.Right;
-      var joinedRight = right as SqlJoinedTable;
-      if (joinedRight!=null)
+      if (joinExpression.Right is SqlJoinedTable joinedRight) {
         Traverse(joinedRight, output);
-    }
-
-
-    // Constructors
-
-    private JoinSequence()
-    {
-      Tables = new List<SqlTable>();
-      JoinTypes = new List<SqlJoinType>();
-      Conditions = new List<SqlExpression>();
+      }
     }
   }
 }

Orm/Xtensive.Orm/Sql/Compiler/SqlCompiler.cs

@@ -1650,7 +1650,7 @@ protected virtual void VisitSelectFrom(SqlSelect node)
       var previous = joinSequence.Pivot;
       previous.AcceptVisitor(this);
 
-      for (var i = 0; i < joinSequence.Tables.Count; i++) {
+      for (int i = 0, n = joinSequence.Tables.Count; i < n; i++) {
         var table = joinSequence.Tables[i];
         var type = joinSequence.JoinTypes[i];
         var condition = joinSequence.Conditions[i];