GraphQL Queries - Entities with self-joining relationships get expected responses

config-generators/dwsql-commands.txt

@@ -155,4 +155,7 @@ update GetBooks --config "dab-config.DwSql.json" --permissions "authenticated:ex
 update GetBook --config "dab-config.DwSql.json" --permissions "authenticated:execute" --rest.methods "Get"
 update CountBooks --config "dab-config.DwSql.json" --permissions "authenticated:execute"
 update Sales --config "dab-config.DwSql.json" --permissions "authenticated:*"
-update GetAuthorsHistoryByFirstName --config "dab-config.DwSql.json" --permissions "authenticated:execute"
+update GetAuthorsHistoryByFirstName --config "dab-config.DwSql.json" --permissions "authenticated:execute"
+add dbo_DimAccount --config "dab-config.DwSql.json" --source "DimAccount" --permissions "anonymous:*" --rest true --graphql true
+update dbo_DimAccount --config "dab-config.DwSql.json" --relationship parent_account --target.entity dbo_DimAccount --cardinality one --relationship.fields "ParentAccountKey:AccountKey"
+update dbo_DimAccount --config "dab-config.DwSql.json" --relationship child_accounts --target.entity dbo_DimAccount --cardinality many --relationship.fields "AccountKey:ParentAccountKey"

config-generators/mssql-commands.txt

@@ -230,3 +230,6 @@ update series --config "dab-config.MsSql.json" --permissions "TestNestedFilterMa
 update series --config "dab-config.MsSql.json" --permissions "TestNestedFilterOneMany_ColumnForbidden:read"
 update series --config "dab-config.MsSql.json" --permissions "TestNestedFilterOneMany_EntityReadForbidden:read"
 update DefaultBuiltInFunction --config "dab-config.MsSql.json" --permissions "anonymous:create" --fields.exclude "current_date,next_date"
+add dbo_DimAccount --config "dab-config.MsSql.json" --source "DimAccount" --permissions "anonymous:*" --rest true --graphql true
+update dbo_DimAccount --config "dab-config.MsSql.json" --relationship parent_account --target.entity dbo_DimAccount --cardinality one --relationship.fields "ParentAccountKey:AccountKey"
+update dbo_DimAccount --config "dab-config.MsSql.json" --relationship child_accounts --target.entity dbo_DimAccount --cardinality many --relationship.fields "AccountKey:ParentAccountKey"

config-generators/mysql-commands.txt

@@ -135,3 +135,6 @@ update Sales --config "dab-config.MySql.json" --permissions "authenticated:*"
 update Bookmarks --config "dab-config.MySql.json" --permissions "authenticated:*"
 update MappedBookmarks --config "dab-config.MySql.json" --permissions "authenticated:*" --map "id:bkid,bkname:name"
 update DefaultBuiltInFunction --config "dab-config.MySql.json" --permissions "anonymous:create" --fields.exclude "current_date,next_date"
+add dbo_DimAccount --config "dab-config.MySql.json" --source "dimaccount" --permissions "anonymous:*" --rest true --graphql true
+update dbo_DimAccount --config "dab-config.MySql.json" --relationship parent_account --target.entity dbo_DimAccount --cardinality one --relationship.fields "ParentAccountKey:AccountKey"
+update dbo_DimAccount --config "dab-config.MySql.json" --relationship child_accounts --target.entity dbo_DimAccount --cardinality many --relationship.fields "AccountKey:ParentAccountKey"

config-generators/postgresql-commands.txt

@@ -170,3 +170,7 @@ update series --config "dab-config.PostgreSql.json" --permissions "TestNestedFil
 update series --config "dab-config.PostgreSql.json" --permissions "TestNestedFilterOneMany_ColumnForbidden:read"
 update series --config "dab-config.PostgreSql.json" --permissions "TestNestedFilterOneMany_EntityReadForbidden:read"
 update DefaultBuiltInFunction --config "dab-config.PostgreSql.json" --permissions "anonymous:create" --fields.exclude "current_date,next_date"
