execsql2 2.0.1__py3-none-any.whl → 2.1.2__py3-none-any.whl

execsql/db/base.py

@@ -14,11 +14,9 @@ open :class:`Database` instances and tracks which connection is currently
 active.  It is the canonical ``_state.dbs`` object.
 """
 
-import datetime
-import io
 import re
-from decimal import Decimal
-from typing import Any, Callable, Dict, Generator, Iterator, List, Optional, Tuple
+from typing import Any
+from collections.abc import Callable, Generator, Iterator
 
 from execsql.exceptions import ErrInfo
 from execsql.utils.errors import exception_desc
@@ -28,23 +26,23 @@ import execsql.state as _state
 class Database:
     """Abstract base class for all database connections."""
 
-    dt_cast: Dict[type, Callable] = {}  # populated per-subclass or in __init__
+    dt_cast: dict[type, Callable] = {}  # populated per-subclass or in __init__
 
     def __init__(
         self,
-        server_name: Optional[str],
-        db_name: Optional[str],
-        user_name: Optional[str] = None,
-        need_passwd: Optional[bool] = None,
-        port: Optional[int] = None,
-        encoding: Optional[str] = None,
+        server_name: str | None,
+        db_name: str | None,
+        user_name: str | None = None,
+        need_passwd: bool | None = None,
+        port: int | None = None,
+        encoding: str | None = None,
     ) -> None:
         self.type = None
         self.server_name = server_name
         self.db_name = db_name
         self.user = user_name
         self.need_passwd = need_passwd
-        self.password: Optional[str] = None
+        self.password: str | None = None
         self.port = port
         self.encoding = encoding
         self.encode_commands = True
@@ -83,10 +81,15 @@ class Database:
             self.conn.close()
             self.conn = None
 
+    def quote_identifier(self, identifier: str) -> str:
+        """Return *identifier* wrapped in double-quotes with any embedded
+        double-quotes escaped (standard SQL identifier quoting)."""
+        return '"' + identifier.replace('"', '""') + '"'
+
     def paramsubs(self, paramcount: int) -> str:
         return ",".join((self.paramstr,) * paramcount)
 
-    def execute(self, sql: Any, paramlist: Optional[list] = None) -> None:
+    def execute(self, sql: Any, paramlist: list | None = None) -> None:
         # A shortcut to self.cursor().execute() that handles encoding.
         # Whether or not encoding is needed depends on the DBMS.
         if type(sql) in (tuple, list):
@@ -98,16 +101,16 @@ class Database:
             else:
                 curs.execute(sql, paramlist)
             try:
-                # DuckDB does not support the 'rowcount' attribute
+                # DuckDB does not support the 'rowcount' attribute.
                 _state.subvars.add_substitution("$LAST_ROWCOUNT", curs.rowcount)
             except Exception:
-                pass
-        except Exception as e:
+                pass  # Non-critical: some drivers lack rowcount support.
+        except Exception:
             try:
                 self.rollback()
             except Exception:
-                pass
-            raise e
+                pass  # Rollback is best-effort after a failed execute.
+            raise
 
     def exec_cmd(self, querycommand: str) -> None:
         from execsql.exceptions import DatabaseNotImplementedError
@@ -129,16 +132,16 @@ class Database:
             try:
                 self.conn.rollback()
             except Exception:
-                pass
+                pass  # Best-effort; connection may already be closed.
 
-    def schema_qualified_table_name(self, schema_name: Optional[str], table_name: str) -> str:
+    def schema_qualified_table_name(self, schema_name: str | None, table_name: str) -> str:
         table_name = self.type.quoted(table_name)
         if schema_name:
             schema_name = self.type.quoted(schema_name)
             return f"{schema_name}.{table_name}"
         return table_name
 
-    def select_data(self, sql: str) -> Tuple[List[str], list]:
+    def select_data(self, sql: str) -> tuple[list[str], list]:
         # Returns the results of the sql select statement.
         curs = self.cursor()
         try:
@@ -149,18 +152,18 @@ class Database:
         try:
             _state.subvars.add_substitution("$LAST_ROWCOUNT", curs.rowcount)
         except Exception:
-            pass
+            pass  # Non-critical: some drivers lack rowcount support.
         rows = curs.fetchall()
         return [d[0] for d in curs.description], rows
 
-    def select_rowsource(self, sql: str) -> Tuple[List[str], Generator]:
+    def select_rowsource(self, sql: str) -> tuple[list[str], Generator]:
         # Return 1) a list of column names, and 2) an iterable that yields rows.
         curs = self.cursor()
         try:
-            # DuckDB cursors have no 'arraysize' attribute
+            # DuckDB cursors have no 'arraysize' attribute.
             curs.arraysize = _state.conf.export_row_buffer
         except Exception:
-            pass
+            pass  # Non-critical: not all drivers support arraysize.
         try:
             curs.execute(sql)
         except Exception:
@@ -169,7 +172,7 @@ class Database:
         try:
             _state.subvars.add_substitution("$LAST_ROWCOUNT", curs.rowcount)
         except Exception:
-            pass
+            pass  # Non-critical: some drivers lack rowcount support.
 
         def decode_row() -> Generator:
             while True:
@@ -180,14 +183,14 @@ class Database:
                     for row in rows:
                         if self.encoding:
                             yield [
-                                c.decode(self.encoding, "backslashreplace") if type(c) == type(b"") else c for c in row
+                                c.decode(self.encoding, "backslashreplace") if isinstance(c, bytes) else c for c in row
                             ]
                         else:
                             yield row
 
         return [d[0] for d in curs.description], decode_row()
 
-    def select_rowdict(self, sql: str) -> Tuple[List[str], Iterator]:
+    def select_rowdict(self, sql: str) -> tuple[list[str], Iterator]:
         # Return an iterable that yields dictionaries of row data
         curs = self.cursor()
         try:
@@ -198,14 +201,14 @@ class Database:
         try:
             _state.subvars.add_substitution("$LAST_ROWCOUNT", curs.rowcount)
         except Exception:
-            pass
+            pass  # Non-critical: some drivers lack rowcount support.
         hdrs = [d[0] for d in curs.description]
 
-        def dict_row() -> Optional[dict]:
+        def dict_row() -> dict | None:
             row = curs.fetchone()
             if row:
                 if self.encoding:
-                    r = [c.decode(self.encoding, "backslashreplace") if type(c) == type(b"") else c for c in row]
+                    r = [c.decode(self.encoding, "backslashreplace") if isinstance(c, bytes) else c for c in row]
                 else:
                     r = row
                 return dict(zip(hdrs, r))
@@ -216,19 +219,22 @@ class Database:
 
     def schema_exists(self, schema_name: str) -> bool:
         curs = self.cursor()
-        curs.execute(
-            f"SELECT schema_name FROM information_schema.schemata WHERE schema_name = '{schema_name}';",
-        )
+        sql = f"SELECT schema_name FROM information_schema.schemata WHERE schema_name = {self.paramstr};"
+        curs.execute(sql, (schema_name,))
         rows = curs.fetchall()
         curs.close()
         return len(rows) > 0
 
-    def table_exists(self, table_name: str, schema_name: Optional[str] = None) -> bool:
+    def table_exists(self, table_name: str, schema_name: str | None = None) -> bool:
         curs = self.cursor()
-        schema_clause = "" if not schema_name else f" and table_schema='{schema_name}'"
-        sql = f"select table_name from information_schema.tables where table_name = '{table_name}'{schema_clause};"
+        params: list = [table_name]
+        schema_clause = ""
+        if schema_name:
+            schema_clause = f" and table_schema={self.paramstr}"
+            params.append(schema_name)
+        sql = f"select table_name from information_schema.tables where table_name = {self.paramstr}{schema_clause};"
         try:
-            curs.execute(sql)
+            curs.execute(sql, params)
         except ErrInfo:
             raise
         except Exception:
@@ -247,17 +253,22 @@ class Database:
         self,
         table_name: str,
         column_name: str,
-        schema_name: Optional[str] = None,
+        schema_name: str | None = None,
     ) -> bool:
         curs = self.cursor()
-        schema_clause = "" if not schema_name else f" and table_schema='{schema_name}'"
+        params: list = [table_name]
+        schema_clause = ""
+        if schema_name:
+            schema_clause = f" and table_schema={self.paramstr}"
+            params.append(schema_name)
+        params.append(column_name)
         sql = (
             f"select column_name from information_schema.columns "
-            f"where table_name='{table_name}'{schema_clause} "
-            f"and column_name='{column_name}';"
+            f"where table_name={self.paramstr}{schema_clause} "
+            f"and column_name={self.paramstr};"
         )
         try:
-            curs.execute(sql)
+            curs.execute(sql, params)
         except ErrInfo:
             raise
         except Exception:
@@ -272,16 +283,20 @@ class Database:
         curs.close()
         return len(rows) > 0
 
-    def table_columns(self, table_name: str, schema_name: Optional[str] = None) -> List[str]:
+    def table_columns(self, table_name: str, schema_name: str | None = None) -> list[str]:
         curs = self.cursor()
-        schema_clause = "" if not schema_name else f" and table_schema='{schema_name}'"
+        params: list = [table_name]
+        schema_clause = ""
+        if schema_name:
+            schema_clause = f" and table_schema={self.paramstr}"
+            params.append(schema_name)
         sql = (
             f"select column_name from information_schema.columns "
-            f"where table_name='{table_name}'{schema_clause} "
+            f"where table_name={self.paramstr}{schema_clause} "
             f"order by ordinal_position;"
         )
         try:
-            curs.execute(sql)
+            curs.execute(sql, params)
         except ErrInfo:
             raise
         except Exception:
@@ -296,12 +311,16 @@ class Database:
         curs.close()
         return [row[0] for row in rows]
 
-    def view_exists(self, view_name: str, schema_name: Optional[str] = None) -> bool:
+    def view_exists(self, view_name: str, schema_name: str | None = None) -> bool:
         curs = self.cursor()
-        schema_clause = "" if not schema_name else f" and table_schema='{schema_name}'"
-        sql = f"select table_name from information_schema.views where table_name = '{view_name}'{schema_clause};"
+        params: list = [view_name]
+        schema_clause = ""
+        if schema_name:
+            schema_clause = f" and table_schema={self.paramstr}"
+            params.append(schema_name)
+        sql = f"select table_name from information_schema.views where table_name = {self.paramstr}{schema_clause};"
         try:
-            curs.execute(sql)
+            curs.execute(sql, params)
         except ErrInfo:
             raise
         except Exception:
@@ -328,10 +347,10 @@ class Database:
 
     def populate_table(
         self,
-        schema_name: Optional[str],
+        schema_name: str | None,
         table_name: str,
         rowsource: Any,
-        column_list: List[str],
+        column_list: list[str],
         tablespec_src: Callable,
     ) -> None:
         # The rowsource argument must be a generator yielding a list of values for the columns of the table.
@@ -362,9 +381,10 @@ class Database:
         rows = iter(rowsource)
         curs = self.cursor()
         eof = False
+        total_rows = 0
         while True:
             b = []
-            for j in range(_state.conf.import_row_buffer):
+            for _j in range(_state.conf.import_row_buffer):
                 try:
                     line = next(rows)
                 except StopIteration:
@@ -409,20 +429,19 @@ class Database:
                                             " ",
                                             line[i],
                                         )
-                                    if not _state.conf.empty_strings:
-                                        if line[i].strip() == "":
-                                            line[i] = None
+                                    if not _state.conf.empty_strings and line[i].strip() == "":
+                                        line[i] = None
                         lt = [type_objs[i].from_data(val) if val is not None else None for i, val in enumerate(line)]
                         lt = [type_mod_fn[i](v) if type_mod_fn[i] else v for i, v in enumerate(lt)]
-                        l = []
+                        row = []
                         for i, v in enumerate(lt):
                             if incl_col[i]:
-                                l.append(v)
+                                row.append(v)
                         add_line = True
                         if not _state.conf.empty_rows:
-                            add_line = not all([c is None for c in l])
+                            add_line = not all(c is None for c in row)
                         if add_line:
-                            b.append(l)
+                            b.append(row)
             if len(b) > 0:
                 try:
                     curs.executemany(sql, b)
@@ -436,12 +455,22 @@ class Database:
                         exception_msg=exception_desc(),
                         other_msg=f"Can't load data into table {sq_name} of {self.name()} from line {{{line}}}",
                     )
+                total_rows += len(b)
+                interval = _state.conf.import_progress_interval
+                if _state.exec_log and interval > 0 and total_rows % interval == 0:
+                    _state.exec_log.log_status_info(
+                        f"IMPORT into {sq_name}: {total_rows} rows imported so far.",
+                    )
             if eof:
                 break
+        if _state.exec_log:
+            _state.exec_log.log_status_info(
+                f"IMPORT into {sq_name} complete: {total_rows} rows imported.",
+            )
 
     def import_tabular_file(
         self,
-        schema_name: Optional[str],
+        schema_name: str | None,
         table_name: str,
         csv_file_obj: Any,
         skipheader: bool,
@@ -483,12 +512,12 @@ class Database:
 
     def import_entire_file(
         self,
-        schema_name: Optional[str],
+        schema_name: str | None,
         table_name: str,
         column_name: str,
         file_name: str,
     ) -> None:
-        with io.open(file_name, "rb") as f:
+        with open(file_name, "rb") as f:
             filedata = f.read()
         sq_name = self.schema_qualified_table_name(schema_name, table_name)
         sql = f"insert into {sq_name} ({column_name}) values ({self.paramsubs(1)});"
@@ -500,9 +529,9 @@ class DatabasePool:
     and with the current and initial databases identified."""
 
     def __init__(self) -> None:
