execsql2 2.4.5__py3-none-any.whl → 2.6.0__py3-none-any.whl

execsql/cli/__init__.py

@@ -24,6 +24,20 @@ from execsql.cli.help import _console, _err_console, _print_encodings, _print_me
 from execsql.cli.run import _connect_initial_db, _run  # noqa: F401 — re-export
 from execsql.exceptions import ConfigError, ErrInfo
 
+__all__ = [
+    "_SCHEME_TO_DBTYPE",
+    "_connect_initial_db",
+    "_console",
+    "_err_console",
+    "_legacy_main",
+    "_parse_connection_string",
+    "_print_encodings",
+    "_print_metacommands",
+    "_run",
+    "app",
+    "main",
+]
+
 
 # ---------------------------------------------------------------------------
 # Typer app

execsql/cli/dsn.py

@@ -4,6 +4,8 @@ from __future__ import annotations
 
 from execsql.exceptions import ConfigError
 
+__all__ = ["_SCHEME_TO_DBTYPE", "_parse_connection_string"]
+
 #: Mapping from URL scheme to execsql db_type code.
 _SCHEME_TO_DBTYPE: dict[str, str] = {
     "postgresql": "p",

execsql/cli/help.py

@@ -11,6 +11,8 @@ from encodings.aliases import aliases as codec_dict
 from rich.console import Console
 from rich.table import Table
 
+__all__ = ["_console", "_err_console", "_print_encodings", "_print_metacommands"]
+
 _console = Console()
 _err_console = Console(stderr=True)
 

execsql/cli/run.py

@@ -24,6 +24,8 @@ from execsql.script import SubVarSet, current_script_line, read_sqlfile, read_sq
 from execsql.utils.fileio import FileWriter, Logger, filewriter_end
 from execsql.utils.gui import gui_connect, gui_console_isrunning, gui_console_off, gui_console_on, gui_console_wait_user
 
+__all__ = ["_connect_initial_db", "_print_dry_run", "_run"]
+
 
 # ---------------------------------------------------------------------------
 # Dry-run helper
@@ -92,7 +94,7 @@ def _run(
     # Security note: ALL environment variables are exposed as &-prefixed
     # substitution variables.  Sensitive values (API keys, tokens) in the
     # process environment will be accessible to scripts.  See the
-    # "Environment Variables" section in docs/substitution_vars.md.
+    # "Environment Variables" section in docs/reference/substitution_vars.md.
     for k in os.environ:
         try:
             _state.subvars.add_substitution("&" + k, os.environ[k])
@@ -138,7 +140,7 @@ def _run(
             parsed_dsn = _parse_connection_string(dsn)
         except ConfigError as exc:
             _err_console.print(f"[bold red]Error:[/bold red] {exc}")
-            raise SystemExit(1)
+            raise SystemExit(1) from None
         db_type = db_type or parsed_dsn["db_type"]
         conf.db_type = db_type
         # DSN values override conf-file values — the CLI flag is explicit.

execsql/constants.py

@@ -17,6 +17,17 @@ Contains:
   colour+icon combinations.
 """
 
+__all__ = [
+    "bm_servers",
+    "cancel_xbm",
+    "color_names",
+    "custom_icons",
+    "expand_xbm",
+    "icon_xbm",
+    "wedge_sm_xbm",
+    "wedges_3_xbm",
+]
+
 # Tile servers for map basemap layers
 bm_servers: dict[str, str] = {
     "OpenStreetMap": "https://a.tile.openstreetmap.org/{z}/{x}/{y}.png",

execsql/db/access.py

@@ -88,6 +88,7 @@ class AccessDatabase(Database):
         return f"AccessDatabase({self.db_name}, {self.encoding})"
 
     def open_db(self) -> None:
+        """Open an ODBC connection to the Access database."""
         # Open an ODBC connection.
         import pyodbc
 
@@ -136,6 +137,7 @@ class AccessDatabase(Database):
             )
 
     def open_dao(self) -> None:
+        """Open a DAO connection to the Access database."""
         import win32com.client
 
         if self.dao_conn is not None:
@@ -186,6 +188,7 @@ class AccessDatabase(Database):
             )
 
     def exec_dao(self, querystring: str) -> None:
+        """Execute a query using the DAO connection."""
         # Execute a query using DAO.
         if self.dao_conn is None:
             self.open_dao()
@@ -193,6 +196,7 @@ class AccessDatabase(Database):
         self.last_dao_time = time.time()
 
     def close(self) -> None:
+        """Close both the DAO and ODBC connections."""
         if self.dao_conn:
             for qn in self.temp_query_names:
                 try:
@@ -206,10 +210,13 @@ class AccessDatabase(Database):
             self.conn = None
 
     def dao_flush_check(self) -> None:
+        """Wait if needed for Jet's read buffer to flush after a DAO command."""
         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:
+        """Execute a SQL command, handling encoding, DAO flush, and temporary queries."""
+
         # A shortcut to self.cursor().execute() that handles encoding and that
         # ensures that at least 5 seconds have passed since the last DAO command,
         # to allow Jet's read buffer to be flushed (see https://support.microsoft.com/en-us/kb/225048).
@@ -254,9 +261,11 @@ class AccessDatabase(Database):
             exec1(sqlcmd, paramlist)
 
     def exec_cmd(self, querycommand: str) -> None:
+        """Execute a stored query command via DAO."""
         self.exec_dao(querycommand)
 
     def select_data(self, sql: str) -> tuple[list[str], list]:
+        """Return column names and all rows from a SELECT statement."""
         # Returns the results of the sql select statement.
         # The Access driver returns data as unicode, so no decoding is necessary.
         self.dao_flush_check()
@@ -266,6 +275,7 @@ class AccessDatabase(Database):
         return [d[0] for d in curs.description], rows
 
     def select_rowsource(self, sql: str) -> tuple[list[str], Any]:
+        """Return column names and an iterable that yields rows one at a time."""
         # Return 1) a list of column names, and 2) an iterable that yields rows.
         self.dao_flush_check()
         curs = self.cursor()
@@ -274,6 +284,7 @@ class AccessDatabase(Database):
         return [d[0] for d in curs.description], iter(curs.fetchone, None)
 
     def select_rowdict(self, sql: str) -> tuple[list[str], Any]:
+        """Return column names and an iterable that yields rows as dictionaries."""
         # Return an iterable that yields dictionaries of row data.
         self.dao_flush_check()
         curs = self.cursor()
@@ -295,6 +306,7 @@ class AccessDatabase(Database):
         return headers, iter(dict_row, None)
 
     def table_exists(self, table_name: str, schema_name: str | None = None) -> bool:
+        """Return True if the named table exists in the Access database."""
         self.dao_flush_check()
         curs = self.cursor()
         try:
@@ -318,6 +330,7 @@ class AccessDatabase(Database):
         column_name: str,
         schema_name: str | None = None,
     ) -> bool:
+        """Return True if the named column exists in the given Access table."""
         self.dao_flush_check()
         curs = self.cursor()
         quoted_col = self.quote_identifier(column_name)
@@ -330,6 +343,7 @@ class AccessDatabase(Database):
         return True
 
     def table_columns(self, table_name: str, schema_name: str | None = None) -> list[str]:
+        """Return a list of column names for the given Access table."""
         self.dao_flush_check()
         curs = self.cursor()
         quoted_tbl = self.quote_identifier(table_name)
@@ -337,6 +351,7 @@ class AccessDatabase(Database):
         return [d[0] for d in curs.description]
 
     def view_exists(self, view_name: str, schema_name: str | None = None) -> bool:
+        """Return True if the named view or query exists in the Access database."""
         self.dao_flush_check()
         curs = self.cursor()
         try:
@@ -355,14 +370,17 @@ class AccessDatabase(Database):
         return len(rows) > 0
 
     def schema_exists(self, schema_name: str) -> bool:
+        """Return False; Access does not support schemas."""
         return False
 
     def drop_table(self, tablename: str) -> None:
+        """Drop the named table from the Access database."""
         self.dao_flush_check()
         tablename = self.type.quoted(tablename)
         self.execute(f"drop table {tablename};")
 
     def as_datetime(self, val: Any) -> datetime.datetime | None:
+        """Convert a value to a datetime object suitable for Access."""
         from execsql.types import DT_Timestamp, DT_Date, DT_Time, DataTypeError
 
         if val is None or (isinstance(val, _state.stringtypes) and len(val) == 0):
@@ -393,6 +411,7 @@ class AccessDatabase(Database):
             return v
 
     def int_or_bool(self, val: Any) -> int | None:
+        """Convert a value to an integer, recognizing Access boolean values."""
         # Because Booleans are stored as integers in Access (at least, if execsql
         # creates the table), we have to recognize Boolean values as legitimate
         # integers.
@@ -420,6 +439,7 @@ class AccessDatabase(Database):
         column_name: str,
         file_name: str,
     ) -> None:
+        """Import an entire binary file into a single column of a table."""
         import pyodbc
 
         with open(file_name, "rb") as f:

execsql/db/base.py

@@ -70,6 +70,7 @@ class Database(ABC):
         port: int | None = None,
         encoding: str | None = None,
     ) -> None:
