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

execsql/db/access.py

@@ -68,7 +68,7 @@ class AccessDatabase(Database):
         self.dao_conn = None
         self.conn = None  # ODBC connection
         self.paramstr = "?"
-        self.dt_cast = dict(Database.dt_cast)
+        self.dt_cast = dict(self.dt_cast)  # Copy the lazy-initialized default before overriding.
         self.dt_cast[datetime.date] = self.as_datetime
         self.dt_cast[datetime.datetime] = self.as_datetime
         self.dt_cast[int] = self.int_or_bool
@@ -290,17 +290,17 @@ class AccessDatabase(Database):
         self.dao_flush_check()
         curs = self.cursor()
         try:
-            sql = f"select Name from MSysObjects where Name='{table_name}' And Type In (1,4,6);"
-            curs.execute(sql)
+            sql = "select Name from MSysObjects where Name=? And Type In (1,4,6);"
+            curs.execute(sql, (table_name,))
         except ErrInfo:
             raise
-        except Exception:
+        except Exception as e:
             raise ErrInfo(
                 type="db",
                 command_text=sql,
                 exception_msg=exception_desc(),
                 other_msg=f"Failure on test for existence of Access table {table_name}",
-            )
+            ) from e
         rows = curs.fetchall()
         return len(rows) > 0
 
@@ -312,7 +312,9 @@ class AccessDatabase(Database):
     ) -> bool:
         self.dao_flush_check()
         curs = self.cursor()
-        sql = f"select top 1 {column_name} from {table_name};"
+        quoted_col = self.quote_identifier(column_name)
+        quoted_tbl = self.quote_identifier(table_name)
+        sql = f"select top 1 {quoted_col} from {quoted_tbl};"
         try:
             curs.execute(sql)
         except Exception:
@@ -322,24 +324,25 @@ class AccessDatabase(Database):
     def table_columns(self, table_name: str, schema_name: str | None = None) -> list[str]:
         self.dao_flush_check()
         curs = self.cursor()
-        curs.execute(f"select top 1 * from {table_name};")
+        quoted_tbl = self.quote_identifier(table_name)
+        curs.execute(f"select top 1 * from {quoted_tbl};")
         return [d[0] for d in curs.description]
 
     def view_exists(self, view_name: str, schema_name: str | None = None) -> bool:
         self.dao_flush_check()
         curs = self.cursor()
         try:
-            sql = f"select Name from MSysObjects where Name='{view_name}' And Type = 5;"
-            curs.execute(sql)
+            sql = "select Name from MSysObjects where Name=? And Type = 5;"
+            curs.execute(sql, (view_name,))
         except ErrInfo:
             raise
-        except Exception:
+        except Exception as e:
             raise ErrInfo(
                 type="db",
                 command_text=sql,
                 exception_msg=exception_desc(),
                 other_msg=f"Test for existence of Access view/query {view_name}",
-            )
+            ) from e
         rows = curs.fetchall()
         return len(rows) > 0
 
@@ -414,5 +417,6 @@ class AccessDatabase(Database):
         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)});"
+        quoted_col = self.quote_identifier(column_name)
+        sql = f"insert into {sq_name} ({quoted_col}) values ({self.paramsubs(1)});"
         self.cursor().execute(sql, (pyodbc.Binary(filedata),))

execsql/db/base.py

