fix(declare): substitute the DDL schema placeholder without str.format

A brace sequence in a table or attribute comment (e.g. '# {data, config}
payload') crashed declaration with an opaque KeyError at
sql.format(database=...), which interpreted user comment text as template
fields. Replace the whole-DDL str.format with a plain str.replace of the
exact adapter-inserted fragment '"{database}".' (PostgreSQL enum type
qualification — its only producer), so braces in user comments and enum
values — including a bare literal {database} — pass through verbatim.

Author: MilagrosMarin

src/datajoint/table.py

@@ -33,6 +33,18 @@
 # Legacy regexp and query kept for reference but no longer used
 
 
+def _substitute_database(ddl: str, database: str) -> str:
+    """Replace the adapter-inserted schema placeholder in DDL.
+
+    Matches the exact quoted fragment produced by the PostgreSQL adapter for
+    enum type qualification (``'"{database}".'`` — see adapters/postgres.py)
+    rather than the bare token, and uses ``str.replace`` rather than
+    ``str.format``, so braces in user-supplied comments and enum values —
+    including a literal ``{database}`` — pass through verbatim.
+    """
+    return ddl.replace('"{database}".', f'"{database}".')
+
+
 @dataclass
 class ValidationResult:
     """
@@ -158,19 +170,19 @@ def declare(self, context=None):
         # Call declaration hook for validation (subclasses like AutoPopulate can override)
         self._declare_check(primary_key, fk_attribute_map)
 
-        sql = sql.format(database=self.database)
+        sql = _substitute_database(sql, self.database)
         try:
             # Execute pre-DDL statements (e.g., CREATE TYPE for PostgreSQL enums)
             for ddl in pre_ddl:
                 try:
-                    self.connection.query(ddl.format(database=self.database))
+                    self.connection.query(_substitute_database(ddl, self.database))
                 except Exception:
                     # Ignore errors (type may already exist)
                     pass
             self.connection.query(sql)
             # Execute post-DDL statements (e.g., COMMENT ON for PostgreSQL)
             for ddl in post_ddl:
-                self.connection.query(ddl.format(database=self.database))
+                self.connection.query(_substitute_database(ddl, self.database))
         except AccessError:
             # Only suppress if table already exists (idempotent declaration)
             # Otherwise raise - user needs to know about permission issues

tests/integration/test_declare.py

@@ -236,6 +236,24 @@ class Part(dj.Part):
     ]
 
 
+def test_braces_in_comments(schema_any):
+    """Braces in table and attribute comments are literal text, not
+    str.format template fields."""
+
+    class BraceComment(dj.Manual):
+        definition = """
+        # payload spec: {data, config}
+        brace_id : int
+        ---
+        payload = null : varchar(32)   # {data, config} payload
+        note = null : varchar(64)      # mentions {database} literally
+        """
+
+    schema_any(BraceComment, context=dict(BraceComment=BraceComment))
+    assert BraceComment.heading["payload"].comment == "{data, config} payload"
+    assert BraceComment.heading["note"].comment == "mentions {database} literally"
+
+
 def test_bad_attribute_name(schema_any):
     class BadName(dj.Manual):
         definition = """

tests/integration/test_multi_backend.py

@@ -119,6 +119,32 @@ class TypeTest(dj.Manual):
     schema.drop()
 
 
+@pytest.mark.backend_agnostic
+def test_braces_in_comments_by_backend(connection_by_backend, backend, prefix):
+    """Braces in table and attribute comments are literal text on both
+    backends — the MySQL path carries them inline in CREATE TABLE, the
+    PostgreSQL path in post-DDL COMMENT ON statements."""
+    schema = dj.Schema(
+        f"{prefix}_multi_backend_{backend}_braces",
+        connection=connection_by_backend,
+    )
+
+    @schema
+    class BraceCommented(dj.Manual):
+        definition = """
+        # payload spec: {data, config}
+        id : int
+        ---
+        payload = null : varchar(32)   # {data, config} payload
+        """
+
+    assert BraceCommented.is_declared
+    assert BraceCommented.heading["payload"].comment == "{data, config} payload"
+
+    # Cleanup
+    schema.drop()
+
+
 @pytest.mark.backend_agnostic
 def test_table_comments(connection_by_backend, backend, prefix):
     """Test that table comments are preserved on both backends."""

tests/unit/test_ddl_substitution.py

@@ -0,0 +1,16 @@
+"""Unit tests for the DDL schema-placeholder substitution in Table.declare."""
+
+from datajoint.table import _substitute_database
+
+
+def test_placeholder_fragment_substituted():
+    """The exact adapter-inserted fragment (see adapters/postgres.py enum
+    qualification) is replaced with the quoted schema name."""
+    assert _substitute_database('"{database}".enum_abc NOT NULL', "myschema") == '"myschema".enum_abc NOT NULL'
+
+
+def test_user_braces_pass_through():
+    """Brace text outside the adapter fragment — including a bare literal
+    {database} in a comment — is never touched."""
+    ddl = '`payload` varchar(32) COMMENT "{data, config} payload for {database}"'
+    assert _substitute_database(ddl, "myschema") == ddl