+        """Initialize common connection attributes for a database backend."""
         self.type = None
         self.server_name = server_name
         self.db_name = db_name
@@ -84,6 +85,7 @@ class Database(ABC):
         self.autocommit = True
 
     def __repr__(self) -> str:
+        """Return a developer-friendly string representation of this connection."""
         return (
             f"Database({self.server_name!r}, {self.db_name!r}, {self.user!r}, "
             f"{self.need_passwd!r}, {self.port!r}, {self.encoding!r})"
@@ -637,12 +639,14 @@ class DatabasePool:
     and with the current and initial databases identified."""
 
     def __init__(self) -> None:
+        """Initialize an empty connection pool with no active database."""
         self.pool: dict[str, Database] = {}
         self.initial_db: str | None = None
         self.current_db: str | None = None
         self.do_rollback: bool = True
 
     def __repr__(self) -> str:
+        """Return a string representation of the pool."""
         return "DatabasePool()"
 
     def add(self, db_alias: str, db_obj: Database) -> None:

execsql/db/dsn.py

@@ -59,6 +59,7 @@ class DsnDatabase(Database):
         return f"DsnDatabase({self.db_name!r}, {self.user!r}, {self.need_passwd!r}, {self.port!r}, {self.encoding!r})"
 
     def open_db(self) -> None:
+        """Open an ODBC connection using the configured DSN."""
         # Open an ODBC connection using a DSN.
         import pyodbc
 
@@ -118,15 +119,16 @@ class DsnDatabase(Database):
             _try_connect()
 
     def exec_cmd(self, querycommand: str) -> None:
+        """Execute a stored procedure by name."""
         # The querycommand must be a stored procedure
-        curs = self.cursor()
-        cmd = f"execute {querycommand};"
-        try:
-            curs.execute(cmd.encode(self.encoding))
-            _state.subvars.add_substitution("$LAST_ROWCOUNT", curs.rowcount)
-        except Exception:
-            self.rollback()
-            raise
+        with self._cursor() as curs:
+            cmd = f"execute {querycommand};"
+            try:
+                curs.execute(cmd.encode(self.encoding))
+                _state.subvars.add_substitution("$LAST_ROWCOUNT", curs.rowcount)
+            except Exception:
+                self.rollback()
+                raise
 
     def import_entire_file(
         self,
@@ -135,6 +137,7 @@ class DsnDatabase(Database):
         column_name: str,
         file_name: str,
     ) -> None:
+        """Import an entire binary file into a single column of a table."""
         import pyodbc
 
         with open(file_name, "rb") as f:

execsql/db/duckdb.py

@@ -45,6 +45,7 @@ class DuckDBDatabase(Database):
         return f"DuckDBDatabase({self.db_name!r})"
 
     def open_db(self) -> None:
+        """Open a connection to the DuckDB database file."""
         import duckdb
 
         if self.conn is None:
@@ -60,22 +61,25 @@ class DuckDBDatabase(Database):
                 ) from e
 
     def exec_cmd(self, querycommand: str) -> None:
+        """Execute a query command as a view selection, since DuckDB lacks stored procedures."""
         # DuckDB does not support stored functions, so the querycommand
         # is treated as (and therefore must be) a view.
-        curs = self.cursor()
-        cmd = f"select * from {querycommand};"
-        try:
-            curs.execute(cmd.encode(self.encoding))
-            _state.subvars.add_substitution("$LAST_ROWCOUNT", curs.rowcount)
-        except Exception:
-            self.rollback()
-            raise
+        with self._cursor() as curs:
+            cmd = f"select * from {querycommand};"
+            try:
+                curs.execute(cmd.encode(self.encoding))
+                _state.subvars.add_substitution("$LAST_ROWCOUNT", curs.rowcount)
+            except Exception:
+                self.rollback()
+                raise
 
     def view_exists(self, view_name: str) -> bool:
+        """Return True if the named view exists in the DuckDB database."""
         # DuckDB information_schema has no 'views' table; views are listed in 'tables'
         return self.table_exists(view_name)
 
     def schema_exists(self, schema_name: str) -> bool:
+        """Return True if the named schema exists in the current DuckDB catalog."""
         # In DuckDB, the 'schemata' view is not limited to the current database.
         curs = self.cursor()
         curs.execute(

execsql/db/firebird.py

@@ -59,6 +59,7 @@ class FirebirdDatabase(Database):
         )
 
     def open_db(self) -> None:
+        """Open a connection to the Firebird database."""
         import fdb as firebird_lib
 
         def db_conn():
@@ -113,17 +114,19 @@ class FirebirdDatabase(Database):
                 raise ErrInfo(type="exception", exception_msg=exception_desc(), other_msg=msg) from e
 
     def exec_cmd(self, querycommand: str) -> None:
+        """Execute a stored procedure by name."""
         # The querycommand must be a stored function (/procedure)
-        curs = self.cursor()
-        cmd = f"execute procedure {querycommand};"
-        try:
-            curs.execute(cmd)
-        except Exception:
-            self.rollback()
-            raise
-        _state.subvars.add_substitution("$LAST_ROWCOUNT", curs.rowcount)
+        with self._cursor() as curs:
+            cmd = f"execute procedure {querycommand};"
+            try:
+                curs.execute(cmd)
+            except Exception:
+                self.rollback()
+                raise
+            _state.subvars.add_substitution("$LAST_ROWCOUNT", curs.rowcount)
 
     def table_exists(self, table_name: str, schema_name: str | None = None) -> bool:
+        """Return True if the named table exists in the Firebird database."""
         curs = self.cursor()
         sql = (
             "SELECT RDB$RELATION_NAME FROM RDB$RELATIONS "
@@ -156,6 +159,7 @@ class FirebirdDatabase(Database):
         column_name: str,
         schema_name: str | None = None,
     ) -> bool:
+        """Return True if the named column exists in the given Firebird table."""
         curs = self.cursor()
         quoted_col = self.quote_identifier(column_name)
         quoted_tbl = self.quote_identifier(table_name)
@@ -167,6 +171,7 @@ class FirebirdDatabase(Database):
         return True
 
     def table_columns(self, table_name: str, schema_name: str | None = None) -> list[str]:
+        """Return a list of column names for the given Firebird table."""
         curs = self.cursor()
         quoted_tbl = self.quote_identifier(table_name)
         sql = f"select first 1 * from {quoted_tbl};"
@@ -185,6 +190,7 @@ class FirebirdDatabase(Database):
         return [d[0] for d in curs.description]
 
     def view_exists(self, view_name: str, schema_name: str | None = None) -> bool:
+        """Return True if the named view exists in the Firebird database."""
         curs = self.cursor()
         sql = "select distinct rdb$view_name from rdb$view_relations where rdb$view_name = ?;"
         try:
@@ -204,9 +210,11 @@ class FirebirdDatabase(Database):
         return len(rows) > 0
 
     def schema_exists(self, schema_name: str) -> bool:
+        """Return False; Firebird does not support schemas."""
         return False
 
     def role_exists(self, rolename: str) -> bool:
+        """Return True if the named role or user exists in the Firebird database."""
         curs = self.cursor()
         curs.execute(
             "SELECT DISTINCT USER FROM RDB$USER_PRIVILEGES WHERE USER = ? union "
@@ -218,6 +226,7 @@ class FirebirdDatabase(Database):
         return len(rows) > 0
 
     def drop_table(self, tablename: str) -> None:
+        """Drop the named table from the Firebird database."""
         # Firebird will thrown an error if there are foreign keys into the table.
         tablename = self.type.quoted(tablename)
         self.execute(f"DROP TABLE {tablename};")

execsql/db/mysql.py

@@ -73,6 +73,7 @@ class MySQLDatabase(Database):
         )
 
     def open_db(self) -> None:
+        """Open a connection to the MySQL or MariaDB server."""
         import pymysql as mysql_lib
 
         def db_conn():
@@ -130,20 +131,23 @@ class MySQLDatabase(Database):
                 raise ErrInfo(type="exception", exception_msg=exception_desc(), other_msg=msg) from e
 
     def exec_cmd(self, querycommand: str) -> None:
+        """Execute a stored procedure by name."""
         # The querycommand must be a stored function (/procedure)
-        curs = self.cursor()
-        cmd = f"call {querycommand}();"
-        try:
-            curs.execute(cmd)
-            _state.subvars.add_substitution("$LAST_ROWCOUNT", curs.rowcount)
-        except Exception:
-            self.rollback()
-            raise
+        with self._cursor() as curs:
+            cmd = f"call {querycommand}();"
+            try:
+                curs.execute(cmd)
+                _state.subvars.add_substitution("$LAST_ROWCOUNT", curs.rowcount)
+            except Exception:
+                self.rollback()
+                raise
 
     def schema_exists(self, schema_name: str) -> bool:
+        """Return False; MySQL does not support schemas in the execsql sense."""
         return False
 
     def role_exists(self, rolename: str) -> bool:
+        """Return True if the named role or user exists in the MySQL server."""
         curs = self.cursor()
         curs.execute(
             "select distinct user as role from mysql.user where user = %s"
@@ -162,6 +166,7 @@ class MySQLDatabase(Database):
         csv_file_obj: Any,
         skipheader: bool,
     ) -> None:
+        """Import a delimited file into a MySQL table."""
         # Import a file to a table.  Columns must be compatible.
         sq_name = self.schema_qualified_table_name(schema_name, table_name)
         if not self.table_exists(table_name, schema_name):

execsql/db/oracle.py

@@ -61,6 +61,7 @@ class OracleDatabase(Database):
         )
 
     def open_db(self) -> None:
+        """Open a connection to the Oracle database."""
         import cx_Oracle
 
         def db_conn(db: OracleDatabase, db_name: str):
@@ -104,6 +105,7 @@ class OracleDatabase(Database):
                 raise ErrInfo(type="exception", exception_msg=exception_desc(), other_msg=msg) from e
 
     def execute(self, sql: Any, paramlist: list | None = None) -> None:
+        """Execute a SQL command, stripping any trailing semicolon for Oracle."""
         # Strip any semicolon off the end and pass to the parent method.
         if sql[-1:] == ";":
             super().execute(sql[:-1], paramlist)
@@ -111,29 +113,34 @@ class OracleDatabase(Database):
             super().execute(sql, paramlist)
 
     def select_data(self, sql: str) -> tuple[list[str], list]:
+        """Return column names and all rows from a SELECT statement."""
         if sql[-1:] == ";":
             return super().select_data(sql[:-1])
         else:
             return super().select_data(sql)
 
     def select_rowsource(self, sql: str) -> Any:
+        """Return column names and an iterable that yields rows one at a time."""
         if sql[-1:] == ";":
             return super().select_rowsource(sql[:-1])
         else:
             return super().select_rowsource(sql)
 
     def select_rowdict(self, sql: str) -> Any:
+        """Return column names and an iterable that yields rows as dictionaries."""
         if sql[-1:] == ";":
             return super().select_rowdict(sql[:-1])
         else:
             return super().select_rowdict(sql)
 
     def schema_exists(self, schema_name: str) -> bool:
+        """Raise DatabaseNotImplementedError; schema_exists is not supported for Oracle."""
         from execsql.exceptions import DatabaseNotImplementedError
 
         raise DatabaseNotImplementedError(self.name(), "schema_exists")
 
     def table_exists(self, table_name: str, schema_name: str | None = None) -> bool:
+        """Return True if the named table exists in the Oracle database."""
         curs = self.cursor()
         params = {"tname": table_name}
         owner_clause = ""
@@ -163,6 +170,7 @@ class OracleDatabase(Database):
         column_name: str,
         schema_name: str | None = None,
     ) -> bool:
+        """Return True if the named column exists in the given Oracle table."""
         curs = self.cursor()
         params = {"tname": table_name, "cname": column_name}
         owner_clause = ""
@@ -187,6 +195,7 @@ class OracleDatabase(Database):
         return len(rows) > 0
 
     def table_columns(self, table_name: str, schema_name: str | None = None) -> list[str]:
+        """Return a list of column names for the given Oracle table."""
         curs = self.cursor()
         params = {"tname": table_name}
         owner_clause = ""
@@ -211,6 +220,7 @@ class OracleDatabase(Database):
         return [row[0] for row in rows]
 
     def view_exists(self, view_name: str, schema_name: str | None = None) -> bool:
+        """Return True if the named view exists in the Oracle database."""
         curs = self.cursor()
         params = {"vname": view_name}
         owner_clause = ""
@@ -235,6 +245,7 @@ class OracleDatabase(Database):
         return len(rows) > 0
 
     def role_exists(self, rolename: str) -> bool:
+        """Return True if the named role or user exists in the Oracle database."""
         curs = self.cursor()
         curs.execute(
             "select role from dba_roles where role = :rname union "
@@ -246,19 +257,22 @@ class OracleDatabase(Database):
         return len(rows) > 0
 
     def drop_table(self, tablename: str) -> None:
+        """Drop the named table with cascade constraints."""
         tablename = self.type.quoted(tablename)
         self.execute(f"drop table {tablename} cascade constraints")
 
     def paramsubs(self, paramcount: int) -> str:
+        """Return Oracle-style positional parameter placeholders (:1, :2, ...)."""
         return ",".join(":" + str(d) for d in range(1, paramcount + 1))
 
     def exec_cmd(self, querycommand: str) -> None:
+        """Execute a stored function by name."""
         # The querycommand must be a stored function (/procedure)
-        curs = self.cursor()
-        cmd = f"select {querycommand}()"
-        try:
-            curs.execute(cmd)
-            _state.subvars.add_substitution("$LAST_ROWCOUNT", curs.rowcount)
-        except Exception:
-            self.rollback()
-            raise
+        with self._cursor() as curs:
+            cmd = f"select {querycommand}()"
+            try:
+                curs.execute(cmd)
+                _state.subvars.add_substitution("$LAST_ROWCOUNT", curs.rowcount)
+            except Exception:
+                self.rollback()
+                raise

execsql/db/postgres.py

@@ -70,6 +70,7 @@ class PostgresDatabase(Database):
         )
 
     def open_db(self) -> None:
+        """Open a connection to the PostgreSQL database."""
         import psycopg2
 
         def db_conn(db: PostgresDatabase, db_name: str):
@@ -145,17 +146,19 @@ class PostgresDatabase(Database):
             self.encoding = self.conn.encoding
 
     def exec_cmd(self, querycommand: str) -> None:
+        """Execute a stored function by name."""
         # The querycommand must be a stored function (/procedure)
-        curs = self.cursor()
-        cmd = f"select {querycommand}()"
-        try:
-            curs.execute(cmd)
-            _state.subvars.add_substitution("$LAST_ROWCOUNT", curs.rowcount)
-        except Exception:
-            self.rollback()
-            raise
+        with self._cursor() as curs:
+            cmd = f"select {querycommand}()"
+            try:
+                curs.execute(cmd)
+                _state.subvars.add_substitution("$LAST_ROWCOUNT", curs.rowcount)
+            except Exception:
+                self.rollback()
+                raise
 
     def role_exists(self, rolename: str) -> bool:
+        """Return True if the named role exists in the PostgreSQL cluster."""
         curs = self.cursor()
         curs.execute("select rolname from pg_roles where rolname = %s;", (rolename,))
         rows = curs.fetchall()
@@ -163,6 +166,7 @@ class PostgresDatabase(Database):
         return len(rows) > 0
 
     def table_exists(self, table_name: str, schema_name: str | None = None) -> bool:
+        """Return True if the named table exists in the PostgreSQL database."""
         curs = self.cursor()
         if schema_name is not None:
             params: list = [table_name]
@@ -195,6 +199,7 @@ class PostgresDatabase(Database):
         return len(rows) > 0
 
     def view_exists(self, view_name: str, schema_name: str | None = None) -> bool:
+        """Return True if the named view exists in the PostgreSQL database."""
         curs = self.cursor()
         if schema_name is not None:
             params: list = [view_name]
@@ -227,9 +232,14 @@ class PostgresDatabase(Database):
         return len(rows) > 0
 
     def vacuum(self, argstring: str) -> None:
+        """Run VACUUM with the given arguments in autocommit mode."""
         self.commit()
         self.conn.set_session(autocommit=True)
-        self.conn.cursor().execute(f"VACUUM {argstring};")
+        curs = self.conn.cursor()
+        try:
+            curs.execute(f"VACUUM {argstring};")
+        finally:
+            curs.close()
         self.conn.set_session(autocommit=False)
 
     def import_tabular_file(
@@ -239,6 +249,7 @@ class PostgresDatabase(Database):
         csv_file_obj: Any,
         skipheader: bool,
     ) -> None:
+        """Import a delimited file into a PostgreSQL table, using COPY when possible."""
         # Import a file to a table.  Columns must be compatible.
         sq_name = self.schema_qualified_table_name(schema_name, table_name)
         if not self.table_exists(table_name, schema_name):
@@ -440,6 +451,7 @@ class PostgresDatabase(Database):
         column_name: str,
         file_name: str,
     ) -> None:
+        """Import an entire binary file into a single column of a table."""
         import psycopg2
 
         with open(file_name, "rb") as f: