feat: Use adapter for query expression SQL (Phase 6 Part 3)

Update expression.py to use database adapter for backend-agnostic SQL:
- from_clause() subquery aliases (line 110)
- from_clause() JOIN USING clause (line 123)
- Aggregation.make_sql() GROUP BY clause (line 1031)
- Aggregation.__len__() alias (line 1042)
- Union.make_sql() alias (line 1084)
- Union.__len__() alias (line 1100)
- Refactor _wrap_attributes() to accept adapter parameter (line 1245)
- Update sorting_clauses() to pass adapter (line 141)

All query expression SQL (JOIN, FROM, SELECT, GROUP BY, ORDER BY) now
uses proper identifier quoting for both MySQL and PostgreSQL.

Maintains backward compatibility with MySQL backend.
All existing tests pass (175 passed, 25 skipped).

Part of Phase 6: Multi-backend PostgreSQL support.
Related: #1338

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

Author: dimitri-yatsenko

src/datajoint/expression.py

@@ -104,9 +104,10 @@ def primary_key(self):
     _subquery_alias_count = count()  # count for alias names used in the FROM clause
 
     def from_clause(self):
+        adapter = self.connection.adapter
         support = (
             (
-                "(" + src.make_sql() + ") as `$%x`" % next(self._subquery_alias_count)
+                "({}) as {}".format(src.make_sql(), adapter.quote_identifier(f"${next(self._subquery_alias_count):x}"))
                 if isinstance(src, QueryExpression)
                 else src
             )
@@ -116,7 +117,8 @@ def from_clause(self):
         for s, (is_left, using_attrs) in zip(support, self._joins):
             left_kw = "LEFT " if is_left else ""
             if using_attrs:
-                using = "USING ({})".format(", ".join(f"`{a}`" for a in using_attrs))
+                quoted_attrs = ", ".join(adapter.quote_identifier(a) for a in using_attrs)
+                using = f"USING ({quoted_attrs})"
                 clause += f" {left_kw}JOIN {s} {using}"
             else:
                 # Cross join (no common non-hidden attributes)
@@ -134,7 +136,8 @@ def sorting_clauses(self):
             return ""
         # Default to KEY ordering if order_by is None (inherit with no existing order)
         order_by = self._top.order_by if self._top.order_by is not None else ["KEY"]
-        clause = ", ".join(_wrap_attributes(_flatten_attribute_list(self.primary_key, order_by)))
+        adapter = self.connection.adapter
+        clause = ", ".join(_wrap_attributes(_flatten_attribute_list(self.primary_key, order_by), adapter))
         if clause:
             clause = f" ORDER BY {clause}"
         if self._top.limit is not None:
@@ -1024,19 +1027,18 @@ def make_sql(self, fields=None):
                 ""
                 if not self.primary_key
                 else (
-                    " GROUP BY `%s`" % "`,`".join(self._grouping_attributes)
+                    " GROUP BY {}".format(
+                        ", ".join(self.connection.adapter.quote_identifier(col) for col in self._grouping_attributes)
+                    )
                     + ("" if not self.restriction else " HAVING (%s)" % ")AND(".join(self.restriction))
                 )
             ),
             sorting=self.sorting_clauses(),
         )
 
     def __len__(self):
-        return self.connection.query(
-            "SELECT count(1) FROM ({subquery}) `${alias:x}`".format(
-                subquery=self.make_sql(), alias=next(self._subquery_alias_count)
-            )
-        ).fetchone()[0]
+        alias = self.connection.adapter.quote_identifier(f"${next(self._subquery_alias_count):x}")
+        return self.connection.query(f"SELECT count(1) FROM ({self.make_sql()}) {alias}").fetchone()[0]
 
     def __bool__(self):
         return bool(self.connection.query("SELECT EXISTS({sql})".format(sql=self.make_sql())).fetchone()[0])
@@ -1072,12 +1074,11 @@ def make_sql(self):
         if not arg1.heading.secondary_attributes and not arg2.heading.secondary_attributes:
             # no secondary attributes: use UNION DISTINCT
             fields = arg1.primary_key
-            return "SELECT * FROM (({sql1}) UNION ({sql2})) as `_u{alias}{sorting}`".format(
-                sql1=(arg1.make_sql() if isinstance(arg1, Union) else arg1.make_sql(fields)),
-                sql2=(arg2.make_sql() if isinstance(arg2, Union) else arg2.make_sql(fields)),
-                alias=next(self.__count),
-                sorting=self.sorting_clauses(),
-            )
+            alias_name = f"_u{next(self.__count)}{self.sorting_clauses()}"
+            alias_quoted = self.connection.adapter.quote_identifier(alias_name)
+            sql1 = arg1.make_sql() if isinstance(arg1, Union) else arg1.make_sql(fields)
+            sql2 = arg2.make_sql() if isinstance(arg2, Union) else arg2.make_sql(fields)
+            return f"SELECT * FROM (({sql1}) UNION ({sql2})) as {alias_quoted}"
         # with secondary attributes, use union of left join with anti-restriction
         fields = self.heading.names
         sql1 = arg1.join(arg2, left=True).make_sql(fields)
@@ -1093,12 +1094,8 @@ def where_clause(self):
         raise NotImplementedError("Union does not use a WHERE clause")
 
     def __len__(self):
-        return self.connection.query(
-            "SELECT count(1) FROM ({subquery}) `${alias:x}`".format(
-                subquery=self.make_sql(),
-                alias=next(QueryExpression._subquery_alias_count),
-            )
-        ).fetchone()[0]
+        alias = self.connection.adapter.quote_identifier(f"${next(QueryExpression._subquery_alias_count):x}")
+        return self.connection.query(f"SELECT count(1) FROM ({self.make_sql()}) {alias}").fetchone()[0]
 
     def __bool__(self):
         return bool(self.connection.query("SELECT EXISTS({sql})".format(sql=self.make_sql())).fetchone()[0])
@@ -1242,6 +1239,14 @@ def _flatten_attribute_list(primary_key, attrs):
             yield a
 
 
-def _wrap_attributes(attr):
-    for entry in attr:  # wrap attribute names in backquotes
-        yield re.sub(r"\b((?!asc|desc)\w+)\b", r"`\1`", entry, flags=re.IGNORECASE)
+def _wrap_attributes(attr, adapter):
+    """Wrap attribute names with database-specific quotes."""
+    for entry in attr:
+        # Replace word boundaries (not 'asc' or 'desc') with quoted version
+        def quote_match(match):
+            word = match.group(1)
+            if word.lower() not in ("asc", "desc"):
+                return adapter.quote_identifier(word)
+            return word
+
+        yield re.sub(r"\b((?!asc|desc)\w+)\b", quote_match, entry, flags=re.IGNORECASE)