Add distinct alias generation for SQL joins to prevent collisions

Author: Samson Gebre

examples/advanced/sql_examples.py

@@ -935,6 +935,29 @@ def _run_examples(client):
         for j in joins[:5]:
             print(f"  {j['column']:25s} -> {j['target']}.{j['target_pk']}")
 
+        # sql_joins -- alias uniqueness: multiple lookups to the same target
+        # table (e.g. ownerid + createdby + modifiedby all point to systemuser)
+        # must each get a distinct alias so the combined SQL is valid.
+        # Expected output:
+        #   ownerid    -> systemuser  alias=s
+        #   createdby  -> systemuser  alias=s2
+        #   modifiedby -> systemuser  alias=s3
+        log_call("client.query.sql_joins('contact') -- distinct aliases for same target table")
+        try:
+            contact_joins = client.query.sql_joins("contact")
+            systemuser_joins = [j for j in contact_joins if j["target"] == "systemuser"]
+            print(f"[OK] {len(systemuser_joins)} lookup(s) from contact -> systemuser:")
+            for j in systemuser_joins:
+                alias = j["join_clause"].split()[2]
+                print(f"  {j['column']:30s} -> {j['target']}  alias={alias}")
+            aliases = [j["join_clause"].split()[2] for j in contact_joins]
+            if len(aliases) != len(set(aliases)):
+                print("[WARN] Duplicate aliases detected")
+            else:
+                print(f"[OK] All {len(contact_joins)} aliases unique")
+        except Exception as e:
+            print(f"[INFO] Alias check skipped: {e}")
+
         # sql_join (auto-generate JOIN clause)
         log_call(f"client.query.sql_join('{child_table}', '{parent_table}', ...)")
         try:

src/PowerPlatform/Dataverse/operations/query.py

@@ -309,6 +309,7 @@ def sql_joins(
         table_lower = table.lower()
         rels = self._client.tables.list_table_relationships(table)
 
+        used_aliases: set = set()
         result: List[Dict[str, Any]] = []
         for r in rels:
             ref_entity = (r.get("ReferencingEntity") or "").lower()
@@ -321,9 +322,19 @@ def sql_joins(
             if not all([col, target, target_pk]):
                 continue
 
-            # Generate a short alias for the target table
-            alias = target[0] if target else "j"
-            join_clause = f"JOIN {target} {alias} " f"ON {table_lower}.{col} = {alias}.{target_pk}"
+            # Generate a unique alias — add a numeric suffix on collision so
+            # two lookups to tables starting with the same letter (e.g.
+            # "account" and "annotation") or two lookups to the same table
+            # (e.g. "ownerid" and "createdby" both to "systemuser") produce
+            # distinct aliases and valid SQL.
+            base = target[0] if target else "j"
+            alias = base
+            counter = 2
+            while alias in used_aliases:
+                alias = f"{base}{counter}"
+                counter += 1
+            used_aliases.add(alias)
+            join_clause = f"JOIN {target} {alias} ON {table_lower}.{col} = {alias}.{target_pk}"
 
             result.append(
                 {

tests/unit/test_query_operations.py

@@ -644,6 +644,58 @@ def test_empty_relationships(self):
         joins = self.client.query.sql_joins("account")
         self.assertEqual(joins, [])
 
+    def test_alias_collision_same_first_letter(self):
+        """Two targets starting with the same letter get distinct aliases."""
+        self._mock_rels(
+            [
+                {
+                    "ReferencingEntity": "contact",
+                    "ReferencingAttribute": "parentcustomerid",
+                    "ReferencedEntity": "account",
+                    "ReferencedAttribute": "accountid",
+                    "SchemaName": "contact_customer_accounts",
+                },
+                {
+                    "ReferencingEntity": "contact",
+                    "ReferencingAttribute": "regardingobjectid",
+                    "ReferencedEntity": "annotation",
+                    "ReferencedAttribute": "annotationid",
+                    "SchemaName": "contact_annotation",
+                },
+            ]
+        )
+        joins = self.client.query.sql_joins("contact")
+        self.assertEqual(len(joins), 2)
+        aliases = [j["join_clause"].split()[2] for j in joins]
+        self.assertEqual(len(set(aliases)), 2, "aliases must be unique")
+        self.assertNotEqual(aliases[0], aliases[1])
+
+    def test_alias_collision_same_target_table(self):
+        """Two lookups to the same table (e.g. ownerid + createdby -> systemuser) get distinct aliases."""
+        self._mock_rels(
+            [
+                {
+                    "ReferencingEntity": "contact",
+                    "ReferencingAttribute": "ownerid",
+                    "ReferencedEntity": "systemuser",
+                    "ReferencedAttribute": "systemuserid",
+                    "SchemaName": "contact_ownerid_systemuser",
+                },
+                {
+                    "ReferencingEntity": "contact",
+                    "ReferencingAttribute": "createdby",
+                    "ReferencedEntity": "systemuser",
+                    "ReferencedAttribute": "systemuserid",
+                    "SchemaName": "contact_createdby_systemuser",
+                },
+            ]
+        )
+        joins = self.client.query.sql_joins("contact")
+        self.assertEqual(len(joins), 2)
+        aliases = [j["join_clause"].split()[2] for j in joins]
+        self.assertEqual(len(set(aliases)), 2, "aliases must be unique")
+        self.assertNotEqual(aliases[0], aliases[1])
+
 
 class TestSqlJoin(unittest.TestCase):
     """Tests for client.query.sql_join()."""