@@ -14,7 +14,9 @@ open :class:`Database` instances and tracks which connection is currently
 active.  It is the canonical ``_state.dbs`` object.
 """
 
+import datetime
 import re
+from decimal import Decimal
 from typing import Any
 from collections.abc import Callable, Generator, Iterator
 
@@ -23,10 +25,36 @@ from execsql.utils.errors import exception_desc
 import execsql.state as _state
 
 
+def _default_dt_cast() -> dict[type, Callable]:
+    """Build the default type-cast mapping used by all database backends."""
+    from execsql.types import DT_Boolean, DT_Timestamp, DT_Date, DT_Decimal
+
+    return {
+        int: int,
+        float: float,
+        str: str,
+        bool: DT_Boolean().from_data,
+        datetime.datetime: DT_Timestamp().from_data,
+        datetime.date: DT_Date().from_data,
+        Decimal: DT_Decimal().from_data,
+        bytearray: bytearray,
+    }
+
+
 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] | None = None
+
+    @property
+    def dt_cast(self) -> dict[type, Callable]:
+        if self._dt_cast is None:
+            self._dt_cast = _default_dt_cast()
+        return self._dt_cast
+
+    @dt_cast.setter
+    def dt_cast(self, value: dict[type, Callable]) -> None:
+        self._dt_cast = value
 
     def __init__(
         self,
@@ -237,14 +265,14 @@ class Database:
             curs.execute(sql, params)
         except ErrInfo:
             raise
-        except Exception:
+        except Exception as e:
             self.rollback()
             raise ErrInfo(
                 type="db",
                 command_text=sql,
                 exception_msg=exception_desc(),
                 other_msg=f"Failed test for existence of table {table_name} in {self.name()}",
-            )
+            ) from e
         rows = curs.fetchall()
         curs.close()
         return len(rows) > 0
@@ -271,14 +299,14 @@ class Database:
             curs.execute(sql, params)
         except ErrInfo:
             raise
-        except Exception:
+        except Exception as e:
             self.rollback()
             raise ErrInfo(
                 type="db",
                 command_text=sql,
                 exception_msg=exception_desc(),
                 other_msg=f"Failed test for existence of column {column_name} in table {table_name} of {self.name()}",
-            )
+            ) from e
         rows = curs.fetchall()
         curs.close()
         return len(rows) > 0
@@ -299,14 +327,14 @@ class Database:
             curs.execute(sql, params)
         except ErrInfo:
             raise
-        except Exception:
+        except Exception as e:
             self.rollback()
             raise ErrInfo(
                 type="db",
                 command_text=sql,
                 exception_msg=exception_desc(),
                 other_msg=f"Failed to get column names for table {table_name} of {self.name()}",
-            )
+            ) from e
         rows = curs.fetchall()
         curs.close()
         return [row[0] for row in rows]
@@ -323,14 +351,14 @@ class Database:
             curs.execute(sql, params)
         except ErrInfo:
             raise
-        except Exception:
+        except Exception as e:
             self.rollback()
             raise ErrInfo(
                 type="db",
                 command_text=sql,
                 exception_msg=exception_desc(),
                 other_msg=f"Failed test for existence of view {view_name} in {self.name()}",
-            )
+            ) from e
         rows = curs.fetchall()
         curs.close()
         return len(rows) > 0
@@ -382,87 +410,126 @@ class Database:
         curs = self.cursor()
         eof = False
         total_rows = 0
-        while True:
-            b = []
-            for _j in range(_state.conf.import_row_buffer):
-                try:
-                    line = next(rows)
-                except StopIteration:
-                    eof = True
-                else:
-                    if len(line) > len(ts_colnames):
-                        extra_err = True
-                        if _state.conf.del_empty_cols:
-                            any_non_empty = False
-                            for cno in range(len(ts_colnames), len(line)):
-                                if not (
-                                    line[cno] is None
-                                    or (
-                                        not _state.conf.empty_strings
-                                        and isinstance(line[cno], _state.stringtypes)
-                                        and len(line[cno].strip()) == 0
-                                    )
-                                    and _state.conf.del_empty_cols
-                                ):
-                                    any_non_empty = True
-                                    break
-                            extra_err = any_non_empty
-                        if extra_err:
-                            raise ErrInfo(
-                                type="error",
-                                other_msg=f"Too many data columns on line {{{line}}}",
-                            )
-                        else:
-                            line = line[: len(ts_colnames)]
-                    if not (len(line) == 1 and line[0] is None):
-                        if _state.conf.trim_strings or _state.conf.replace_newlines or not _state.conf.empty_strings:
-                            for i in range(len(line)):
-                                if line[i] is not None and isinstance(
-                                    line[i],
-                                    _state.stringtypes,
-                                ):
-                                    if _state.conf.trim_strings:
-                                        line[i] = line[i].strip()
-                                    if _state.conf.replace_newlines:
-                                        line[i] = re.sub(
-                                            r"[\s\t]*[\r\n]+[\s\t]*",
-                                            " ",
-                                            line[i],
+
+        # Optional rich progress bar for long-running imports.
+        use_progress = getattr(_state.conf, "show_progress", False)
+        progress_ctx = None
+        task_id = None
+        if use_progress:
+            try:
+                from rich.progress import Progress, SpinnerColumn, TextColumn, TimeElapsedColumn
+                from rich.console import Console
+
+                progress_ctx = Progress(
+                    SpinnerColumn(),
+                    TextColumn("[bold blue]IMPORT[/bold blue] {task.description}"),
+                    TextColumn("{task.completed:,} rows"),
+                    TimeElapsedColumn(),
+                    console=Console(stderr=True),
+                )
+            except ImportError:
+                use_progress = False
+
+        def _import_loop() -> int:
+            nonlocal eof, total_rows, task_id
+            while True:
+                b = []
+                for _j in range(_state.conf.import_row_buffer):
+                    try:
+                        line = next(rows)
+                    except StopIteration:
+                        eof = True
+                    else:
+                        if len(line) > len(ts_colnames):
+                            extra_err = True
+                            if _state.conf.del_empty_cols:
+                                any_non_empty = False
+                                for cno in range(len(ts_colnames), len(line)):
+                                    if not (
+                                        line[cno] is None
+                                        or (
+                                            not _state.conf.empty_strings
+                                            and isinstance(line[cno], _state.stringtypes)
+                                            and len(line[cno].strip()) == 0
                                         )
-                                    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)]
-                        row = []
-                        for i, v in enumerate(lt):
-                            if incl_col[i]:
-                                row.append(v)
-                        add_line = True
-                        if not _state.conf.empty_rows:
-                            add_line = not all(c is None for c in row)
-                        if add_line:
-                            b.append(row)
-            if len(b) > 0:
-                try:
-                    curs.executemany(sql, b)
-                except ErrInfo:
-                    raise
-                except Exception:
-                    self.rollback()
-                    raise ErrInfo(
-                        type="db",
-                        command_text=sql,
-                        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
+                                        and _state.conf.del_empty_cols
+                                    ):
+                                        any_non_empty = True
+                                        break
+                                extra_err = any_non_empty
+                            if extra_err:
+                                raise ErrInfo(
+                                    type="error",
+                                    other_msg=f"Too many data columns on line {{{line}}}",
+                                )
+                            else:
+                                line = line[: len(ts_colnames)]
+                        if not (len(line) == 1 and line[0] is None):
+                            if (
+                                _state.conf.trim_strings
+                                or _state.conf.replace_newlines
+                                or not _state.conf.empty_strings
+                            ):
+                                for i in range(len(line)):
+                                    if line[i] is not None and isinstance(
+                                        line[i],
+                                        _state.stringtypes,
+                                    ):
+                                        if _state.conf.trim_strings:
+                                            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 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)]
+                            row = []
+                            for i, v in enumerate(lt):
+                                if incl_col[i]:
+                                    row.append(v)
+                            add_line = True
+                            if not _state.conf.empty_rows:
+                                add_line = not all(c is None for c in row)
+                            if add_line:
+                                b.append(row)
+                if len(b) > 0:
+                    try:
+                        curs.executemany(sql, b)
+                    except ErrInfo:
+                        raise
+                    except Exception as e:
+                        self.rollback()
+                        raise ErrInfo(
+                            type="db",
+                            command_text=sql,
+                            exception_msg=exception_desc(),
+                            other_msg=f"Can't load data into table {sq_name} of {self.name()} from line {{{line}}}",
+                        ) from e
+                    total_rows += len(b)
+                    if use_progress and progress_ctx is not None and task_id is not None:
+                        progress_ctx.update(task_id, completed=total_rows)
+                    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
+            return total_rows
+
+        if use_progress and progress_ctx is not None:
+            with progress_ctx:
+                task_id = progress_ctx.add_task(sq_name, total=None)
+                _import_loop()
+        else:
+            _import_loop()
+
         if _state.exec_log:
             _state.exec_log.log_status_info(
                 f"IMPORT into {sq_name} complete: {total_rows} rows imported.",
@@ -520,7 +587,8 @@ class Database:
         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)});"
+        quoted_col = self.quote_identifier(column_name)
+        sql = f"insert into {sq_name} ({quoted_col}) values ({self.paramsubs(1)});"
         self.cursor().execute(sql, (filedata,))
 
 

execsql/db/dsn.py

@@ -79,23 +79,23 @@ class DsnDatabase(Database):
         def _try_connect():
             try:
                 _dsn_connect()
-            except Exception:
+            except Exception as e:
                 excdesc = exception_desc()
                 if "Optional feature not implemented" in excdesc:
                     try:
                         _dsn_connect(autocommit=True)
-                    except Exception:
+                    except Exception as e:
                         raise ErrInfo(
                             type="exception",
                             exception_msg=exception_desc(),
                             other_msg=f"Can't open DSN database {self.db_name} using ODBC",
-                        )
+                        ) from e
                 else:
                     raise ErrInfo(
                         type="exception",
                         exception_msg=excdesc,
                         other_msg=f"Can't open DSN database {self.db_name} using ODBC",
-                    )
+                    ) from e
 
         try:
             _try_connect()
@@ -136,5 +136,6 @@ class DsnDatabase(Database):
         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)});"
+        quoted_col = self.quote_identifier(column_name)
+        sql = f"insert into {sq_name} ({quoted_col}) values ({self.paramsubs(1)});"
         self.cursor().execute(sql, (pyodbc.Binary(filedata),))

execsql/db/duckdb.py

@@ -48,12 +48,12 @@ class DuckDBDatabase(Database):
                 self.conn = duckdb.connect(self.db_name, read_only=False)
             except ErrInfo:
                 raise
-            except Exception:
+            except Exception as e:
                 raise ErrInfo(
                     type="exception",
                     exception_msg=exception_desc(),
                     other_msg=f"Can't open DuckDB database {self.db_name}",
-                )
+                ) from e
 
     def exec_cmd(self, querycommand: str) -> None:
         # DuckDB does not support stored functions, so the querycommand

execsql/db/firebird.py

@@ -30,7 +30,7 @@ class FirebirdDatabase(Database):
             import fdb as firebird_lib  # noqa: F401
         except Exception:
             fatal_error(
-                "The fdb module is required to connect to MySQL.   See https://pypi.python.org/pypi/fdb/",
+                "The fdb module is required to connect to Firebird.   See https://pypi.python.org/pypi/fdb/",
             )
         from execsql.types import dbt_firebird
 
@@ -104,9 +104,9 @@ class FirebirdDatabase(Database):
                 raise
             except ErrInfo:
                 raise
-            except Exception:
+            except Exception as e:
                 msg = f"Failed to open Firebird database {self.db_name} on {self.server_name}"
-                raise ErrInfo(type="exception", exception_msg=exception_desc(), other_msg=msg)
+                raise ErrInfo(type="exception", exception_msg=exception_desc(), other_msg=msg) from e
 
     def exec_cmd(self, querycommand: str) -> None:
         # The querycommand must be a stored function (/procedure)
@@ -122,15 +122,15 @@ class FirebirdDatabase(Database):
     def table_exists(self, table_name: str, schema_name: str | None = None) -> bool:
         curs = self.cursor()
         sql = (
-            f"SELECT RDB$RELATION_NAME FROM RDB$RELATIONS "
-            f"WHERE RDB$SYSTEM_FLAG=0 AND RDB$VIEW_BLR IS NULL "
-            f"AND RDB$RELATION_NAME='{table_name.upper()}';"
+            "SELECT RDB$RELATION_NAME FROM RDB$RELATIONS "
+            "WHERE RDB$SYSTEM_FLAG=0 AND RDB$VIEW_BLR IS NULL "
+            "AND RDB$RELATION_NAME=?;"
         )
         try:
-            curs.execute(sql)
+            curs.execute(sql, (table_name.upper(),))
         except ErrInfo:
             raise
-        except Exception:
+        except Exception as e:
             try:
                 self.rollback()
             except Exception:
@@ -140,7 +140,7 @@ class FirebirdDatabase(Database):
                 command_text=sql,
                 exception_msg=exception_desc(),
                 other_msg=f"Failed test for existence of Firebird table {table_name}",
-            )
+            ) from e
         rows = curs.fetchall()
         self.conn.commit()
         curs.close()
@@ -153,7 +153,9 @@ class FirebirdDatabase(Database):
         schema_name: str | None = None,
     ) -> bool:
         curs = self.cursor()
-        sql = f"select first 1 {column_name} from {table_name};"
+        quoted_col = self.quote_identifier(column_name)
+        quoted_tbl = self.quote_identifier(table_name)
+        sql = f"select first 1 {quoted_col} from {quoted_tbl};"
         try:
             curs.execute(sql)
         except Exception:
@@ -162,36 +164,37 @@ class FirebirdDatabase(Database):
 
     def table_columns(self, table_name: str, schema_name: str | None = None) -> list[str]:
         curs = self.cursor()
-        sql = f"select first 1 * from {table_name};"
+        quoted_tbl = self.quote_identifier(table_name)
+        sql = f"select first 1 * from {quoted_tbl};"
         try:
             curs.execute(sql)
         except ErrInfo:
             raise
-        except Exception:
+        except Exception as e:
             self.rollback()
             raise ErrInfo(
                 type="db",
                 command_text=sql,
                 exception_msg=exception_desc(),
                 other_msg=f"Failed to get column names for table {table_name} of {self.name()}",
-            )
+            ) from e
         return [d[0] for d in curs.description]
 
     def view_exists(self, view_name: str, schema_name: str | None = None) -> bool:
         curs = self.cursor()
-        sql = f"select distinct rdb$view_name from rdb$view_relations where rdb$view_name = '{view_name}';"
+        sql = "select distinct rdb$view_name from rdb$view_relations where rdb$view_name = ?;"
         try:
-            curs.execute(sql)
+            curs.execute(sql, (view_name,))
         except ErrInfo:
             raise
-        except Exception:
+        except Exception as e:
             self.rollback()
             raise ErrInfo(
                 type="db",
                 command_text=sql,
                 exception_msg=exception_desc(),
                 other_msg=f"Failed test for existence of Firebird view {view_name}",
-            )
+            ) from e
         rows = curs.fetchall()
         curs.close()
         return len(rows) > 0
@@ -202,8 +205,9 @@ class FirebirdDatabase(Database):
     def role_exists(self, rolename: str) -> bool:
         curs = self.cursor()
         curs.execute(
-            f"SELECT DISTINCT USER FROM RDB$USER_PRIVILEGES WHERE USER = '{rolename}' union "
-            f" SELECT DISTINCT RDB$ROLE_NAME FROM RDB$ROLES WHERE RDB$ROLE_NAME = '{rolename}';",
+            "SELECT DISTINCT USER FROM RDB$USER_PRIVILEGES WHERE USER = ? union "
+            " SELECT DISTINCT RDB$ROLE_NAME FROM RDB$ROLES WHERE RDB$ROLE_NAME = ?;",
+            (rolename, rolename),
         )
         rows = curs.fetchall()
         curs.close()

execsql/db/mysql.py

@@ -109,9 +109,9 @@ class MySQLDatabase(Database):
                 raise
             except ErrInfo:
                 raise
-            except Exception:
+            except Exception as e:
                 msg = f"Failed to open MySQL database {self.db_name} on {self.server_name}"
-                raise ErrInfo(type="exception", exception_msg=exception_desc(), other_msg=msg)
+                raise ErrInfo(type="exception", exception_msg=exception_desc(), other_msg=msg) from e
 
     def exec_cmd(self, querycommand: str) -> None:
         # The querycommand must be a stored function (/procedure)
@@ -130,9 +130,10 @@ class MySQLDatabase(Database):
     def role_exists(self, rolename: str) -> bool:
         curs = self.cursor()
         curs.execute(
-            f"select distinct user as role from mysql.user where user = '{rolename}'"
-            f" union select distinct role_name as role from information_schema.applicable_roles"
-            f" where role_name = '{rolename}'",
+            "select distinct user as role from mysql.user where user = %s"
+            " union select distinct role_name as role from information_schema.applicable_roles"
+            " where role_name = %s",
+            (rolename, rolename),
         )
         rows = curs.fetchall()
         curs.close()
@@ -274,14 +275,14 @@ class MySQLDatabase(Database):
                         curs.executemany(sql_template, b)
                     except ErrInfo:
                         raise
-                    except Exception:
+                    except Exception as e:
                         self.rollback()
                         raise ErrInfo(
                             type="db",
                             command_text=sql_template,
                             exception_msg=exception_desc(),
                             other_msg=f"Import from file into table {sq_name}, line {{{line}}}",
-                        )
+                        ) from e
                     total_rows += len(b)
                     interval = _state.conf.import_progress_interval
                     if _state.exec_log and interval > 0 and total_rows % interval == 0: