Improved N-1 join query performance for DW SQL

src/Cli.Tests/ModuleInitializer.cs

@@ -79,6 +79,10 @@ public static void Init()
         VerifierSettings.IgnoreMember<RuntimeConfig>(options => options.EnableAggregation);
         // Ignore the EnableAggregation as that's unimportant from a test standpoint.
         VerifierSettings.IgnoreMember<GraphQLRuntimeOptions>(options => options.EnableAggregation);
+        // Ignore the EnableDwNto1JoinOpt as that's unimportant from a test standpoint.
+        VerifierSettings.IgnoreMember<RuntimeConfig>(options => options.EnableDwNto1JoinOpt);
+        // Ignore the FeatureFlags as that's unimportant from a test standpoint.
+        VerifierSettings.IgnoreMember<GraphQLRuntimeOptions>(options => options.FeatureFlags);
         // Ignore the JSON schema path as that's unimportant from a test standpoint.
         VerifierSettings.IgnoreMember<RuntimeConfig>(config => config.Schema);
         // Ignore the message as that's not serialized in our config file anyway.

src/Config/ObjectModel/FeatureFlags.cs

@@ -0,0 +1,19 @@
+namespace Azure.DataApiBuilder.Config.ObjectModel
+{
+    /// <summary>
+    /// The class is used for ephemeral feature flags to turn on/off features in development
+    /// </summary>
+    public class FeatureFlags
+    {
+        /// <summary>
+        /// By default EnableDwNto1JoinQueryOptimization is disabled
+        /// We should change the default as True once got more confidence with the fix
+        /// </summary>
+        public bool EnableDwNto1JoinQueryOptimization { get; set; }
+
+        public FeatureFlags()
+        {
+            this.EnableDwNto1JoinQueryOptimization = false;
+        }
+    }
+}

src/Config/ObjectModel/GraphQLRuntimeOptions.cs