+add dbo_DimAccount --config "dab-config.PostgreSql.json" --source "dimaccount" --permissions "anonymous:*" --rest true --graphql true
+update dbo_DimAccount --config "dab-config.PostgreSql.json" --map "parentaccountkey:ParentAccountKey,accountkey:AccountKey" 
+update dbo_DimAccount --config "dab-config.PostgreSql.json" --relationship parent_account --target.entity dbo_DimAccount --cardinality one --relationship.fields "parentaccountkey:accountkey"
+update dbo_DimAccount --config "dab-config.PostgreSql.json" --relationship child_accounts --target.entity dbo_DimAccount --cardinality many --relationship.fields "accountkey:parentaccountkey"

src/Config/DatabasePrimitives/DatabaseObject.cs

@@ -242,7 +242,9 @@ public class ViewDefinition : SourceDefinition { }
 public class RelationshipMetadata
 {
     /// <summary>
-    /// Dictionary of target entity name to ForeignKeyDefinition.
+    /// Dictionary tracking ForeignKeyDefinitions for a given target entity.
+    /// key: {targetEntityName}
+    /// value: [{ForeignKeyDefinition},{...}]
     /// </summary>
     [JsonInclude]
     public Dictionary<string, List<ForeignKeyDefinition>> TargetEntityToFkDefinitionMap { get; private set; }
@@ -271,9 +273,28 @@ public ColumnDefinition(Type systemType)
     }
 }
 
-[DebuggerDisplay("ReferencingDbTable = {Pair.ReferencingDbTable.FullName} (Count = {ReferencingColumns.Count}), ReferencedDbTable = {Pair.ReferencedDbTable.FullName} (Count = {ReferencedColumns.Count})")]
+[DebuggerDisplay("Relationship: {RelationshipName} ReferencingDbTable = {Pair.ReferencingDbTable.FullName} (Count = {ReferencingColumns.Count}), ReferencedDbTable = {Pair.ReferencedDbTable.FullName} (Count = {ReferencedColumns.Count})")]
 public class ForeignKeyDefinition
 {
+    public string SourceEntityName { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Identifies whether the referencing entity is the target, source, or linking entity.
+    /// Enables Resolve{Target/Source}Columns() functions to return the correct columns.
+    /// </summary>
+    public RelationshipRole ReferencingEntityRole { get; init; } = RelationshipRole.None;
+
+    /// <summary>
+    /// Identifies whether the referenced entity is the target, source, or linking entity.
+    /// Enables Resolve{Target/Source}Columns() functions to return the correct columns.
+    /// </summary>
+    public RelationshipRole ReferencedEntityRole { get; init; } = RelationshipRole.None;
+
+    /// <summary>
+    /// The relationship name defined for the relationship in the runtime config.
+    /// </summary>
+    public string RelationshipName { get; init; } = string.Empty;
+
     /// <summary>
     /// The referencing and referenced table pair.
     /// </summary>
@@ -293,6 +314,56 @@ public class ForeignKeyDefinition
     /// </summary>
     public List<string> ReferencingColumns { get; set; } = new();
 
+    /// <summary>
+    /// Resolves the target columns based on the role of the referencing and referenced entities.
+    /// The role of the referencing and referenced entities is important because
+    /// target entity can either be the "referenced" or "referencing" entity.
+    /// </summary>
+    /// <returns>List of the target entity's columns</returns>
+    /// <exception cref="Exception">Raised when the ForeignKeyDefinition represents a relationship
+    /// between a source (source fields) and linking object (linking source fields).</exception>
+    public List<string> ResolveTargetColumns()
+    {
+        if (ReferencingEntityRole == RelationshipRole.Target)
+        {
+            return ReferencingColumns;
+        }
+        else if (ReferencedEntityRole == RelationshipRole.Target)
+        {
+            return ReferencedColumns;
+        }
+        else
+        {
+            throw new Exception(
+                message: "Unable to resolve target columns because this ForeignKeyDefinition relates a target entity and linking object.");
+        }
+    }
+
+    /// <summary>
+    /// Resolves the source columns based on the role of the referencing and referenced entities.
+    /// The role of the referencing and referenced entities is important because
+    /// source entity can either be the "referenced" or "referencing" entity.
+    /// </summary>
+    /// <returns>List of the source entity's columns</returns>
+    /// <exception cref="Exception">Raised when the ForeignKeyDefinition represents a relationship
+    /// between a target (target columns) and linking object (linking target fields).</exception>
+    public List<string> ResolveSourceColumns()
+    {
+        if (ReferencingEntityRole == RelationshipRole.Source)
+        {
+            return ReferencingColumns;
+        }
+        else if (ReferencedEntityRole == RelationshipRole.Source)
+        {
+            return ReferencedColumns;
+        }
+        else
+        {
+            throw new Exception(
+                message: "Unable to resolve source columns because this ForeignKeyDefinition relates a source entity and linking object.");
+        }
+    }
+
     public override bool Equals(object? other)
     {
         return Equals(other as ForeignKeyDefinition);
@@ -316,12 +387,27 @@ public override int GetHashCode()
 [DebuggerDisplay("ReferencingDbTable = {ReferencingDbTable.FullName}, ReferencedDbTable = {ReferencedDbTable.FullName}")]
 public class RelationShipPair
 {
+    /// <summary>
+    /// Relationship name specified in the runtime config.
+    /// </summary>
+    public string RelationshipName { get; set; } = string.Empty;
+
     public RelationShipPair() { }
 
     public RelationShipPair(
+    DatabaseTable referencingDbObject,
+    DatabaseTable referencedDbObject)
+    {
+        ReferencingDbTable = referencingDbObject;
+        ReferencedDbTable = referencedDbObject;
+    }
+
+    public RelationShipPair(
+        string relationshipName,
         DatabaseTable referencingDbObject,
         DatabaseTable referencedDbObject)
     {
+        RelationshipName = relationshipName;
         ReferencingDbTable = referencingDbObject;
         ReferencedDbTable = referencedDbObject;
     }

src/Config/ObjectModel/EntityRelationshipKey.cs

@@ -0,0 +1,49 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using System.Diagnostics;
+
+namespace Azure.DataApiBuilder.Config.ObjectModel
+{
+    /// <summary>
+    /// Identifies a specific value pair:
+    /// 1. entity name
+    /// 2. relationship name
+    /// Which can be used to uniquely identify a relationship (ForeignKeyDefinition object(s)).
+    /// </summary>
+    [DebuggerDisplay("{EntityName} - {RelationshipName}")]
+    public class EntityRelationshipKey
+    {
+        /// <summary>
+        /// Source entity name which contains the relationship configuration.
+        /// </summary>
+        public string EntityName { get; set; }
+        public string RelationshipName { get; set; }
+
+        public EntityRelationshipKey(string entityName, string relationshipName)
+        {
+            EntityName = entityName;
+            RelationshipName = relationshipName;
+        }
+
+        public override bool Equals(object? other)
+        {
+            return Equals(other as EntityRelationshipKey);
+        }
+
+        public bool Equals(EntityRelationshipKey? other)
+        {
+            if (other == null)
+            {
+                return false;
+            }
+
+            return EntityName.Equals(other.EntityName) && RelationshipName.Equals(other.RelationshipName);
+        }
+
+        public override int GetHashCode()
+        {
+            return HashCode.Combine(EntityName, RelationshipName);
+        }
+    }
+}

src/Config/ObjectModel/RelationshipRole.cs

@@ -0,0 +1,21 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+namespace Azure.DataApiBuilder.Config.ObjectModel;
+
+/// <summary>
+/// Denotes the role of a referencing or referenced table in a relationship.
+/// Default value is None because the role is only resolved to help DAB
+/// create join predicates for self-referencing relationships.
+/// In non self-join relationships, DAB uses the ForeignKeyDefinition.RelationShipPair
+/// to determine the referencing/referenced entity. RelationShipPair isn't sufficient
+/// for self-join relationships because the DatabaseObjects used to represent the pair
+/// reference the same object: e.g. both Referenced/Referencing entity would point to 'dbo.MyTable'
+/// </summary>
+public enum RelationshipRole
+{
+    None,
+    Source,
+    Target,
+    Linking
+}

src/Core/Models/GraphQLFilterParsers.cs

@@ -425,9 +425,9 @@ private void HandleNestedFilterForSql(
         // Add JoinPredicates to the subquery query structure so a predicate connecting
         // the outer table is added to the where clause of subquery
         existsQuery.AddJoinPredicatesForRelatedEntity(
-            queryStructure.EntityName,
-            queryStructure.SourceAlias,
-            existsQuery);
+            targetEntityName: queryStructure.EntityName,
+            relatedSourceAlias: queryStructure.SourceAlias,
+            subQuery: existsQuery);
 
         // The right operand is the SqlExistsQueryStructure.
         PredicateOperand right = new(existsQuery);

src/Core/Models/SqlQueryStructures.cs

@@ -386,8 +386,7 @@ public ulong Current()
 }
 
 /// <summary>
-/// A simple class that is used to hold the information about joins that
-/// are part of a SQL query.
+/// Holds the information about joins that are part of a SQL query.
 /// <summary>
 /// <param name="DbObject">The name of the database object containing table metadata like joined tables.</param>
 /// <param name="TableAlias">The alias of the table that is joined with.</param>

src/Core/Resolvers/Sql Query Structures/BaseSqlQueryStructure.cs

@@ -143,8 +143,85 @@ public Type GetColumnSystemType(string columnName)
         /// <summary>
         /// Based on the relationship metadata involving referenced and
         /// referencing columns of a foreign key, add the join predicates
-        /// to the subquery Query structure created for the given target entity Name
-        /// and related source alias.
+        /// to the subquery QueryStructure created for the given target's entity name
+        /// and related target table source alias (name of table used in subquery).
+        /// There are only a couple of options for the foreign key - we only use the
+        /// valid foreign key definition. It is guaranteed at least one fk definition
+        /// will be valid since the MetadataProvider.ValidateAllFkHaveBeenInferred.
+        /// </summary>
+        /// <param name="fkLookupKey">{entityName, relationshipName} used to lookup foreign key metadata.</param>
+        /// <param name="targetEntityName">Related(target) entity's name.</param>
+        /// <param name="subqueryTargetTableAlias">The alias assigned for the underlying source of this related entity.</param>
+        /// <param name="subQuery">The subquery to which the join predicates are to be added.</param>
+        public void AddJoinPredicatesForRelationship(
+            EntityRelationshipKey fkLookupKey,
+            string targetEntityName,
+            string subqueryTargetTableAlias,
+            BaseSqlQueryStructure subQuery)
+        {
+            if (string.Equals(fkLookupKey.EntityName, targetEntityName))
+            {
+                AddJoinPredicatesForSelfJoinedEntity(
+                    fkLookupKey: fkLookupKey,
+                    subqueryTargetTableAlias: subqueryTargetTableAlias,
+                    subQuery: subQuery);
+            }
+            else
+            {
+                AddJoinPredicatesForRelatedEntity(
+                    targetEntityName: targetEntityName,
+                    relatedSourceAlias: subqueryTargetTableAlias,
+                    subQuery: subQuery);
+            }
+        }
+
+        /// <summary>
+        /// Add query predicates for self-joined entity.
+        /// Example pseudo tsql to illustrate what the predicates enable:
+        /// SELECT [columns] FROM [SqlQueryStructure.SourceAlias] // table0
+        /// JSON_QUERY(...) AS [fkLookupKey.relationshipName] // RelationshipName represents the sub query.
+        /// OUTER APPLY (
+        ///     // The param 'subQuery' captures the contents of this OUTER APPLY
+        ///     SELECT [columns] FROM [functionParams.subqueryTargetTableAlias] // table1
+        ///     WHERE [table0].[fk.SourceColumn] = [table1].[fk.TargetColumn]
+        /// )
+        /// WHERE [table0].[fk.SourceColumn] = [@param value from request]
+        ///
+        /// Process self-joining entity relationship. Excludes support for processing
+        /// self-joining relationships in GraphQL query filters (nested filter entities).
+        /// </summary>
+        /// <param name="fkLookupKey">{entityName, relationshipName} used to lookup foreign key metadata.</param>
+        /// <param name="subqueryTargetTableAlias">The table alias of the target entity/ subject of the sub-query.</param>
+        /// <param name="subQuery">The subquery to which the join predicates are to be added.</param>
+        /// <exception cref="DataApiBuilderException">Raised when an entity's relationship config is not found in the
+        /// metadata provider.</exception>
+        private void AddJoinPredicatesForSelfJoinedEntity(
+            EntityRelationshipKey fkLookupKey,
+            string subqueryTargetTableAlias,
+            BaseSqlQueryStructure subQuery)
+        {
+            if (MetadataProvider.RelationshipToFkDefinition.TryGetValue(key: fkLookupKey, out ForeignKeyDefinition? fkDef))
+            {
+                subQuery.Predicates.AddRange(
+                        CreateJoinPredicates(
+                            leftTableAlias: SourceAlias,
+                            leftColumnNames: fkDef.ResolveSourceColumns(),
+                            rightTableAlias: subqueryTargetTableAlias,
+                            rightColumnNames: fkDef.ResolveTargetColumns()));
+            }
+            else
+            {
+                throw new DataApiBuilderException(
+                    message: $"Could not find relationship between self-joined entity: {EntityName}.",
+                    statusCode: HttpStatusCode.BadRequest,
+                    subStatusCode: DataApiBuilderException.SubStatusCodes.BadRequest);
+            }
+        }
+
+        /// <summary>
+        /// Based on the relationship metadata involving referenced and
+        /// referencing columns of a foreign key, add the join predicates
+        /// to the subquery Query structure created for linking objects.
         /// There are only a couple of options for the foreign key - we only use the
         /// valid foreign key definition. It is guaranteed at least one fk definition
         /// will be valid since the MetadataProvider.ValidateAllFkHaveBeenInferred.
@@ -174,8 +251,8 @@ public void AddJoinPredicatesForRelatedEntity(
                     out foreignKeyDefinitions))
             {
                 Dictionary<DatabaseObject, string> associativeTableAndAliases = new();
-                // For One-One and One-Many, not all fk definitions would be valid
-                // but at least 1 will be.
+                // For One-One and One-Many, not all fk definitions are valid
+                // and at least 1 will be.
                 // Identify the side of the relationship first, then check if its valid
                 // by ensuring the referencing and referenced column count > 0
                 // before adding the predicates.

src/Core/Resolvers/Sql Query Structures/SqlQueryStructure.cs

@@ -791,11 +791,15 @@ private void AddGraphQLFields(IReadOnlyList<ISelectionNode> selections, RuntimeC
                     // use the _underlyingType from the subquery which will be overridden appropriately if the query is paginated
                     ObjectType subunderlyingType = subquery._underlyingFieldType;
                     string targetEntityName = MetadataProvider.GetEntityName(subunderlyingType.Name);
-                    string subtableAlias = subquery.SourceAlias;
-
-                    AddJoinPredicatesForRelatedEntity(targetEntityName, subtableAlias, subquery);
-
-                    string subqueryAlias = $"{subtableAlias}_subq";
+                    string subqueryTableAlias = subquery.SourceAlias;
+                    EntityRelationshipKey currentEntityRelationshipKey = new(EntityName, relationshipName: fieldName);
+                    AddJoinPredicatesForRelationship(
+                        fkLookupKey: currentEntityRelationshipKey,
+                        targetEntityName,
+                        subqueryTargetTableAlias: subqueryTableAlias,
+                        subquery);
+
+                    string subqueryAlias = $"{subqueryTableAlias}_subq";
                     JoinQueries.Add(subqueryAlias, subquery);
                     Columns.Add(new LabelledColumn(tableSchema: subquery.DatabaseObject.SchemaName,
                               tableName: subquery.DatabaseObject.Name,