fix: make table name quoting backend-agnostic

- Update get_master() regex to match both MySQL backticks and PostgreSQL double quotes
- Use adapter.quote_identifier() for FreeTable construction in schemas.py
- Add pattern parameter to list_tables_sql() for job table queries
- Use list_tables_sql() instead of hardcoded SHOW TABLES in jobs property
- Update FreeTable.__repr__ to use full_table_name property

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

Author: dimitri-yatsenko

src/datajoint/adapters/base.py

@@ -598,14 +598,16 @@ def list_schemas_sql(self) -> str:
         ...
 
     @abstractmethod
-    def list_tables_sql(self, schema_name: str) -> str:
+    def list_tables_sql(self, schema_name: str, pattern: str | None = None) -> str:
         """
         Generate query to list tables in a schema.
 
         Parameters
         ----------
         schema_name : str
             Name of schema to list tables from.
+        pattern : str, optional
+            LIKE pattern to filter table names. Use %% for % in SQL.
 
         Returns
         -------

src/datajoint/adapters/mysql.py

@@ -606,9 +606,12 @@ def list_schemas_sql(self) -> str:
         """Query to list all databases in MySQL."""
         return "SELECT schema_name FROM information_schema.schemata"
 
-    def list_tables_sql(self, schema_name: str) -> str:
+    def list_tables_sql(self, schema_name: str, pattern: str | None = None) -> str:
         """Query to list tables in a database."""
-        return f"SHOW TABLES IN {self.quote_identifier(schema_name)}"
+        sql = f"SHOW TABLES IN {self.quote_identifier(schema_name)}"
+        if pattern:
+            sql += f" LIKE '{pattern}'"
+        return sql
 
     def get_table_info_sql(self, schema_name: str, table_name: str) -> str:
         """Query to get table metadata (comment, engine, etc.)."""

src/datajoint/adapters/postgres.py

@@ -684,13 +684,16 @@ def list_schemas_sql(self) -> str:
             "WHERE schema_name NOT IN ('pg_catalog', 'information_schema')"
         )
 
-    def list_tables_sql(self, schema_name: str) -> str:
+    def list_tables_sql(self, schema_name: str, pattern: str | None = None) -> str:
         """Query to list tables in a schema."""
-        return (
+        sql = (
             f"SELECT table_name FROM information_schema.tables "
             f"WHERE table_schema = {self.quote_string(schema_name)} "
             f"AND table_type = 'BASE TABLE'"
         )
+        if pattern:
+            sql += f" AND table_name LIKE '{pattern}'"
+        return sql
 
     def get_table_info_sql(self, schema_name: str, table_name: str) -> str:
         """Query to get table metadata."""

src/datajoint/dependencies.py

@@ -31,8 +31,14 @@ def extract_master(part_table: str) -> str | None:
     str or None
         Master table name if part_table is a part table, None otherwise.
     """
-    match = re.match(r"(?P<master>`\w+`.`#?\w+)__\w+`", part_table)
-    return match["master"] + "`" if match else None
+    # Match both MySQL backticks and PostgreSQL double quotes
+    # MySQL: `schema`.`master__part`
+    # PostgreSQL: "schema"."master__part"
+    match = re.match(r'(?P<master>(?P<q>[`"])[\w]+(?P=q)\.(?P=q)#?[\w]+)__[\w]+(?P=q)', part_table)
+    if match:
+        q = match["q"]
+        return match["master"] + q
+    return None
 
 
 def topo_sort(graph: nx.DiGraph) -> list[str]:

src/datajoint/schemas.py

@@ -517,13 +517,16 @@ def jobs(self) -> list[Job]:
         jobs_list = []
 
         # Get all existing job tables (~~prefix)
-        # Note: %% escapes the % in pymysql
-        result = self.connection.query(f"SHOW TABLES IN `{self.database}` LIKE '~~%%'").fetchall()
+        # Note: %% escapes the % in pymysql/psycopg2
+        adapter = self.connection.adapter
+        sql = adapter.list_tables_sql(self.database, pattern="~~%%")
+        result = self.connection.query(sql).fetchall()
         existing_job_tables = {row[0] for row in result}
 
         # Iterate over auto-populated tables and check if their job table exists
         for table_name in self.list_tables():
-            table = FreeTable(self.connection, f"`{self.database}`.`{table_name}`")
+            adapter = self.connection.adapter
+            table = FreeTable(self.connection, f"{adapter.quote_identifier(self.database)}.{adapter.quote_identifier(table_name)}")
             tier = _get_tier(table.full_table_name)
             if tier in (Computed, Imported):
                 # Compute expected job table name: ~~base_name
@@ -696,7 +699,8 @@ def get_table(self, name: str) -> FreeTable:
         if table_name is None:
             raise DataJointError(f"Table `{name}` does not exist in schema `{self.database}`.")
 
-        full_name = f"`{self.database}`.`{table_name}`"
+        adapter = self.connection.adapter
+        full_name = f"{adapter.quote_identifier(self.database)}.{adapter.quote_identifier(table_name)}"
         return FreeTable(self.connection, full_name)
 
     def __getitem__(self, name: str) -> FreeTable:

src/datajoint/table.py

@@ -1443,4 +1443,4 @@ def __init__(self, conn, full_table_name):
         )
 
     def __repr__(self):
-        return "FreeTable(`%s`.`%s`)\n" % (self.database, self._table_name) + super().__repr__()
+        return f"FreeTable({self.full_table_name})\n" + super().__repr__()