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

execsql/db/sqlite.py

@@ -9,10 +9,9 @@ files via the Python standard library ``sqlite3`` module.  Corresponds to
 """
 
 import datetime
-import io
 import re
 from decimal import Decimal
-from typing import Any, List, Optional
+from typing import Any
 
 from execsql.db.base import Database
 from execsql.exceptions import ErrInfo
@@ -20,8 +19,11 @@ from execsql.utils.errors import exception_desc, fatal_error
 import execsql.state as _state
 
 
+DEFAULT_CONNECT_TIMEOUT = 30  # seconds
+
+
 class SQLiteDatabase(Database):
-    def __init__(self, SQLite_fn: str) -> None:
+    def __init__(self, SQLite_fn: str, timeout: float = DEFAULT_CONNECT_TIMEOUT) -> None:
         try:
             import sqlite3  # noqa: F401
         except Exception:
@@ -36,6 +38,7 @@ class SQLiteDatabase(Database):
         self.encoding = "UTF-8"
         self.encode_commands = False
         self.paramstr = "?"
+        self.timeout = timeout
         self.conn = None
         self.autocommit = True
         self.open_db()
@@ -48,7 +51,7 @@ class SQLiteDatabase(Database):
 
         if self.conn is None:
             try:
-                self.conn = sqlite3.connect(self.db_name)
+                self.conn = sqlite3.connect(self.db_name, timeout=self.timeout)
             except ErrInfo:
                 raise
             except Exception:
@@ -72,11 +75,11 @@ class SQLiteDatabase(Database):
             self.rollback()
             raise
 
-    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()
-        sql = f"select name from sqlite_master where type='table' and name='{table_name}';"
+        sql = "select name from sqlite_master where type='table' and name=?;"
         try:
-            curs.execute(sql)
+            curs.execute(sql, (table_name,))
         except ErrInfo:
             raise
         except Exception:
@@ -94,19 +97,15 @@ class SQLiteDatabase(Database):
         self,
         table_name: str,
         column_name: str,
-        schema_name: Optional[str] = None,
+        schema_name: str | None = None,
     ) -> bool:
-        curs = self.cursor()
-        sql = f"select {column_name} from {table_name} limit 1;"
-        try:
-            curs.execute(sql)
-        except Exception:
-            return False
-        return True
+        cols = self.table_columns(table_name, schema_name)
+        return column_name in cols
 
-    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()
-        sql = f"select * from {table_name} where 1=0;"
+        quoted_tbl = self.quote_identifier(table_name)
+        sql = f"select * from {quoted_tbl} where 1=0;"
         try:
             curs.execute(sql)
         except ErrInfo:
@@ -123,9 +122,9 @@ class SQLiteDatabase(Database):
 
     def view_exists(self, view_name: str) -> bool:
         curs = self.cursor()
-        sql = f"select name from sqlite_master where type='view' and name='{view_name}';"
+        sql = "select name from sqlite_master where type='view' and name=?;"
         try:
-            curs.execute(sql)
+            curs.execute(sql, (view_name,))
         except ErrInfo:
             raise
         except Exception:
@@ -148,10 +147,10 @@ class SQLiteDatabase(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: Any,
     ) -> None:
         # The rowsource argument must be a generator yielding a list of values for the columns of the table.
@@ -174,6 +173,7 @@ class SQLiteDatabase(Database):
         paramspec = ",".join(["?" for c in columns])
         sql = f"insert into {sq_name} ({colspec}) values ({paramspec});"
         curs = self.cursor()
+        total_rows = 0
         for datalineno, line in enumerate(rowsource):
             # Skip empty rows.
             if not (len(line) == 1 and line[0] is None):
@@ -190,16 +190,15 @@ class SQLiteDatabase(Database):
                                 line[i] = line[i].strip()
                             if _state.conf.replace_newlines:
                                 line[i] = re.sub(r"[\s\t]*[\r\n]+[\s\t]*", " ", 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
                 # Convert datetime, time, and Decimal values to strings.
                 for i in range(len(linedata)):
                     if type(linedata[i]) in (datetime.datetime, datetime.time, Decimal):
                         linedata[i] = str(linedata[i])
                 add_line = True
                 if not _state.conf.empty_rows:
-                    add_line = not all([c is None for c in linedata])
+                    add_line = not all(c is None for c in linedata)
                 if add_line:
                     try:
                         curs.execute(sql, linedata)
@@ -213,17 +212,27 @@ class SQLiteDatabase(Database):
                             exception_msg=exception_desc(),
                             other_msg=f"Can't load data into table {sq_name} from line {{{line}}}",
                         )
+                    total_rows += 1
+                    interval = getattr(_state.conf, "import_progress_interval", 0)
+                    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 _state.exec_log:
+            _state.exec_log.log_status_info(
+                f"IMPORT into {sq_name} complete: {total_rows} rows imported.",
+            )
 
     def import_entire_file(
         self,
-        schema_name: Optional[str],
+        schema_name: str | None,
         table_name: str,
         column_name: str,
         file_name: str,
     ) -> None:
         import sqlite3
 
-        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/sqlserver.py

@@ -7,13 +7,11 @@ Implements :class:`SqlServerDatabase`, which connects to Microsoft SQL
 Server via ``pyodbc``.  Corresponds to ``-t s`` 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.errors import fatal_error
+from execsql.utils.auth import clear_stored_password, get_password, password_from_keyring
 import execsql.state as _state
 
 
@@ -22,11 +20,11 @@ class SqlServerDatabase(Database):
         self,
         server_name: str,
         db_name: str,
-        user_name: Optional[str],
+        user_name: str | None,
         need_passwd: bool = False,
-        port: Optional[int] = 1433,
-        encoding: Optional[str] = "latin1",
-        password: Optional[str] = None,
+        port: int | None = 1433,
+        encoding: str | None = "latin1",
+        password: str | None = None,
     ) -> None:
         try:
             import pyodbc  # noqa: F401
@@ -76,30 +74,47 @@ class SqlServerDatabase(Database):
                 "SQL Native Client",
                 "SQL Server",
             )
-            for drv in ssdrivers:
-                if self.user:
-                    if self.password:
-                        connstr = (
-                            f"DRIVER={{{drv}}};SERVER={self.server_name};MARS_Connection=Yes; "
-                            f"DATABASE={self.db_name};Uid={self.user};Pwd={self.password}"
-                        )
+
+            def _try_drivers():
+                for drv in ssdrivers:
+                    if self.user:
+                        if self.password:
+                            connstr = (
+                                f"DRIVER={{{drv}}};SERVER={self.server_name};MARS_Connection=Yes; "
+                                f"DATABASE={self.db_name};Uid={self.user};Pwd={self.password}"
+                            )
+                        else:
+                            connstr = (
+                                f"DRIVER={{{drv}}};SERVER={self.server_name};MARS_Connection=Yes; "
+                                f"DATABASE={self.db_name};Uid={self.user}"
+                            )
                     else:
                         connstr = (
                             f"DRIVER={{{drv}}};SERVER={self.server_name};MARS_Connection=Yes; "
-                            f"DATABASE={self.db_name};Uid={self.user}"
+                            f"DATABASE={self.db_name};Trusted_Connection=yes"
                         )
-                else:
-                    connstr = (
-                        f"DRIVER={{{drv}}};SERVER={self.server_name};MARS_Connection=Yes; "
-                        f"DATABASE={self.db_name};Trusted_Connection=yes"
-                    )
-                try:
-                    self.conn = pyodbc.connect(connstr)
-                except Exception:
-                    _state.exec_log.log_status_info(f"Could not connect using: {connstr}")
-                else:
-                    _state.exec_log.log_status_info(f"Connected using: {connstr}")
-                    break
+                    try:
+                        self.conn = pyodbc.connect(connstr)
+                    except Exception:
+                        _state.exec_log.log_status_info(f"Could not connect using: {connstr}")
+                    else:
+                        _state.exec_log.log_status_info(f"Connected using: {connstr}")
+                        return True
+                return False
+
+            if not _try_drivers() and password_from_keyring():
+                # Stored credential is stale — clear it and re-prompt.
+                clear_stored_password("SQL Server", self.db_name, self.user, self.server_name)
+                self.password = get_password(
+                    "SQL Server",
+                    self.db_name,
+                    self.user,
+                    server_name=self.server_name,
+                    skip_keyring=True,
+                    other_msg="(stored credential failed — enter current password)",
+                )
+                _try_drivers()
+
             if not self.conn:
                 raise ErrInfo(
                     type="error",
@@ -147,14 +162,14 @@ class SqlServerDatabase(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/exceptions.py

@@ -6,9 +6,11 @@ Custom exception hierarchy for execsql.
 All domain-specific exceptions are defined here so that callers can import
 from a single location.  Notable exceptions:
 
+- :class:`ExecSqlError` — common base for all single-message execsql exceptions.
 - :class:`ConfigError` — invalid or missing ``execsql.conf`` values.
-- :class:`ErrInfo` — both an exception and a structured error-data carrier
-  (type, command text, exception message, script location).
+- :class:`ErrInfo` — rich exception carrying type, command text, exception
+  message, and script location; used as both a raised exception and an error
+  data carrier passed to ``exit_now()``.
 - :class:`ExecSqlTimeoutError` — timeout during alarm-timer operations.
 - :class:`DataTypeError` / :class:`DbTypeError` — type-system failures.
 - :class:`ColumnError` / :class:`DataTableError` — data-model failures.
@@ -20,26 +22,60 @@ from a single location.  Notable exceptions:
 """
 
 