@@ -11,7 +11,8 @@ public record GraphQLRuntimeOptions(bool Enabled = true,
                                     bool AllowIntrospection = true,
                                     int? DepthLimit = null,
                                     MultipleMutationOptions? MultipleMutationOptions = null,
-                                    bool EnableAggregation = true)
+                                    bool EnableAggregation = true,
+                                    FeatureFlags? FeatureFlags = null)
 {
     public const string DEFAULT_PATH = "/graphql";
 
@@ -24,4 +25,10 @@ public record GraphQLRuntimeOptions(bool Enabled = true,
     [JsonIgnore(Condition = JsonIgnoreCondition.Always)]
     [MemberNotNullWhen(true, nameof(DepthLimit))]
     public bool UserProvidedDepthLimit { get; init; } = false;
+
+    /// <summary>
+    /// Feature flag contains ephemeral flags passed in to init the runtime options 
+    /// </summary>
+    [JsonIgnore(Condition = JsonIgnoreCondition.Always)]
+    public FeatureFlags FeatureFlags { get; init; } = FeatureFlags ?? new FeatureFlags();
 }

src/Config/ObjectModel/RuntimeConfig.cs

@@ -150,6 +150,16 @@ Runtime is not null &&
         Runtime.GraphQL is not null &&
         Runtime.GraphQL.EnableAggregation;
 
+    /// <summary>
+    /// Retrieves the value of runtime.graphql.dwnto1joinopt.enabled property if present, default is false.
+    /// </summary>
+    [JsonIgnore]
+    public bool EnableDwNto1JoinOpt =>
+        Runtime is not null &&
+        Runtime.GraphQL is not null &&
+        Runtime.GraphQL.FeatureFlags is not null &&
+        Runtime.GraphQL.FeatureFlags.EnableDwNto1JoinQueryOptimization;
+
     private Dictionary<string, DataSource> _dataSourceNameToDataSource;
 
     private Dictionary<string, string> _entityNameToDataSourceName = new();

src/Core/Resolvers/BaseTSqlQueryBuilder.cs

@@ -0,0 +1,132 @@
+using Azure.DataApiBuilder.Config.ObjectModel;
+using Azure.DataApiBuilder.Core.Models;
+
+namespace Azure.DataApiBuilder.Core.Resolvers
+{
+    /// <summary>
+    /// Base query builder class for T-SQL engine
+    /// Can be used by dwsql and mssql
+    /// </summary>
+    public abstract class BaseTSqlQueryBuilder : BaseSqlQueryBuilder
+    {
+        protected const string FOR_JSON_SUFFIX = " FOR JSON PATH, INCLUDE_NULL_VALUES";
+        protected const string WITHOUT_ARRAY_WRAPPER_SUFFIX = "WITHOUT_ARRAY_WRAPPER";
+
+        /// <summary>
+        /// Build the Json Path query needed to append to the main query
+        /// </summary>
+        /// <param name="structure">Sql query structure to build query on</param>
+        /// <returns>SQL query with JSON PATH format</returns>
+        protected virtual string BuildJsonPath(SqlQueryStructure structure)
+        {
+            string query = string.Empty;
+            query += FOR_JSON_SUFFIX;
+            if (!structure.IsListQuery)
+            {
+                query += "," + WITHOUT_ARRAY_WRAPPER_SUFFIX;
+            }
+
+            return query;
+        }
+
+        /// <summary>
+        /// Build the predicates query needed to append to the main query
+        /// </summary>
+        /// <param name="structure">Sql query structure to build query on</param>
+        /// <returns>SQL query with predicates</returns>
+        protected virtual string BuildPredicates(SqlQueryStructure structure)
+        {
+            return JoinPredicateStrings(
+                          structure.GetDbPolicyForOperation(EntityActionOperation.Read),
+                          structure.FilterPredicates,
+                          Build(structure.Predicates),
+                          Build(structure.PaginationMetadata.PaginationPredicate));
+        }
+
+        /// <summary>
+        /// Build the Group By Clause needed to append to the main query
+        /// </summary>
+        /// <param name="structure">Sql query structure to build query on</param>
+        /// <returns>SQL query with group-by clause</returns>
+        protected virtual string BuildGroupBy(SqlQueryStructure structure)
+        {
+            // Add GROUP BY clause if there are any group by columns
+            if (structure.GroupByMetadata.Fields.Any())
+            {
+                return $" GROUP BY {string.Join(", ", structure.GroupByMetadata.Fields.Values.Select(c => Build(c)))}";
+            }
+
+            return string.Empty;
+        }
+
+        /// <summary>
+        /// Build the Having clause needed to append to the main query
+        /// </summary>
+        /// <param name="structure">Sql query structure to build query on</param>
+        /// <returns>SQL query with having clause</returns>
+        protected virtual string BuildHaving(SqlQueryStructure structure)
+        {
+            if (structure.GroupByMetadata.Aggregations.Count > 0)
+            {
+                List<Predicate>? havingPredicates = structure.GroupByMetadata.Aggregations
+                      .SelectMany(aggregation => aggregation.HavingPredicates ?? new List<Predicate>())
+                      .ToList();
+
+                if (havingPredicates.Any())
+                {
+                    return $" HAVING {Build(havingPredicates)}";
+                }
+            }
+
+            return string.Empty;
+        }
+
+        /// <summary>
+        /// Build the Order By clause needed to append to the main query
+        /// </summary>
+        /// <param name="structure">Sql query structure to build query on</param>
+        /// <returns>SQL query with order-by clause</returns>
+        protected virtual string BuildOrderBy(SqlQueryStructure structure)
+        {
+            if (structure.OrderByColumns.Any())
+            {
+                return $" ORDER BY {Build(structure.OrderByColumns)}";
+            }
+
+            return string.Empty;
+        }
+
+        /// <summary>
+        /// Build the aggregation columns needed to append to the main query
+        /// </summary>
+        /// <param name="structure">Sql query structure to build query on</param>
+        /// <returns>SQL query with aggregation columns</returns>
+        protected virtual string BuildAggregationColumns(SqlQueryStructure structure)
+        {
+            string aggregations = string.Empty;
+            if (structure.GroupByMetadata.Aggregations.Count > 0)
+            {
+                if (structure.Columns.Any())
+                {
+                    aggregations = $",{BuildAggregationColumns(structure.GroupByMetadata)}";
+                }
+                else
+                {
+                    aggregations = $"{BuildAggregationColumns(structure.GroupByMetadata)}";
+                }
+            }
+
+            return aggregations;
+        }
+
+        /// <summary>
+        /// Build the aggregation columns needed to append to the main query
+        /// </summary>
+        /// <param name="metadata">GroupByMetadata</param>
+        /// <returns>SQL query with aggregation columns</returns>
+        protected virtual string BuildAggregationColumns(GroupByMetadata metadata)
+        {
+            return string.Join(", ", metadata.Aggregations.Select(aggregation => Build(aggregation.Column, useAlias: true)));
+        }
+    }
+}