execsql2 2.22.9__py3-none-any.whl → 2.23.1__py3-none-any.whl

execsql/api.py

@@ -29,6 +29,7 @@ Usage::
 
 from __future__ import annotations
 
+import atexit
 import dataclasses
 import datetime
 import io
@@ -511,6 +512,11 @@ def run(
         errors: list[ScriptError] = []
         t0 = time.perf_counter()
 
+        # WRITE ... TO <file> and TEE are handled by a FileWriter subprocess,
+        # and fileio drops every write when none is running.  Start one here so
+        # the API behaves like the CLI.
+        _ensure_filewriter(conf)
+
         try:
             execute(tree, ctx=ctx)
         except SystemExit:
@@ -538,6 +544,17 @@ def run(
 
         elapsed = time.perf_counter() - t0
 
+        # Flush and close every file the script wrote, so the caller can read
+        # them the moment run() returns.  The subprocess itself is left running
+        # for reuse by a later run() and is reaped by the atexit handler; a
+        # writer the caller started is theirs and is never shut down here.
+        from execsql.utils.fileio import filewriter_close_all_after_write
+
+        try:
+            filewriter_close_all_after_write()
+        except Exception:
+            pass  # Best-effort: a failed flush must not mask a script error.
+
         # ------------------------------------------------------------------
         # Collect results
         # ------------------------------------------------------------------
@@ -571,6 +588,60 @@ def run(
 # ---------------------------------------------------------------------------
 # Helpers
 # ---------------------------------------------------------------------------
+def _ensure_filewriter(conf: Any) -> bool:
+    """Start the FileWriter subprocess if one is not already running.
+
+    ``WRITE ... TO <file>`` and ``TEE`` hand their output to a FileWriter
+    subprocess, and every entry point in :mod:`execsql.utils.fileio` guards on
+    the subprocess being alive — dropping the write when it is not, so that a
+    dead writer cannot deadlock the caller on a full pipe.  The CLI starts one
+    during startup; :func:`run` did not, so every file write under the API was
+    silently discarded and the run still reported success.
+
+    A writer started here outlives the call and is reused by a later
+    :func:`run`, exactly as the CLI keeps one for the life of the process; it
+    is reaped by an ``atexit`` handler.  A writer the caller started themselves
+    is left alone.
+
+    Returns:
+        ``True`` if this call started the writer, ``False`` if one was already
+        running.
+    """
+    import execsql.state as _state
+    import execsql.utils.fileio as _fileio
+    from execsql.utils.fileio import FileWriter, filewriter_end
+
+    if _fileio.filewriter is not None and _fileio.filewriter.is_alive():
+        return False
+
+    # Drain stale messages so a previously-dead subprocess cannot leak
+    # responses or unconsumed commands into the new one.  On macOS (`spawn`)
+    # the OS pipe buffer is small enough that retained entries would deadlock
+    # the next put().
+    for q in (_fileio.fw_input, _fileio.fw_output):
+        try:
+            while True:
+                q.get_nowait()
+        except Exception:
+            pass
+
+    try:
+        _fileio.filewriter = _state.filewriter = FileWriter(
+            _fileio.fw_input,
+            _fileio.fw_output,
+            file_encoding=conf.output_encoding,
+            open_timeout=getattr(conf, "outfile_open_timeout", 10),
+        )
+        _state.filewriter.start()
+    except Exception:
+        # Under the `spawn` start method (macOS, Windows) the subprocess
+        # re-imports the parent's __main__, which fails from a REPL, a
+        # notebook, or `python -c`.  Leave the writer unset: fileio's guards
+        # then warn on the first dropped write rather than deadlocking.
+        _fileio.filewriter = _state.filewriter = None
+        return False
+    atexit.register(filewriter_end)
+    return True
 
 
 def _capture_errors(ctx: RuntimeContext, errors: list[ScriptError]) -> None:

execsql/config.py

@@ -316,6 +316,7 @@ class ConfigData:
         self._get_int(cp, self._OUTPUT_SECTION, "zip_buffer_mb", "zip_buffer_mb")
         # --- [interface] ---
         self._get_bool(cp, self._INTERFACE_SECTION, "write_warnings", "write_warnings")
+        self._get_bool(cp, self._INTERFACE_SECTION, "support_tier_notice", "support_tier_notice")
         self._get_int(cp, self._INTERFACE_SECTION, "console_height", "gui_console_height", min_val=5)
         self._get_int(cp, self._INTERFACE_SECTION, "console_width", "gui_console_width", min_val=20)
         self._get_bool(cp, self._INTERFACE_SECTION, "console_wait_when_done", "gui_wait_on_exit")
@@ -409,6 +410,7 @@ class ConfigData:
         self.scan_lines = 100
         self.hdf5_text_len = 1000
         self.write_warnings = False
+        self.support_tier_notice = True
         self.write_prefix: str | None = None
         self.write_suffix: str | None = None
         self.gui_level: int = 0

execsql/data/execsql.conf.template

@@ -231,6 +231,11 @@
 # Values: Yes or No.  Default: No.
 #write_warnings=No
 
+# Whether opening a best-effort database connection (MS Access, Firebird,
+# Oracle, ODBC DSN) notes on stderr that the adapter is not verified in CI.
+# Values: Yes or No.  Default: Yes.
+#support_tier_notice=Yes
+
 # Text to prefix to WRITE output (with a space separator). "clear" removes a previous prefix.
 #write_prefix=
 

execsql/db/access.py

@@ -14,7 +14,8 @@ import time
 from pathlib import Path
 from typing import Any, cast
 
-from execsql.db.base import Database
+from execsql.db.base import Database, _fetched
+from execsql.db.tiers import SupportTier
 from execsql.exceptions import ErrInfo
 from execsql.utils.errors import exception_desc, fatal_error
 from execsql.utils.auth import clear_stored_password, get_password, password_from_keyring
@@ -26,6 +27,11 @@ __all__ = ["AccessDatabase"]
 class AccessDatabase(Database):
     """MS Access adapter connecting to .mdb/.accdb files via DAO (win32com) with pyodbc fallback."""
 
+    #: The Access Database Engine install on the Windows CI runner is
+    #: best-effort, so a run can silently skip these tests.
+    support_tier = SupportTier.BEST_EFFORT
+    support_tier_name = "MS Access"
+
     # Regex for the 'create temporary view' SQL extension
     temp_rx = re.compile(
         r"^\s*create(?:\s+or\s+replace)?(\s+temp(?:orary)?)?\s+(?:(view|query))\s+(\w+) as\s+",
@@ -58,13 +64,15 @@ class AccessDatabase(Database):
             fatal_error("The pyodbc module is required.  See http://github.com/mkleehammer/pyodbc")
         from execsql.types import dbt_access
 
+        super().__init__(
+            server_name=None,
+            db_name=Access_fn,
+            user_name=user_name,
+            need_passwd=need_passwd,
+        )
         self.type = dbt_access
-        self.server_name = None
-        self.db_name = Access_fn
         # The following assignment is tentative and may be changed when the connection is made.
         self.jet4 = len(Access_fn) > 6 and Access_fn.lower()[-6:] == ".accdb"
-        self.user = user_name
-        self.need_passwd = need_passwd
         self.password = password
         # Encoding is only applicable to Jet < 4.0: non-accdb databases.
         self.encoding = encoding or "windows-1252"
@@ -223,7 +231,13 @@ class AccessDatabase(Database):
         if time.time() - self.last_dao_time < 5.0:
             time.sleep(5 - (time.time() - self.last_dao_time))
 
-    def execute(self, sqlcmd: Any, paramlist: list | None = None) -> None:
+    def execute(
+        self,
+        sqlcmd: Any,
+        paramlist: list | None = None,
+        *,
+        fetch: bool = False,
+    ) -> tuple[list[str], list] | None:
         """Execute a SQL command, handling encoding, DAO flush, and temporary queries."""
 
         # A shortcut to self.cursor().execute() that handles encoding and that
@@ -231,9 +245,15 @@ class AccessDatabase(Database):
         # to allow Jet's read buffer to be flushed (see https://support.microsoft.com/en-us/kb/225048).
         # This also handles the 'CREATE TEMPORARY QUERY' extension to Access.
         # For Access, commands in a tuple (batch) are executed singly.
-        def exec1(sql: str, paramlist: list | None) -> None:
+        def exec1(sql: str, paramlist: list | None) -> tuple[list[str], list] | None:
             tqd = self.temp_rx.match(sql)
             if tqd:
+                if self.conn is not None and self.holding():
+                    self.warn_once(
+                        "temporary query",
+                        "CREATE TEMPORARY QUERY reopens the Access connection, which rolls back statements "
+                        "not yet committed under AUTOCOMMIT OFF or BEGIN BATCH.",
+                    )
                 qn = tqd.group(3)
                 qsql = sql[tqd.end() :]
                 if self.dao_conn is None:
@@ -250,7 +270,9 @@ class AccessDatabase(Database):
                     self.conn = None
                 if tqd.group(1) and tqd.group(1).strip().lower()[:4] == "temp" and qn not in self.temp_query_names:
                     self.temp_query_names.append(qn)
+                return None
             else:
+                self.before_statement(sql)
                 self.dao_flush_check()
                 with self._cursor() as curs:
                     encoded_sql: Any
@@ -263,12 +285,14 @@ class AccessDatabase(Database):
                     else:
                         curs.execute(encoded_sql, paramlist)
                     _state.subvars.add_substitution("$LAST_ROWCOUNT", curs.rowcount)
+                    return _fetched(curs) if fetch else None
 
         if type(sqlcmd) in (list, tuple):
+            result = None
             for sql in sqlcmd:
-                exec1(sql, paramlist)
-        else:
-            exec1(sqlcmd, paramlist)
+                result = exec1(sql, paramlist)
+            return result
+        return exec1(sqlcmd, paramlist)
 
     def exec_cmd(self, querycommand: str) -> None:
         """Execute a stored query command via DAO."""

execsql/db/base.py

@@ -19,15 +19,31 @@ import datetime
 import re
 from abc import ABC, abstractmethod
 from decimal import Decimal
-from typing import Any
+from typing import Any, ClassVar
 from collections.abc import Callable, Generator, Iterator
 
 from execsql.exceptions import ErrInfo
 from execsql.utils.errors import exception_desc
+from execsql.db.tiers import SupportTier, announce_tier
 import execsql.state as _state
 
 __all__ = ["Database", "DatabasePool"]
 
+# Leading whitespace and comments, skipped to find a statement's first words.
+_LEADING_NOISE_RX = re.compile(r"(?:\s+|--[^\n]*(?:\n|$)|/\*.*?\*/)*", re.S)
+
+# Statements that manage a transaction themselves; one is never opened in front of them.
+_TRANSACTION_CONTROL_RX = re.compile(
+    r"(?:BEGIN|START\s+TRANSACTION|COMMIT|END|ROLLBACK|ABORT|SAVEPOINT|RELEASE)\b",
+    re.I,
+)
+
+
+def statement_start(sql: str) -> str:
+    """*sql* from its first keyword on: leading whitespace and comments removed."""
+    match = _LEADING_NOISE_RX.match(sql)
+    return sql[match.end() :] if match else sql
+
 
 def _default_dt_cast() -> dict[type, Callable]:
     """Build the default type-cast mapping used by all database backends."""
@@ -45,6 +61,13 @@ def _default_dt_cast() -> dict[type, Callable]:
     }
 
 
+def _fetched(curs: Any) -> tuple[list[str], list] | None:
+    """The rows a just-executed cursor produced, as ``(column_names, rows)``; ``None`` if none."""
+    if curs.description is None:
+        return None
+    return [d[0] for d in curs.description], curs.fetchall()
+
+
 class Database(ABC):
     """Abstract base class for every DBMS adapter.
 
@@ -80,6 +103,15 @@ class Database(ABC):
     conn: Any
     autocommit: bool
 
+    #: How thoroughly this adapter is verified.  Subclasses that are not
+    #: exercised against a live server in CI override this with
+    #: ``SupportTier.BEST_EFFORT``; see :mod:`execsql.db.tiers`.
+    support_tier: ClassVar[SupportTier] = SupportTier.SUPPORTED
+
+    #: Name used in the best-effort notice.  Defaults to the class name minus
+    #: the ``Database`` suffix (``FirebirdDatabase`` -> ``Firebird``).
+    support_tier_name: ClassVar[str | None] = None
+
     _dt_cast: dict[type, Callable] | None = None
 
     @property
@@ -205,13 +237,17 @@ class Database(ABC):
         """Return a comma-separated string of *paramcount* parameter placeholders."""
         return ",".join((self.paramstr,) * paramcount)
 
-    def execute(self, sql: Any, paramlist: list | None = None) -> None:
+    def execute(self, sql: Any, paramlist: list | None = None, *, fetch: bool = False) -> tuple[list[str], list] | None:
         """Execute *sql* (optionally with *paramlist*), updating ``$LAST_ROWCOUNT``.
 
+        With *fetch*, return ``(column_names, rows)`` when the statement
+        produces rows (a prompt shows them), else ``None``.
+
         Rolls back the current transaction and re-raises on any driver error.
         """
         if type(sql) in (tuple, list):
             sql = " ".join(sql)
+        self.before_statement(sql)
         try:
             with self._cursor() as curs:
                 if paramlist is None:
@@ -222,6 +258,7 @@ class Database(ABC):
                     _state.subvars.add_substitution("$LAST_ROWCOUNT", curs.rowcount)
                 except Exception:
                     pass  # Non-critical: some drivers lack rowcount support.
+                return _fetched(curs) if fetch else None
         except Exception:
             try:
                 self.rollback()
@@ -234,6 +271,81 @@ class Database(ABC):
         """Execute a stored procedure or function by name."""
         ...
 
+    # ------------------------------------------------------------------
+    # Holding statements until commit (AUTOCOMMIT OFF, BEGIN BATCH)
+    # ------------------------------------------------------------------
+
+    #: Statements the DBMS commits on its own, with everything run before
+    #: them, even inside a transaction (MySQL and Oracle DDL).  Matched against
+    #: the start of the statement; a warning names each one run while holding.
+    implicit_commit_rx: ClassVar[re.Pattern[str] | None] = None
+
+    #: Statements that cannot run inside a transaction on this DBMS; one is
+    #: not opened in front of them.
+    no_transaction_rx: ClassVar[re.Pattern[str] | None] = None
+
+    #: Set on a connection whose driver could only connect in autocommit mode
+    #: (an ODBC DSN without transactions): nothing can be held back.
+    driver_autocommits: bool = False
+
+    def holding(self) -> bool:
+        """Whether statements on this connection wait for a commit.
+
+        True while AUTOCOMMIT is OFF for this database, or inside BEGIN BATCH
+        (which holds every database).
+        """
+        if not self.autocommit:
+            return True
+        status = _state.status
+        return status is not None and status.batch.in_batch()
+
+    def before_statement(self, sql: str) -> None:
+        """Make sure *sql* is held until commit when execsql is holding statements.
+
+        Most drivers already hold every statement: they open a transaction
+        before the first one and keep it open until commit or rollback.  An
+        adapter whose driver does not (SQLite for DDL, DuckDB for everything)
+        overrides :meth:`begin_transaction`.  Where the DBMS itself commits a
+        statement regardless, a warning says so, since the work cannot be
+        rolled back.
+        """
+        if not self.holding():
+            return
+        if self.driver_autocommits:
+            self.warn_once(
+                "driver",
+                f"{self.name()} cannot hold statements until COMMIT: its driver commits each one as it runs. "
+                "AUTOCOMMIT OFF and BEGIN BATCH have no effect on it.",
+            )
+            return
+        start = statement_start(sql)
+        if self.implicit_commit_rx is not None and (m := self.implicit_commit_rx.match(start)):
+            from execsql.utils.errors import write_warning
+
+            write_warning(
+                f"{self.type.dbms_id} commits {' '.join(m.group(0).upper().split())} immediately, together with "
+                "everything run before it; it cannot be rolled back.",
+                always=True,
+            )
+        if _TRANSACTION_CONTROL_RX.match(start):
+            return
+        if self.no_transaction_rx is not None and self.no_transaction_rx.match(start):
+            return
+        self.begin_transaction()
+
+    def begin_transaction(self) -> None:
+        """Open a transaction if none is open.  Most drivers do this themselves; a no-op here."""
+
+    def warn_once(self, key: str, message: str) -> None:
+        """Write *message* as a warning the first time *key* comes up on this connection."""
+        warned: set[str] = self.__dict__.setdefault("_warned", set())
+        if key in warned:
+            return
+        warned.add(key)
+        from execsql.utils.errors import write_warning
+
+        write_warning(message, always=True)
+
     def autocommit_on(self) -> None:
         """Enable autocommit mode so each statement is committed immediately."""
         self.autocommit = True
@@ -552,6 +664,7 @@ class Database(ABC):
         rows = iter(rowsource)
         eof = False
         total_rows = 0
+        self.before_statement(sql)
 
         # Optional rich progress bar for long-running imports.
         use_progress = getattr(_state.conf, "show_progress", False)
@@ -735,6 +848,7 @@ class Database(ABC):
         sq_name = self.schema_qualified_table_name(schema_name, table_name)
         quoted_col = self.quote_identifier(column_name)
         sql = f"insert into {sq_name} ({quoted_col}) values ({self.paramsubs(1)});"
+        self.before_statement(sql)
         with self._cursor() as curs:
             curs.execute(sql, (filedata,))
 
@@ -778,6 +892,10 @@ class DatabasePool:
                 )
             self.pool[db_alias].close()
         self.pool[db_alias] = db_obj
+        announce_tier(
+            db_obj.support_tier,
+            db_obj.support_tier_name or type(db_obj).__name__.removesuffix("Database"),
+        )
         # Refresh static system vars so $DB_NAME, $DB_USER, etc. reflect the new connection.
         try:
             from execsql.script.engine import set_static_system_vars

execsql/db/dsn.py

@@ -10,6 +10,7 @@ the CLI.
 
 
 from execsql.db.base import Database
+from execsql.db.tiers import SupportTier
 from execsql.exceptions import ErrInfo
 from execsql.utils.errors import exception_desc, fatal_error
 from execsql.utils.auth import clear_stored_password, get_password, password_from_keyring
@@ -21,6 +22,11 @@ __all__ = ["DsnDatabase"]
 class DsnDatabase(Database):
     """Generic ODBC adapter that connects to any data source registered as an ODBC DSN via pyodbc."""
 
+    #: CI covers DSN string parsing only — no live DSN is ever opened,
+    #: and a DSN may front any DBMS at all.
+    support_tier = SupportTier.BEST_EFFORT
+    support_tier_name = "ODBC DSN"
+
     # There's no telling what is actually connected to a DSN, so this uses
     # generic Database methods almost exclusively.  Only 'exec_cmd()' is
     # overridden, and that uses the method for SQL Server because the DAO
@@ -41,18 +47,17 @@ class DsnDatabase(Database):
             fatal_error("The pyodbc module is required.  See http://github.com/mkleehammer/pyodbc")
         from execsql.types import dbt_dsn
 
+        super().__init__(
+            server_name=None,
+            db_name=dsn_name,
+            user_name=user_name,
+            need_passwd=need_passwd,
+        )
         self.type = dbt_dsn
-        self.server_name = None
-        self.db_name = dsn_name
-        self.user = user_name
-        self.need_passwd = need_passwd
         self.password = password
-        self.port = None
         self.encoding = encoding
         self.encode_commands = True
         self.paramstr = "?"
-        self.conn = None
-        self.autocommit = True
         self.open_db()
         self.password = None  # Clear cleartext password after successful connection
 
@@ -104,6 +109,8 @@ class DsnDatabase(Database):
                 if "Optional feature not implemented" in excdesc:
                     try:
                         _dsn_connect(autocommit=True)
+                        # This ODBC driver has no transactions: nothing can be held.
+                        self.driver_autocommits = True
                     except Exception as e:
                         raise ErrInfo(
                             type="exception",

execsql/db/duckdb.py

@@ -8,18 +8,55 @@ analytics databases via the ``duckdb`` package.  Corresponds to ``-t k``
 on the CLI.
 """
 
+import re
 from pathlib import Path
+from typing import Any
 
-from execsql.db.base import Database
+from execsql.db.base import Database, statement_start
 from execsql.exceptions import ErrInfo
 from execsql.utils.errors import exception_desc, fatal_error
 import execsql.state as _state
 
 __all__ = ["DuckDBDatabase"]
 
+# Statements that return rows; any other statement DuckDB answers with a
+# one-column "Count" result (rows inserted, updated or deleted).
+_QUERY_RX = re.compile(r"(?:SELECT|WITH|VALUES|FROM|TABLE|SHOW|DESCRIBE|SUMMARIZE|EXPLAIN|PRAGMA|CALL)\b|\(", re.I)
+
+# A statement that opens a transaction, or one that ends it.
+_TRANSACTION_RX = re.compile(r"(?P<begin>BEGIN|START\s+TRANSACTION)\b|(?P<end>COMMIT|END|ROLLBACK|ABORT)\b", re.I)
+
+
+class _SharedCursor:
+    """The connection, used as a cursor so a statement joins its open transaction.
+
+    A DuckDB cursor is a separate connection with a transaction of its own,
+    and closing it rolls that transaction back.  ``close()`` therefore leaves
+    the connection open.
+    """
+
+    def __init__(self, conn: Any) -> None:
+        self._conn = conn
+
+    def __getattr__(self, name: str) -> Any:
+        return getattr(self._conn, name)
+
+    def close(self) -> None:
+        pass
+
 
 class DuckDBDatabase(Database):
-    """DuckDB in-process analytics adapter using the duckdb package."""
+    """DuckDB in-process analytics adapter using the duckdb package.
+
+    The duckdb driver commits each statement unless a transaction was begun,
+    and has no way to ask whether one is open, so this adapter begins one
+    itself while statements are held (AUTOCOMMIT OFF, BEGIN BATCH) and keeps
+    track of it.  While it is open, every statement runs on the connection
+    itself rather than on a cursor (see :class:`_SharedCursor`).
+    """
+
+    #: A transaction this adapter or a script's own BEGIN opened, not yet ended.
+    in_transaction: bool = False
 
     def __init__(self, DuckDB_fn: str) -> None:
         try:
@@ -28,22 +65,77 @@ class DuckDBDatabase(Database):
             fatal_error("The duckdb module is required.")
         from execsql.types import dbt_duckdb
 
+        super().__init__(
+            server_name=None,
+            db_name=DuckDB_fn,
+            user_name=None,
+            need_passwd=False,
+            encoding="UTF-8",
+        )
         self.type = dbt_duckdb
-        self.server_name = None
-        self.db_name = DuckDB_fn
         self.catalog_name = Path(DuckDB_fn).stem
-        self.user = None
-        self.need_passwd = False
-        self.encoding = "UTF-8"
         self.encode_commands = False
-        self.paramstr = "?"
-        self.conn = None
-        self.autocommit = True
         self.open_db()
 
     def __repr__(self) -> str:
         return f"DuckDBDatabase({self.db_name!r})"
 
+    def cursor(self) -> Any:
+        """A cursor, or while a transaction is open, the connection itself."""
+        if self.conn is None:
+            self.open_db()
+        if self.in_transaction:
+            return _SharedCursor(self.conn)
+        return self.conn.cursor()
+
+    def begin_transaction(self) -> None:
+        """Open a transaction if none is open."""
+        if self.conn is None:
+            self.open_db()
+        if not self.in_transaction:
+            # A second BEGIN would abort the open transaction, hence the tracking.
+            self.conn.execute("BEGIN TRANSACTION")
+            self.in_transaction = True
+
+    def execute(self, sql: Any, paramlist: list | None = None, *, fetch: bool = False) -> tuple[list[str], list] | None:
+        """Execute *sql*, noting a transaction the statement itself begins or ends.
+
+        The driver's ``rowcount`` is always -1: DuckDB answers an INSERT,
+        UPDATE or DELETE with a one-column ``Count`` result instead, which is
+        read here to set ``$LAST_ROWCOUNT`` as other drivers do.
+        """
+        text = " ".join(sql) if type(sql) in (tuple, list) else sql
+        start = statement_start(text)
+        m = _TRANSACTION_RX.match(start)
+        if m and m.group("begin"):
+            self.in_transaction = True  # so the BEGIN itself runs on the connection
+        query = bool(_QUERY_RX.match(start))
+        result = super().execute(sql, paramlist, fetch=fetch or not query)
+        if m and m.group("end"):
+            self.in_transaction = False
+        if not query and result is not None and result[0] == ["Count"]:
+            rows = result[1]
+            if _state.subvars is not None:
+                _state.subvars.add_substitution("$LAST_ROWCOUNT", rows[0][0] if rows else -1)
+            return None
+        return result if fetch else None
+
+    def commit(self) -> None:
+        """Commit the open transaction if autocommit is enabled."""
+        super().commit()
+        if self.autocommit:
+            self.in_transaction = False
+
+    def rollback(self) -> None:
+        """Roll back the open transaction."""
+        super().rollback()
+        self.in_transaction = False
+
+    def close(self) -> None:
+        """Close the connection; an open transaction is rolled back."""
+        super().close()
+        self.in_transaction = False
+
     def open_db(self) -> None:
         """Open a connection to the DuckDB database file."""
         import duckdb

execsql/db/firebird.py

@@ -9,6 +9,7 @@ via the ``firebird-driver`` package.  Corresponds to ``-t f`` on the CLI.
 
 
 from execsql.db.base import Database
+from execsql.db.tiers import SupportTier
 from execsql.exceptions import ErrInfo
 from execsql.utils.errors import exception_desc, fatal_error
 from execsql.utils.auth import clear_stored_password, get_password, password_from_keyring
@@ -20,6 +21,10 @@ __all__ = ["FirebirdDatabase"]
 class FirebirdDatabase(Database):
     """Firebird adapter using the firebird-driver package."""
 
+    #: No Firebird server runs in CI; this adapter has no tests.
+    support_tier = SupportTier.BEST_EFFORT
+    support_tier_name = "Firebird"
+
     def __init__(
         self,
         server_name: str,
@@ -39,18 +44,18 @@ class FirebirdDatabase(Database):
             )
         from execsql.types import dbt_firebird
 
+        super().__init__(
+            server_name=str(server_name),
+            db_name=str(db_name),
+            user_name=str(user_name),
+            need_passwd=need_passwd,
+            port=port if port else 3050,
+        )
         self.type = dbt_firebird
-        self.server_name = str(server_name)
-        self.db_name = str(db_name)
-        self.user = str(user_name)
-        self.need_passwd = need_passwd
         self.password = password
-        self.port = port if port else 3050
         self.encoding = encoding or "latin1"
         self.encode_commands = True
         self.paramstr = "?"
-        self.conn = None
-        self.autocommit = True
         self.open_db()
         self.password = None  # Clear cleartext password after successful connection