-class ConfigError(Exception):
-    def __init__(self, msg: str) -> None:
-        self.value = msg
+class ExecSqlError(Exception):
+    """Base class for simple single-message execsql exceptions.
+
+    Subclasses inherit a ``value`` attribute holding the original message and
+    a ``__repr__`` that uses the concrete class name, so no boilerplate is
+    needed in each subclass.
+
+    ``super().__init__(errmsg)`` is called so that ``str(exc)``, ``exc.args``,
+    and standard logging all produce meaningful output.
+    """
+
+    def __init__(self, errmsg: str) -> None:
+        super().__init__(errmsg)
+        self.value = errmsg
 
     def __repr__(self) -> str:
-        return f"ConfigError({self.value!r})"
+        return f"{type(self).__name__}({self.value!r})"
+
 
+class ConfigError(ExecSqlError):
+    """Raised for invalid or missing execsql configuration values."""
 
-class ExecSqlTimeoutError(Exception):
-    """Renamed from TimeoutError to avoid shadowing the Python 3.3+ built-in."""
 
-    pass
+class ExecSqlTimeoutError(ExecSqlError):
+    """Timeout during alarm-timer operations.
+
+    Inherits from :class:`ExecSqlError` so that generic ``except ExecSqlError``
+    handlers will catch timeouts.  Accepts an optional message (defaults to
+    ``"Operation timed out"``), keeping it compatible with bare
+    ``raise ExecSqlTimeoutError`` usage.
+    """
+
+    def __init__(self, errmsg: str = "Operation timed out") -> None:
+        super().__init__(errmsg)
 
 
 class ErrInfo(Exception):
