Fix multiple relationships pointing to the same collection (#88)

* Fix multiple relationships pointing to the same collection

* Update test expectation

* Oops wrong test

* Format

* Update expected.json

---------

Co-authored-by: Gavin Ray <ray.gavin97@gmail.com>

Author: danieljharvey

ndc-connector-snowflake/src/main/kotlin/io/hasura/snowflake/CTEQueryGenerator.kt

@@ -352,7 +352,8 @@ object CTEQueryGenerator : BaseQueryGenerator() {
                                     DSL.name(
                                         createAlias(
                                             relation.target_collection,
-                                            isAggOnlyRelationField(field)
+                                            isAggOnlyRelationField(field),
+                                            alias
                                         ),
                                         ROWS_AND_AGGREGATES
                                     )
@@ -429,12 +430,12 @@ object CTEQueryGenerator : BaseQueryGenerator() {
                 val args = if (baseRel.arguments.isEmpty() && baseRel.column_mapping.isEmpty() && field.arguments.isNotEmpty()) {
                     field.arguments
                 } else baseRel.arguments
-                Pair(field, baseRel.copy(arguments = args))
+                Triple(alias, field, baseRel.copy(arguments = args))
             }
 
             val joinedAliases = mutableSetOf<String>()
 
-            relationFields.forEach { (field, relationship) ->
+            relationFields.forEach { (fieldAlias, field, relationship) ->
                 val desiredAggOnly = isAggOnlyRelationField(field)
 
                 var chosenTriple: Triple<QueryRequest, String?, SelectJoinStep<*>>? = null
@@ -456,7 +457,8 @@ object CTEQueryGenerator : BaseQueryGenerator() {
                     val (innerRequest, _, innerSelect) = chosenTriple!!
                     val innerAlias = createAlias(
                         innerRequest.collection,
-                        isAggregateOnlyRequest(innerRequest)
+                        isAggregateOnlyRequest(innerRequest),
+                        fieldAlias
                     )
 
                     if (!joinedAliases.contains(innerAlias)) {
@@ -537,9 +539,14 @@ object CTEQueryGenerator : BaseQueryGenerator() {
     }
 
     /**
-     * Helper to alias inner SELECTs based on collection and whether they are aggregate-only.
+     * Helper to alias inner SELECTs based on collection, field alias, and whether they are aggregate-only.
      */
-    private fun createAlias(collection: String, isAggregateOnly: Boolean): String {
-        return "$collection${if (isAggregateOnly) "_AGG" else ""}".replace(".", "_")
+    private fun createAlias(collection: String, isAggregateOnly: Boolean, fieldAlias: String? = null): String {
+        val baseAlias = if (fieldAlias != null) {
+            "${fieldAlias}_${collection}"
+        } else {
+            collection
+        }
+        return "$baseAlias${if (isAggregateOnly) "_AGG" else ""}".replace(".", "_")
     }
 }

ndc-connector-trino/src/main/kotlin/io/hasura/trino/CTEQueryGenerator.kt

@@ -198,7 +198,8 @@ object CTEQueryGenerator : BaseQueryGenerator() {
                                     DSL.name(
                                         createAlias(
                                             relation.target_collection,
-                                            isAggOnlyRelationField(field)
+                                            isAggOnlyRelationField(field),
+                                            alias
                                         ),
                                         ROWS_AND_AGGREGATES
                                     )
@@ -251,22 +252,22 @@ object CTEQueryGenerator : BaseQueryGenerator() {
 
 
         selects.forEachIndexed() { idx, (request, select) ->
-            val relationships = getQueryRelationFields(request.query.fields).values.map {
-                val rel = request.collection_relationships[it.relationship]!!
-                val args = if (rel.arguments.isEmpty() && rel.column_mapping.isEmpty() && it.arguments.isNotEmpty()) {
-                    it.arguments
+            val relationships = getQueryRelationFields(request.query.fields).map { (alias, field) ->
+                val rel = request.collection_relationships[field.relationship]!!
+                val args = if (rel.arguments.isEmpty() && rel.column_mapping.isEmpty() && field.arguments.isNotEmpty()) {
+                    field.arguments
                 } else rel.arguments
-                rel.copy(arguments = args)
+                Pair(alias, rel.copy(arguments = args))
             }
 
-            relationships.forEach { relationship ->
+            relationships.forEach { (fieldAlias, relationship) ->
 
                 val innerSelects =
                     selects.minus(selects[idx]).filter { it.first.collection == relationship.target_collection }
 
                 innerSelects.forEach { (innerRequest, innerSelect) ->
                     val innerAlias = createAlias(
-                        innerRequest.collection, isAggregateOnlyRequest(innerRequest)
+                        innerRequest.collection, isAggregateOnlyRequest(innerRequest), fieldAlias
                     )
 
                     run {
@@ -338,8 +339,13 @@ object CTEQueryGenerator : BaseQueryGenerator() {
         )
     }
 
-    private fun createAlias(collection: String, isAggregateOnly: Boolean): String {
-        return "$collection${if (isAggregateOnly) "_AGG" else ""}".replace(".", "_")
+    private fun createAlias(collection: String, isAggregateOnly: Boolean, fieldAlias: String? = null): String {
+        val baseAlias = if (fieldAlias != null) {
+            "${fieldAlias}_${collection}"
+        } else {
+            collection
+        }
+        return "$baseAlias${if (isAggregateOnly) "_AGG" else ""}".replace(".", "_")
     }
 
 }