-        self.pool: Dict[str, Database] = {}
-        self.initial_db: Optional[str] = None
-        self.current_db: Optional[str] = None
+        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:
@@ -531,7 +560,7 @@ class DatabasePool:
             self.pool[db_alias].close()
         self.pool[db_alias] = db_obj
 
-    def aliases(self) -> List[str]:
+    def aliases(self) -> list[str]:
         # Return a list of the currently defined aliases
         return list(self.pool)
 

execsql/db/dsn.py

@@ -8,13 +8,11 @@ registered as an ODBC DSN via ``pyodbc``.  Corresponds to ``-t d`` on
 the CLI.
 """
 
-import io
-from typing import Optional
 
 from execsql.db.base import Database
 from execsql.exceptions import ErrInfo
 from execsql.utils.errors import exception_desc, fatal_error
-from execsql.utils.auth import get_password
+from execsql.utils.auth import clear_stored_password, get_password, password_from_keyring
 import execsql.state as _state
 
 
@@ -28,10 +26,10 @@ class DsnDatabase(Database):
     def __init__(
         self,
         dsn_name: str,
-        user_name: Optional[str],
+        user_name: str | None,
         need_passwd: bool = False,
-        encoding: Optional[str] = None,
-        password: Optional[str] = None,
+        encoding: str | None = None,
+        password: str | None = None,
     ) -> None:
         try:
             import pyodbc  # noqa: F401
@@ -65,37 +63,55 @@ class DsnDatabase(Database):
             self.conn = None
         if self.need_passwd and self.user and self.password is None:
             self.password = get_password("DSN", self.db_name, self.user)
-        cs = "DSN=%s;"
-        try:
+
+        def _dsn_connect(autocommit: bool = False):
+            cs = "DSN=%s;"
             if self.need_passwd:
+                kwargs = {"autocommit": autocommit} if autocommit else {}
                 self.conn = pyodbc.connect(
                     f"{cs % self.db_name} Uid={self.user}; Pwd={self.password};",
+                    **kwargs,
                 )
             else:
-                self.conn = pyodbc.connect(cs % self.db_name)
-        except Exception:
-            excdesc = exception_desc()
-            if "Optional feature not implemented" in excdesc:
-                try:
-                    if self.need_passwd:
-                        self.conn = pyodbc.connect(
-                            f"{cs % self.db_name} Uid={self.user}; Pwd={self.password};",
-                            autocommit=True,
+                kwargs = {"autocommit": autocommit} if autocommit else {}
+                self.conn = pyodbc.connect(cs % self.db_name, **kwargs)
+
+        def _try_connect():
+            try:
+                _dsn_connect()
+            except Exception:
+                excdesc = exception_desc()
+                if "Optional feature not implemented" in excdesc:
+                    try:
+                        _dsn_connect(autocommit=True)
+                    except Exception:
+                        raise ErrInfo(
+                            type="exception",
+                            exception_msg=exception_desc(),
+                            other_msg=f"Can't open DSN database {self.db_name} using ODBC",
                         )
-                    else:
-                        self.conn = pyodbc.connect(cs % self.db_name, autocommit=True)
-                except Exception:
+                else:
                     raise ErrInfo(
                         type="exception",
-                        exception_msg=exception_desc(),
+                        exception_msg=excdesc,
                         other_msg=f"Can't open DSN database {self.db_name} using ODBC",
                     )
-            else:
-                raise ErrInfo(
-                    type="exception",
-                    exception_msg=excdesc,
-                    other_msg=f"Can't open DSN database {self.db_name} using ODBC",
-                )
+
+        try:
+            _try_connect()
+        except ErrInfo:
+            if not password_from_keyring():
+                raise
+            clear_stored_password("DSN", self.db_name, self.user)
+            self.password = get_password(
+                "DSN",
+                self.db_name,
+                self.user,
+                skip_keyring=True,
+                other_msg="(stored credential failed — enter current password)",
+            )
+            self.conn = None
+            _try_connect()
 
     def exec_cmd(self, querycommand: str) -> None:
         # The querycommand must be a stored procedure
@@ -110,14 +126,14 @@ class DsnDatabase(Database):
 
     def import_entire_file(
         self,
-        schema_name: Optional[str],
+        schema_name: str | None,
         table_name: str,
         column_name: str,
         file_name: str,
     ) -> None:
         import pyodbc
 
-        with io.open(file_name, "rb") as f:
+        with open(file_name, "rb") as f:
             filedata = f.read()
         sq_name = self.schema_qualified_table_name(schema_name, table_name)
         sql = f"insert into {sq_name} ({column_name}) values ({self.paramsubs(1)});"

execsql/db/duckdb.py

@@ -8,8 +8,7 @@ analytics databases via the ``duckdb`` package.  Corresponds to ``-t k``
 on the CLI.
 """
 
-import os
-from typing import Optional
+from pathlib import Path
 
 from execsql.db.base import Database
 from execsql.exceptions import ErrInfo
@@ -28,7 +27,7 @@ class DuckDBDatabase(Database):
         self.type = dbt_duckdb
         self.server_name = None
         self.db_name = DuckDB_fn
-        self.catalog_name = os.path.splitext(DuckDB_fn)[0]
+        self.catalog_name = Path(DuckDB_fn).stem
         self.user = None
         self.need_passwd = False
         self.encoding = "UTF-8"
@@ -76,8 +75,8 @@ class DuckDBDatabase(Database):
         # In DuckDB, the 'schemata' view is not limited to the current database.
         curs = self.cursor()
         curs.execute(
-            f"SELECT schema_name FROM information_schema.schemata "
-            f"WHERE schema_name = '{schema_name}' and catalog_name = '{self.catalog_name}';",
+            "SELECT schema_name FROM information_schema.schemata WHERE schema_name = ? and catalog_name = ?;",
+            (schema_name, self.catalog_name),
         )
         rows = curs.fetchall()
         curs.close()

execsql/db/factory.py

@@ -12,8 +12,7 @@ functions are the canonical way to open a new database connection from
 :mod:`execsql.cli` and the connection-related metacommand handlers.
 """
 
-import os
-from typing import Optional
+from pathlib import Path
 
 from execsql.exceptions import ErrInfo
 from execsql.db.access import AccessDatabase
@@ -30,10 +29,10 @@ from execsql.db.firebird import FirebirdDatabase
 def db_Access(
     Access_fn: str,
     pw_needed: bool = False,
-    user: Optional[str] = None,
-    encoding: Optional[str] = None,
+    user: str | None = None,
+    encoding: str | None = None,
 ) -> AccessDatabase:
-    if not os.path.exists(Access_fn):
+    if not Path(Access_fn).exists():
         raise ErrInfo(
             type="error",
             other_msg=f'Access database file "{Access_fn}" does not exist.',
@@ -44,26 +43,27 @@ def db_Access(
 def db_Postgres(
     server_name: str,
     database_name: str,
-    user: Optional[str] = None,
+    user: str | None = None,
     pw_needed: bool = True,
-    port: Optional[int] = None,
-    encoding: Optional[str] = None,
+    port: int | None = None,
+    encoding: str | None = None,
     new_db: bool = False,
+    password: str | None = None,
 ) -> PostgresDatabase:
-    return PostgresDatabase(server_name, database_name, user, pw_needed, port, new_db=new_db)
+    return PostgresDatabase(server_name, database_name, user, pw_needed, port, new_db=new_db, password=password)
 
 
 def db_SQLite(
     sqlite_fn: str,
     new_db: bool = False,
-    encoding: Optional[str] = None,
+    encoding: str | None = None,
 ) -> SQLiteDatabase:
     if new_db:
         from execsql.utils.fileio import check_dir
 
         check_dir(sqlite_fn)
     else:
-        if not os.path.exists(sqlite_fn):
+        if not Path(sqlite_fn).exists():
             raise ErrInfo(
                 type="error",
                 other_msg=f'SQLite database file "{sqlite_fn}" does not exist.',
@@ -74,10 +74,10 @@ def db_SQLite(
 def db_SqlServer(
     server_name: str,
     database_name: str,
-    user: Optional[str] = None,
+    user: str | None = None,
     pw_needed: bool = True,
-    port: Optional[int] = None,
-    encoding: Optional[str] = None,
+    port: int | None = None,
+    encoding: str | None = None,
 ) -> SqlServerDatabase:
     return SqlServerDatabase(server_name, database_name, user, pw_needed, port, encoding)
 
@@ -85,10 +85,10 @@ def db_SqlServer(
 def db_MySQL(
     server_name: str,
     database_name: str,
-    user: Optional[str] = None,
+    user: str | None = None,
     pw_needed: bool = True,
-    port: Optional[int] = None,
-    encoding: Optional[str] = None,
+    port: int | None = None,
+    encoding: str | None = None,
 ) -> MySQLDatabase:
     return MySQLDatabase(server_name, database_name, user, pw_needed, port, encoding)
 
@@ -96,14 +96,14 @@ def db_MySQL(
 def db_DuckDB(
     duckdb_fn: str,
     new_db: bool = False,
-    encoding: Optional[str] = None,
+    encoding: str | None = None,
 ) -> DuckDBDatabase:
     if new_db:
         from execsql.utils.fileio import check_dir
 
         check_dir(duckdb_fn)
     else:
-        if not os.path.exists(duckdb_fn):
+        if not Path(duckdb_fn).exists():
             raise ErrInfo(
                 type="error",
                 other_msg=f'DuckDB database file "{duckdb_fn}" does not exist.',
@@ -114,10 +114,10 @@ def db_DuckDB(
 def db_Oracle(
     server_name: str,
     database_name: str,
-    user: Optional[str] = None,
+    user: str | None = None,
     pw_needed: bool = True,
-    port: Optional[int] = None,
-    encoding: Optional[str] = None,
+    port: int | None = None,
+    encoding: str | None = None,
 ) -> OracleDatabase:
     return OracleDatabase(server_name, database_name, user, pw_needed, port, encoding)
 
@@ -125,18 +125,18 @@ def db_Oracle(
 def db_Firebird(
     server_name: str,
     database_name: str,
-    user: Optional[str] = None,
+    user: str | None = None,
     pw_needed: bool = True,
-    port: Optional[int] = None,
-    encoding: Optional[str] = None,
+    port: int | None = None,
+    encoding: str | None = None,
 ) -> FirebirdDatabase:
     return FirebirdDatabase(server_name, database_name, user, pw_needed, port, encoding)
 
 
 def db_Dsn(
     dsn_name: str,
-    user: Optional[str] = None,
+    user: str | None = None,
     pw_needed: bool = True,
-    encoding: Optional[str] = None,
+    encoding: str | None = None,
 ) -> DsnDatabase:
     return DsnDatabase(dsn_name=dsn_name, user_name=user, need_passwd=pw_needed, encoding=encoding)