execsql2 2.24.0__py3-none-any.whl → 2.25.1__py3-none-any.whl

execsql/cli/run.py

@@ -514,7 +514,8 @@ def _setup_logging(
     opts_dict = {
         k: v
         for k, v in {
-            "sub_vars": sub_vars,
+            # Count only: -a values are opaque and often secrets.
+            "sub_vars": f"{len(sub_vars)} value(s)" if sub_vars else None,
             "boolean_int": boolean_int,
             "make_dirs": make_dirs,
             "database_encoding": database_encoding,
@@ -535,7 +536,7 @@ def _setup_logging(
     }
     logger = Logger(
         script_name or "<inline>",
-        conf.db or "",
+        conf.db or conf.db_file or "",
         conf.server,
         opts_dict,
         conf.user_logfile,
@@ -552,6 +553,9 @@ def _setup_logging(
         )
 
     subvars.add_substitution("$RUN_ID", logger.run_id)
+    # Passwords from the DSN or config files, known before the first connection.
+    logger.add_redaction_value(getattr(conf, "db_password", None))
+    logger.add_redaction_value(getattr(conf, "smtp_password", None))
 
     if sub_vars:
         for n, repl in enumerate(sub_vars):
@@ -740,27 +744,13 @@ def _run(
         manifest = _manifest.start(manifest_path, script_name, variables)
         manifest.config_files = list(conf.files_read)
 
-    import execsql.utils.fileio as _fileio
-
     if _state.filewriter is None or not _state.filewriter.is_alive():
-        # Drain stale messages from the queues so a previously-dead subprocess
-        # can't leak responses or unconsumed commands into the new one. On
-        # macOS (`spawn`) the OS pipe buffer is small enough that retained
-        # entries from a crashed writer would deadlock the next put().
-        for q in (_fileio.fw_input, _fileio.fw_output):
-            try:
-                while True:
-                    q.get_nowait()
-            except Exception:
-                pass
-        _fileio.filewriter = _state.filewriter = FileWriter(
-            _fileio.fw_input,
-            _fileio.fw_output,
+        _state.filewriter = FileWriter(
             file_encoding=conf.output_encoding,
             open_timeout=getattr(conf, "outfile_open_timeout", 10),
         )
         _state.filewriter.start()
-        atexit.register(filewriter_end)
+        atexit.register(filewriter_end, _state.filewriter)
 
     # ------------------------------------------------------------------
     # Logging
@@ -856,6 +846,28 @@ def _run(
 # ---------------------------------------------------------------------------
 
 
+def _end_run_on_sigterm() -> None:
+    """Make SIGTERM end the process through ``SystemExit`` (exit status 143).
+
+    Python's default SIGTERM action stops the process without running
+    ``atexit`` handlers, so the run's log (buffered until close) was lost,
+    the open transaction was not rolled back explicitly, and a running
+    ``SYSTEM_CMD`` was left behind.  ``timeout``, ``docker stop``, systemd
+    and CI cancellation all send SIGTERM.  Installed by the console entry
+    point only: ``execsql.run()`` leaves the host program's signals alone.
+    """
+    import signal
+
+    def _terminate(signum: int, _frame: Any) -> None:
+        import execsql.state as _state
+
+        if _state.exec_log is not None:
+            _state.exec_log.log_exit_terminated()
+        raise SystemExit(128 + signum)
+
+    signal.signal(signal.SIGTERM, _terminate)
+
+
 def _execute_script_ast(
     tree: Any,
     conf: ConfigData,
@@ -883,7 +895,8 @@ def _execute_script_ast(
     try:
         execute(tree)
     except SystemExit as exc:
-        if gui_console_isrunning() and conf.gui_wait_on_exit:
+        terminated = _state.exec_log is not None and _state.exec_log.exit_type == "terminated"
+        if gui_console_isrunning() and conf.gui_wait_on_exit and not terminated:
             gui_console_wait_user(
                 "Script complete; close the console window to exit execsql.",
             )
@@ -895,6 +908,9 @@ def _execute_script_ast(
         sys.exit(exc.code)
     except ConfigError:
         raise
+    except KeyboardInterrupt:
+        _state.exec_log.log_exit_interrupted()
+        raise
     except ErrInfo as exc:
         from execsql.utils.errors import exit_now
 
@@ -908,6 +924,7 @@ def _execute_script_ast(
         exit_now(1, ErrInfo("exception", exception_msg=msg))
 
     _state.dbs.do_rollback = False
+    _flush_output_files()
     if gui_console_isrunning() and conf.gui_wait_on_exit:
         gui_console_wait_user(
             "Script complete; close the console window to exit execsql.",
@@ -970,10 +987,30 @@ def _execute_script_textual_console(tree: Any, conf: ConfigData) -> None:
             exit_now(1, ErrInfo("exception", exception_msg=msg))
 
     _state.dbs.do_rollback = False
+    _flush_output_files()
     _state.exec_log.log_status_info(f"{_state.cmds_run} commands run")
     _state.exec_log.log_exit_end()
 
 
+def _flush_output_files() -> None:
+    """Flush file output at the normal end of a script; lost output fails the run.
+
+    A WRITE/EXPORT target that stays locked past ``outfile_open_timeout`` has
+    its output discarded.  That must not end in a successful exit status.
+    """
+    from execsql.utils.fileio import filewriter_close_all_after_write
+
+    try:
+        filewriter_close_all_after_write()
+    except ErrInfo as exc:
+        from execsql.utils.errors import exit_now
+
+        # The loss belongs to no particular statement; keep exit_now from
+        # attributing it to whatever line happened to run last.
+        exc.script_file = ""
+        exit_now(1, exc)
+
+
 # ---------------------------------------------------------------------------
 # Utility: build the database connection for the initial/default database
 # ---------------------------------------------------------------------------

execsql/config.py

@@ -372,6 +372,8 @@ class ConfigData:
         self._get_str(cp, self._EMAIL_SECTION, "password", "smtp_password")
         self._get_bool(cp, self._EMAIL_SECTION, "use_ssl", "smtp_ssl")
         self._get_bool(cp, self._EMAIL_SECTION, "use_tls", "smtp_tls")
+        self._get_bool(cp, self._EMAIL_SECTION, "verify_certificate", "smtp_verify_certificate")
+        self._get_str(cp, self._EMAIL_SECTION, "ca_file", "smtp_ca_file")
         self._get_str(cp, self._EMAIL_SECTION, "message_css", "email_css")
         # --- [format] and [lint]: read by `execsql format` / `execsql lint`; a run ignores them ---
         self._get_int(cp, self._FORMAT_SECTION, "indent", "format_indent")
@@ -523,6 +525,8 @@ class ConfigData:
         self.smtp_password: str | None = None
         self.smtp_ssl = False
         self.smtp_tls = False
+        self.smtp_verify_certificate = True
+        self.smtp_ca_file: str | None = None
         self.email_format = "plain"
         self.email_css: str | None = None
         self.include_req: list = []
@@ -727,13 +731,12 @@ class WriteHooks:
     """
 
     def __repr__(self) -> str:
-        return f"WriteHooks({self.write_func!r}, {self.err_func!r}, {self.status_func!r})"
+        return f"WriteHooks({self.write_func!r}, {self.err_func!r})"
 
     def __init__(
         self,
         standard_output_func: Callable[[str], object] | None = None,
         error_output_func: Callable[[str], object] | None = None,
-        status_output_func: Callable[[str], object] | None = None,
     ) -> None:
         """Store optional hook callables; ``None`` means use the default stream.
 
@@ -742,8 +745,6 @@ class WriteHooks:
                 ``None`` to use ``sys.stdout``.
             error_output_func: Callable to receive error-output text, or
                 ``None`` to use ``sys.stderr``.
-            status_output_func: Callable to receive status-line text, or
-                ``None`` to suppress.
         """
         # Arguments should be functions that take a single string and
         # write it to the desired destination.  Both stdout and stderr can be hooked.
@@ -752,7 +753,6 @@ class WriteHooks:
         # The purpose is to allow writing to be redirected to a GUI.
         self.write_func = standard_output_func
         self.err_func = error_output_func
-        self.status_func = status_output_func
         self.tee_stderr = True
 
     def reset(self) -> None:
@@ -770,15 +770,6 @@ class WriteHooks:
         self.err_func = error_output_func
         self.tee_stderr = tee
 
-    def redir(
-        self,
-        standard_output_func: Callable[[str], object],
-        error_output_func: Callable[[str], object],
-    ) -> None:
-        """Redirect both stdout and stderr hooks in one call."""
-        self.redir_stdout(standard_output_func)
-        self.redir_stderr(error_output_func)
-
     def write(self, strval: str) -> None:
         """Write a string to the standard-output hook, or to sys.stdout if unset."""
         if self.write_func:
@@ -799,8 +790,3 @@ class WriteHooks:
         else:
             sys.stderr.write(strval)
             sys.stderr.flush()
-
-    def write_status(self, strval: str) -> None:
-        """Forward a status string to the status hook if one is registered."""
-        if self.status_func:
-            self.status_func(strval)

execsql/data/execsql.conf.template

@@ -46,7 +46,7 @@
 #password_prompt=Yes
 
 # Whether to use the OS credential store (keyring) for password storage.
-# Requires: pip install execsql2[auth]
+# Requires the auth extra: uv tool install "execsql2[auth]"
 # Values: Yes or No.  Default: Yes.
 #use_keyring=Yes
 
@@ -71,7 +71,8 @@
 [input]
 # Settings for handling imported data.
 
-# Whether to convert numeric values to double precision when using MS Access.
+# MS Access: create columns for decimal data as NUMERIC(precision,scale)
+# (Yes) or as DOUBLE (No) when IMPORT or COPY creates a table.
 # Values: Yes or No.  Default: No.
 #access_use_numeric=No
 
@@ -261,6 +262,15 @@
 # Values: Yes or No.  Default: No.
 #use_tls=No
 
+# Whether to verify the SMTP server's certificate when use_ssl or use_tls is on.
+# Turn off only for a test relay; prefer ca_file for an internal certificate.
+# Values: Yes or No.  Default: Yes.
+#verify_certificate=Yes
+
+# CA certificate file (PEM) to trust, for a server with an internal or
+# self-signed certificate.  Default: the system's trusted CAs.
+#ca_file=
+
 # Email body format.
 # Values: plain or html.  Default: plain.
 #email_format=plain
@@ -297,8 +307,8 @@
 # Values: Yes or No.  Default: Yes.
 #allow_rm_file=Yes
 
-# Whether to allow the SERVE metacommand (which opens an HTTP server on
-# a local port to serve a single file). Set to No to disable.
+# Whether to allow the SERVE metacommand (which copies a file to stdout
+# with HTTP headers, for CGI use). Set to No to disable.
 # Also controllable via --no-serve CLI flag.
 # Values: Yes or No.  Default: Yes.
 #allow_serve=Yes

execsql/db/access.py

@@ -18,7 +18,14 @@ 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
+from execsql.utils.auth import (
+    begin_login,
+    clear_stored_password,
+    get_password,
+    is_login_failure,
+    password_from_keyring,
+    remember_password,
+)
 import execsql.state as _state
 
 __all__ = ["AccessDatabase"]
@@ -76,7 +83,6 @@ class AccessDatabase(Database):
         self.password = password
         # Encoding is only applicable to Jet < 4.0: non-accdb databases.
         self.encoding = encoding or "windows-1252"
-        self.encode_commands = True
         self.dao_conn: Any = None
         self.conn = None  # ODBC connection
         self.paramstr = "?"
@@ -104,9 +110,12 @@ class AccessDatabase(Database):
         if self.conn is not None:
             self.conn.close()
             self.conn = None
+        begin_login()
         if self.need_passwd and self.user and self.password is None:
             self.password = get_password("MS-Access", self.db_name, self.user)
 
+        errors: list[BaseException] = []
+
         def _try_odbc_drivers():
             db_name = str(Path(self.db_name).resolve())
             for cs, jet4flag in self.connection_strings:
@@ -120,7 +129,8 @@ class AccessDatabase(Database):
                     # the connect attempt at 30 s to match the other
                     # adapters.
                     self.conn = pyodbc.connect(connstr, timeout=30)
-                except Exception:
+                except Exception as e:
+                    errors.append(e)
                     if _state.exec_log is not None:
                         _state.exec_log.log_status_info(
                             f"Could not connect via ODBC using: {re.sub(r'Pwd=[^;]*', 'Pwd=***', connstr)}",
@@ -134,7 +144,8 @@ class AccessDatabase(Database):
                     return True
             return False
 
-        if not _try_odbc_drivers() and password_from_keyring():
+        # Only a rejected password means the stored one is stale.
+        if not _try_odbc_drivers() and password_from_keyring() and any(is_login_failure(e) for e in errors):
             clear_stored_password("MS-Access", self.db_name, self.user)
             self.password = get_password(
                 "MS-Access",
@@ -144,6 +155,8 @@ class AccessDatabase(Database):
                 other_msg="(stored credential failed — enter current password)",
             )
             _try_odbc_drivers()
+        if self.conn and self.user:
+            remember_password("MS-Access", self.db_name, self.user)
 
         if not self.conn:
             raise ErrInfo(
@@ -158,10 +171,13 @@ class AccessDatabase(Database):
         if self.dao_conn is not None:
             self.dao_conn.Close()
             self.dao_conn = None
+        begin_login()
         if self.need_passwd and self.user and self.password is None:
             self.password = get_password("MS-Access", self.db_name, self.user)
         dao_engines = ("DAO.DBEngine.120", "DAO.DBEngine.36")
 
+        dao_errors: list[BaseException] = []
+
         def _try_dao_engines():
             for engine in dao_engines:
                 try:
@@ -175,7 +191,8 @@ class AccessDatabase(Database):
                         )
                     else:
                         self.dao_conn = daoEngine.OpenDatabase(self.db_name)
-                except Exception:
+                except Exception as e:
+                    dao_errors.append(e)
                     if _state.exec_log is not None:
                         _state.exec_log.log_status_info(f"Could not connect via DAO using: {engine}")
                 else:
@@ -184,7 +201,7 @@ class AccessDatabase(Database):
                     return True
             return False
 
-        if not _try_dao_engines() and password_from_keyring():
+        if not _try_dao_engines() and password_from_keyring() and any(is_login_failure(e) for e in dao_errors):
             clear_stored_password("MS-Access", self.db_name, self.user)
             self.password = get_password(
                 "MS-Access",
@@ -194,6 +211,8 @@ class AccessDatabase(Database):
                 other_msg="(stored credential failed — enter current password)",
             )
             _try_dao_engines()
+        if self.dao_conn and self.user:
+            remember_password("MS-Access", self.db_name, self.user)
 
         if not self.dao_conn:
             raise ErrInfo(
@@ -339,6 +358,9 @@ class AccessDatabase(Database):
 
         return headers, iter(dict_row, None)
 
+    # table_exists() without a schema looks only where CREATE TABLE puts a table: one namespace.
+    unqualified_lookup_is_scoped = True
+
     def table_exists(self, table_name: str, schema_name: str | None = None) -> bool:
         """Return True if the named table exists in the Access database.
 
@@ -418,9 +440,8 @@ class AccessDatabase(Database):
         return False
 
     def drop_table(self, tablename: str) -> None:
-        """Drop the named table from the Access database."""
+        """Drop *tablename*, quoted by the caller."""
         self.dao_flush_check()
-        tablename = self.type.quoted(tablename)
         self.execute(f"drop table {tablename};")
 
     def as_datetime(self, val: Any) -> datetime.datetime | datetime.date | datetime.time | None:

execsql/db/base.py

@@ -98,7 +98,6 @@ class Database(ABC):
     password: str | None
     port: int | None
     encoding: Any
-    encode_commands: bool
     paramstr: str
     conn: Any
     autocommit: bool
@@ -143,7 +142,6 @@ class Database(ABC):
         self.password: str | None = None
         self.port = port
         self.encoding = encoding
-        self.encode_commands = True
         self.paramstr = "?"
         self.conn = None
         self.autocommit = True
@@ -494,6 +492,21 @@ class Database(ABC):
             rows = curs.fetchall()
         return len(rows) > 0
 
+    #: Whether :meth:`table_exists` without a schema already looks only where
+    #: an unqualified ``CREATE TABLE`` puts a table (one namespace, or the
+    #: search path).  When not, the check is narrowed to :meth:`current_schema`.
+    unqualified_lookup_is_scoped = False
+
+    def current_schema(self) -> str | None:
+        """The schema (MySQL: database) an unqualified table name is created in, or ``None`` if unknown."""
+        return None
+
+    def _query_current_schema(self, sql: str) -> str | None:
+        with self._cursor() as curs:
+            curs.execute(sql)
+            row = curs.fetchone()
+        return str(row[0]) if row and row[0] else None
+
     def table_exists(self, table_name: str, schema_name: str | None = None) -> bool:
         """Return ``True`` if *table_name* (optionally in *schema_name*) exists."""
         with self._cursor() as curs:
@@ -665,6 +678,17 @@ class Database(ABC):
         eof = False
         total_rows = 0
         self.before_statement(sql)
+        # The rows go in as several batches and are committed once, by the
+        # caller.  Most drivers hold every batch in the transaction they open
+        # themselves; DuckDB's commits each statement unless one is open, so a
+        # failure would leave the batches before it behind.
+        self.begin_transaction()
+        if self.driver_autocommits:
+            self.warn_once(
+                "import",
+                f"{self.name()} commits each statement as it runs, so an IMPORT or COPY that fails part-way "
+                "leaves the rows already loaded.",
+            )
 
         # Optional rich progress bar for long-running imports.
         use_progress = getattr(_state.conf, "show_progress", False)
@@ -739,6 +763,8 @@ class Database(ABC):
                                             )
                                         if not _state.conf.empty_strings and line[i].strip() == "":
                                             line[i] = None
+                            # Trailing values left off the line are NULL.
+                            line = list(line) + [None] * (len(ts_colnames) - len(line))
                             lt = [
                                 type_objs[i].from_data(val) if val is not None else None for i, val in enumerate(line)
                             ]
@@ -777,13 +803,19 @@ class Database(ABC):
                     break
             return total_rows
 
-        with self._cursor() as curs:
-            if use_progress and progress_ctx is not None:
-                with progress_ctx:
-                    task_id = progress_ctx.add_task(sq_name, total=None)
+        try:
+            with self._cursor() as curs:
+                if use_progress and progress_ctx is not None:
+                    with progress_ctx:
+                        task_id = progress_ctx.add_task(sq_name, total=None)
+                        _import_loop(curs)
+                else:
                     _import_loop(curs)
-            else:
-                _import_loop(curs)
+        except BaseException:
+            # A bad value or short row stops the load as surely as a failed
+            # insert does; either way none of it is kept.
+            self.rollback()
+            raise
 
         if _state.exec_log:
             _state.exec_log.log_status_info(

execsql/db/dsn.py

@@ -13,7 +13,14 @@ 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
+from execsql.utils.auth import (
+    begin_login,
+    clear_stored_password,
+    get_password,
+    is_login_failure,
+    password_from_keyring,
+    remember_password,
+)
 import execsql.state as _state
 
 __all__ = ["DsnDatabase"]
@@ -56,7 +63,6 @@ class DsnDatabase(Database):
         self.type = dbt_dsn
         self.password = password
         self.encoding = encoding
-        self.encode_commands = True
         self.paramstr = "?"
         self.open_db()
         self.password = None  # Clear cleartext password after successful connection
@@ -72,6 +78,7 @@ class DsnDatabase(Database):
         if self.conn is not None:
             self.conn.close()
             self.conn = None
+        begin_login()
         if self.need_passwd and self.user and self.password is None:
             self.password = get_password("DSN", self.db_name, self.user)
 
@@ -126,8 +133,9 @@ class DsnDatabase(Database):
 
         try:
             _try_connect()
-        except ErrInfo:
-            if not password_from_keyring():
+        except ErrInfo as e:
+            # Only a rejected password means the stored one is stale.
+            if not (password_from_keyring() and is_login_failure(e)):
                 raise
             clear_stored_password("DSN", self.db_name, self.user)
             self.password = get_password(
@@ -139,6 +147,7 @@ class DsnDatabase(Database):
             )
             self.conn = None
             _try_connect()
+        remember_password("DSN", self.db_name, self.user or "")
 
     def exec_cmd(self, querycommand: str) -> None:
         """Execute a stored procedure by name."""

execsql/db/duckdb.py

@@ -74,9 +74,11 @@ class DuckDBDatabase(Database):
         )
         self.type = dbt_duckdb
         self.catalog_name = Path(DuckDB_fn).stem
-        self.encode_commands = False
         self.open_db()
 
+    def current_schema(self) -> str | None:
+        return self._query_current_schema("select current_schema()")
+
     def __repr__(self) -> str:
         return f"DuckDBDatabase({self.db_name!r})"
 

execsql/db/factory.py

@@ -64,7 +64,16 @@ def db_Postgres(
     password: str | None = None,
 ) -> PostgresDatabase:
     """Open a new PostgreSQL connection via psycopg (psycopg3)."""
-    return PostgresDatabase(server_name, database_name, user, pw_needed, port, new_db=new_db, password=password)
+    return PostgresDatabase(
+        server_name,
+        database_name,
+        user,
+        pw_needed,
+        port,
+        new_db=new_db,
+        encoding=encoding,
+        password=password,
+    )
 
 
 def db_SQLite(
@@ -143,7 +152,7 @@ def db_Oracle(
     encoding: str | None = None,
     password: str | None = None,
 ) -> OracleDatabase:
-    """Open an Oracle database connection via cx_Oracle (python-oracledb)."""
+    """Open an Oracle database connection via python-oracledb."""
     return OracleDatabase(server_name, database_name, user, pw_needed, port, encoding, password=password)
 
 

execsql/db/firebird.py

@@ -12,7 +12,14 @@ 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
+from execsql.utils.auth import (
+    begin_login,
+    clear_stored_password,
+    get_password,
+    is_login_failure,
+    password_from_keyring,
+    remember_password,
+)
 import execsql.state as _state
 
 __all__ = ["FirebirdDatabase"]
@@ -54,7 +61,6 @@ class FirebirdDatabase(Database):
         self.type = dbt_firebird
         self.password = password
         self.encoding = encoding or "latin1"
-        self.encode_commands = True
         self.paramstr = "?"
         self.open_db()
         self.password = None  # Clear cleartext password after successful connection
@@ -100,28 +106,34 @@ class FirebirdDatabase(Database):
 
         if self.conn is None:
             try:
+                begin_login()
                 if self.user and self.need_passwd and not self.password:
                     self.password = get_password(
                         "Firebird",
                         self.db_name,
                         self.user,
                         server_name=self.server_name,
+                        port=self.port,
                     )
                 try:
                     self.conn = db_conn()
-                except Exception:
-                    if not password_from_keyring():
+                except Exception as e:
+                    # Only a rejected password means the stored one is stale;
+                    # a timeout or a missing database leaves it alone.
+                    if not (password_from_keyring() and is_login_failure(e)):
                         raise
-                    clear_stored_password("Firebird", self.db_name, self.user, self.server_name)
+                    clear_stored_password("Firebird", self.db_name, self.user, self.server_name, port=self.port)
                     self.password = get_password(
                         "Firebird",
                         self.db_name,
                         self.user,
                         server_name=self.server_name,
+                        port=self.port,
                         skip_keyring=True,
                         other_msg="(stored credential failed — enter current password)",
                     )
                     self.conn = db_conn()
+                remember_password("Firebird", self.db_name, self.user, self.server_name, port=self.port)
             except SystemExit:
                 # If the user canceled the password prompt.
                 raise
@@ -143,6 +155,9 @@ class FirebirdDatabase(Database):
                 raise
             _state.subvars.add_substitution("$LAST_ROWCOUNT", curs.rowcount)
 
+    # table_exists() without a schema looks only where CREATE TABLE puts a table: one namespace.
+    unqualified_lookup_is_scoped = True
+
     def table_exists(self, table_name: str, schema_name: str | None = None) -> bool:
         """Return True if the named table exists in the Firebird database."""
         sql = (
@@ -243,8 +258,7 @@ class FirebirdDatabase(Database):
         return len(rows) > 0
 
     def drop_table(self, tablename: str) -> None:
-        """Drop the named table from the Firebird database."""
+        """Drop *tablename*, schema-qualified and quoted by the caller."""
         # Firebird will thrown an error if there are foreign keys into the table.
-        tablename = self.type.quoted(tablename)
         self.execute(f"DROP TABLE {tablename};")
         self.conn.commit()