-    """Both an exception and a data carrier for error information."""
+    """Rich exception and error-data carrier for execsql.
+
+    ``str(e)`` returns the most informative available message (``other_msg``,
+    then ``exception_msg``, then ``type``) so that standard logging and
+    exception handlers produce useful output without requiring callers to know
+    about the execsql-specific ``eval_err()`` / ``write()`` interface.
+
+    ``eval_err()`` / ``write()`` remain available for the full formatted
+    message including script location, timestamp, and command context.
+    """
 
     def __repr__(self) -> str:
         return f"ErrInfo({self.type!r}, {self.command!r}, {self.exception!r}, {self.other!r})"
 
+    def __str__(self) -> str:
+        return self.other or self.exception or self.type or "ErrInfo"
+
     def __init__(
         self,
         type: str,
@@ -56,6 +92,9 @@ class ErrInfo(Exception):
         self.cmd = None
         self.cmdtype = None
         self.error_message = None
+        # Pass a concise message to Exception so str(e), e.args, and
+        # standard loggers produce useful output.
+        super().__init__(self.other or self.exception or self.type)
 
     def script_info(self) -> str | None:
         if self.script_line_no:
@@ -117,6 +156,7 @@ class DataTypeError(Exception):
     def __init__(self, data_type_name: str, error_msg: str) -> None:
         self.data_type_name = data_type_name or "Unspecified data type"
         self.error_msg = error_msg or "Unspecified error"
+        super().__init__(str(self))
 
     def __repr__(self) -> str:
         return f"DataTypeError({self.data_type_name!r}, {self.error_msg!r})"
@@ -130,6 +170,7 @@ class DbTypeError(Exception):
         self.dbms_id = dbms_id
         self.data_type = data_type
         self.error_msg = error_msg or "Unspecified error"
+        super().__init__(str(self))
 
     def __repr__(self) -> str:
         return f"DbTypeError({self.dbms_id!r}, {self.data_type!r}, {self.error_msg!r})"
@@ -141,32 +182,19 @@ class DbTypeError(Exception):
             return f"{self.dbms_id} DBMS type error: {self.error_msg}"
 
 
-class ColumnError(Exception):
-    def __init__(self, errmsg: str) -> None:
-        self.value = errmsg
-
-    def __repr__(self) -> str:
-        return f"ColumnError({self.value!r})"
-
-    def __str__(self) -> str:
-        return repr(self.value)
+class ColumnError(ExecSqlError):
+    """Raised for column-level data errors."""
 
 
-class DataTableError(Exception):
-    def __init__(self, errmsg: str) -> None:
-        self.value = errmsg
-
-    def __repr__(self) -> str:
-        return f"DataTableError({self.value})"
-
-    def __str__(self) -> str:
-        return repr(self.value)
+class DataTableError(ExecSqlError):
+    """Raised for DataTable-level errors."""
 
 
 class DatabaseNotImplementedError(Exception):
     def __init__(self, db_name: str, method: str) -> None:
         self.db_name = db_name
         self.method = method
+        super().__init__(str(self))
 
     def __repr__(self) -> str:
         return f"DatabaseNotImplementedError({self.db_name!r}, {self.method!r})"
@@ -175,49 +203,25 @@ class DatabaseNotImplementedError(Exception):
         return f"Method {self.method} is not implemented for database {self.db_name}"
 
 
-class OdsFileError(Exception):
-    def __init__(self, errmsg: str) -> None:
-        self.value = errmsg
-
-    def __repr__(self) -> str:
-        return f"OdsFileError({self.value!r})"
-
-
-class XlsFileError(Exception):
-    def __init__(self, errmsg: str) -> None:
-        self.value = errmsg
-
-    def __repr__(self) -> str:
-        return f"XlsFileError({self.value!r})"
-
-
-class XlsxFileError(Exception):
-    def __init__(self, errmsg: str) -> None:
-        self.value = errmsg
+class OdsFileError(ExecSqlError):
+    """Raised for ODS file I/O errors."""
 
-    def __repr__(self) -> str:
-        return f"XlsxFileError({self.value!r})"
 
+class XlsFileError(ExecSqlError):
+    """Raised for XLS file I/O errors."""
 
-class ConsoleUIError(Exception):
-    def __init__(self, errmsg: str) -> None:
-        self.value = errmsg
 
-    def __repr__(self) -> str:
-        return f"ConsoleUIError({self.value!r})"
+class XlsxFileError(ExecSqlError):
+    """Raised for XLSX file I/O errors."""
 
 
-class CondParserError(Exception):
-    def __init__(self, errmsg: str) -> None:
-        self.value = errmsg
+class ConsoleUIError(ExecSqlError):
+    """Raised for GUI console errors."""
 
-    def __repr__(self) -> str:
-        return f"CondParserError({self.value!r})"
 
+class CondParserError(ExecSqlError):
+    """Raised for conditional-expression parse errors."""
 
-class NumericParserError(Exception):
-    def __init__(self, errmsg: str) -> None:
-        self.value = errmsg
 
-    def __repr__(self) -> str:
-        return f"NumericParserError({self.value!r})"
+class NumericParserError(ExecSqlError):
+    """Raised for numeric-expression parse errors."""

execsql/exporters/__init__.py

@@ -10,5 +10,5 @@ importing directly from here.
 
 Sub-modules: ``base``, ``delimited``, ``json``, ``xml``, ``html``,
 ``latex``, ``ods``, ``xls``, ``zip``, ``raw``, ``pretty``, ``values``,
-``templates``, ``feather``, ``duckdb``, ``sqlite``.
+``templates``, ``feather``, ``parquet``, ``duckdb``, ``sqlite``.
 """

execsql/exporters/base.py

@@ -1,5 +1,3 @@
-from __future__ import annotations
-
 """
 Base export infrastructure — metadata tracking and write specifications.
 
@@ -14,42 +12,63 @@ Provides:
   (message text, file path, encoding) used by halt/cancel hooks.
 """
 
-import os
-import re
-from typing import Any, Optional, List
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
 
 import execsql.state as _state
+from execsql.script import current_script_line
+from execsql.utils.errors import file_size_date
+from execsql.utils.gui import ConsoleUIError
 
 
 class ExportRecord:
+    """Records the details of a single EXPORT operation for metadata tracking.
+
+    Captures the query name, output file path, optional zip file, user
+    description, originating script location, and database connection info.
+    """
+
     def __init__(
         self,
         queryname: str,
         outfile: str,
-        zipfile: Optional[str] = None,
-        description: Optional[str] = None,
+        zipfile: str | None = None,
+        description: str | None = None,
     ) -> None:
         self.exported = False
         # Record is a list of: table_or_query_name, filename, zipfilename, file_path, user_description, script_name,
         # script_path, script_line_no, script_datetime, database_name, database_server, user_name.
         if zipfile is not None:
-            fpath, zfname = os.path.split(os.path.abspath(zipfile))
+            fpath, zfname = str(Path(zipfile).resolve().parent), Path(zipfile).resolve().name
             fname = outfile
         else:
-            fpath, fname = os.path.split(os.path.abspath(outfile))
+            fpath, fname = str(Path(outfile).resolve().parent), Path(outfile).resolve().name
             zfname = None
-        script, lno = _state.current_script_line()
-        spath, sname = os.path.split(os.path.abspath(script))
-        ssz, sdt = _state.file_size_date(script)
+        import getpass
+
+        script, lno = current_script_line()
+        if script and Path(script).is_file():
+            spath, sname = str(Path(script).resolve().parent), Path(script).resolve().name
+            _, sdt = file_size_date(script)
+        else:
+            spath, sname = "", script or "<inline>"
+            _, sdt = 0, ""
         db = _state.dbs.current()
         svr = db.server_name
         dbn = db.db_name
-        usr = db.user if db.user is not None else _state.getpass.getuser()
+        usr = db.user if db.user is not None else getpass.getuser()
         self.record = [queryname, fname, zfname, fpath, description, sname, spath, lno, sdt, dbn, svr, usr]
 
 
 class ExportMetadata:
-    # A list of ExportRecord objects.
+    """Collection of :class:`ExportRecord` objects; can write itself as JSON.
+
+    Accumulates export records during a script run and provides them to the
+    EXPORT METADATA metacommand for serialisation.
+    """
+
     colhdrs = [
         "query",
         "filename",
@@ -66,7 +85,7 @@ class ExportMetadata:
     ]
 
     def __init__(self) -> None:
-        self.recordlist: List[ExportRecord] = []
+        self.recordlist: list[ExportRecord] = []
 
     def add(self, exp_record: ExportRecord) -> None:
         self.recordlist.append(exp_record)
@@ -85,10 +104,16 @@ class ExportMetadata:
 
 
 class WriteSpec:
+    """Specification for a deferred WRITE operation used by halt/cancel hooks.
+
+    Stores a message, optional destination file, tee flag, and repeatability
+    setting. Resolved and executed later by the hook machinery.
+    """
+
     def __repr__(self) -> str:
         return f"WriteSpec({self.msg}, {self.outfile}, {self.tee})"
 
-    def __init__(self, message: str, dest: Optional[str] = None, tee: Any = None, repeatable: bool = False) -> None:
+    def __init__(self, message: str, dest: str | None = None, tee: Any = None, repeatable: bool = False) -> None:
         # Inputs
         # message: Text to write.  May contain substitution variable references.
         # dest: The to which the text should be written.  If omitted, the message
@@ -122,7 +147,7 @@ class WriteSpec:
             if (not self.outfile) or self.tee:
                 try:
                     _state.output.write(msg.encode(conf.output_encoding))
-                except _state.ConsoleUIError as e:
+                except ConsoleUIError as e:
                     _state.output.reset()
                     _state.exec_log.log_status_info(
                         f"Console UI write failed (message {{{e.value}}}); output reset to stdout.",