execsql2 2.32.0__py3-none-any.whl → 2.34.0__py3-none-any.whl

execsql/db/base.py

@@ -24,7 +24,9 @@ from collections.abc import Callable, Generator, Iterator
 
 from execsql.exceptions import ErrInfo
 from execsql.utils.errors import exception_desc
+from execsql.db.target_types import ColumnKinds, existing_table_converter, kind_for_python_type
 from execsql.db.tiers import SupportTier, announce_tier
+from execsql.types import DataType
 import execsql.state as _state
 
 __all__ = ["Database", "DatabasePool"]
@@ -604,6 +606,42 @@ class Database(ABC):
             rows = curs.fetchall()
         return [row[0] for row in rows]
 
+    def column_kinds(self, sq_name: str) -> ColumnKinds:
+        """The execsql data type each column of table *sq_name* converts values to (see ``db.target_types``).
+
+        *sq_name* is schema-qualified and quoted, as for an ``INSERT``, and
+        is looked up the way the ``INSERT`` finds it.  Keys are lower-cased
+        column names; a column with no fitting execsql type maps to ``None``.
+        This default reads the driver's description of an empty query on the
+        table; adapters whose catalog names types more exactly override it.
+        """
+        description, _rows = self._column_type_query(sq_name, f"select * from {sq_name} where 1=0;")
+        return {d[0].lower(): self._described_kind(d) for d in description}
+
+    def _described_kind(self, description: Any) -> type[DataType] | None:
+        """The execsql type for one column of a cursor description (a DB-API 7-item sequence)."""
+        return kind_for_python_type(description[1], description[5])
+
+    def _column_type_query(self, sq_name: str, sql: str, params: list | None = None) -> tuple[Any, list]:
+        """Run *sql* for :meth:`column_kinds` of *sq_name*; return the cursor description and the rows."""
+        with self._cursor() as curs:
+            try:
+                if params is None:
+                    curs.execute(sql)
+                else:
+                    curs.execute(sql, params)
+            except ErrInfo:
+                raise
+            except Exception as e:
+                self.rollback()
+                raise ErrInfo(
+                    type="db",
+                    command_text=sql,
+                    exception_msg=exception_desc(),
+                    other_msg=f"Failed to get the column types of table {sq_name} of {self.name()}",
+                ) from e
+            return curs.description, curs.fetchall()
+
     def view_exists(self, view_name: str, schema_name: str | None = None) -> bool:
         """Return ``True`` if *view_name* (optionally in *schema_name*) exists."""
         with self._cursor() as curs:
@@ -689,11 +727,17 @@ class Database(ABC):
         rowsource: Any,
         column_list: list[str],
         tablespec_src: Callable,
+        *,
+        existing_table: bool = False,
     ) -> None:
         """Bulk-insert rows from *rowsource* into *table_name* using the columns in *column_list*.
 
         *rowsource* must be a generator yielding lists of values in column order.
         *tablespec_src* is a zero-argument callable that returns the table's type specification.
+        Each value is converted to the type scanned for its column; with
+        *existing_table* (the table was there before the IMPORT or COPY), the
+        type of the column it goes into decides instead (see
+        ``db.target_types.existing_table_converter``).
         """
         # The rowsource argument must be a generator yielding a list of values for the columns of the table.
         # The column_list argument must an iterable containing column names.  This may be a subset of
@@ -713,8 +757,13 @@ class Database(ABC):
         sel_cols = [col for col in ts_colnames if col in column_list]
         incl_col = [col in column_list for col in ts_colnames]
         # Type conversion functions for the rowsource.
-        type_objs = [col.column_type()[1]() for col in tablespec.cols]
-        type_mod_fn = [self.type.dialect[col.column_type()[1]][3] for col in tablespec.cols]
+        converters = [self._scanned_type_converter(col.column_type()[1]) for col in tablespec.cols]
+        if existing_table:
+            kinds = self.column_kinds(sq_name)
+            converters = [
+                existing_table_converter(kinds.get(col.name.lower()), col.column_type()[1], convert, col.name, sq_name)
+                for col, convert in zip(tablespec.cols, converters)
+            ]
         # Construct INSERT statement.
         columns = [self.type.quoted(col) for col in sel_cols]
         colspec = ",".join(columns)
@@ -812,10 +861,7 @@ class Database(ABC):
                                             line[i] = None
                             # Trailing values left off the line are NULL.
                             line = list(line) + [None] * (len(ts_colnames) - len(line))
-                            lt = [
-                                type_objs[i].from_data(val) if val is not None else None for i, val in enumerate(line)
-                            ]
-                            lt = [type_mod_fn[i](v) if type_mod_fn[i] else v for i, v in enumerate(lt)]
+                            lt = [converters[i](val) for i, val in enumerate(line)]
                             row = []
                             for i, v in enumerate(lt):
                                 if incl_col[i]:
@@ -869,14 +915,31 @@ class Database(ABC):
                 f"IMPORT into {sq_name} complete: {total_rows} rows imported.",
             )
 
+    def _scanned_type_converter(self, data_type: type[DataType]) -> Callable[[Any], Any]:
+        """Convert a value to *data_type*, then apply this DBMS's adjustment for that type, if any.
+
+        NULL is not converted, but it is adjusted: MySQL's adjustment for
+        dates turns it into ``""``.
+        """
+        from_data = data_type().from_data
+        adjust = self.type.dialect[data_type][3]
+        if adjust is None:
+            return lambda value: None if value is None else from_data(value)
+        return lambda value: adjust(None if value is None else from_data(value))
+
     def import_tabular_file(
         self,
         schema_name: str | None,
         table_name: str,
         csv_file_obj: Any,
         skipheader: bool,
+        *,
+        existing_table: bool = False,
     ) -> None:
-        """Import a CSV/tabular file into *table_name*; column names must be compatible."""
+        """Import a CSV/tabular file into *table_name*; column names must be compatible.
+
+        *existing_table*: the table was there before the IMPORT (see :meth:`populate_table`).
+        """
         # Import a text (CSV) file containing tabular data to a table.  Columns must be compatible.
         if not self.table_exists(table_name, schema_name):
             raise ErrInfo(
@@ -912,7 +975,7 @@ class Database(ABC):
 
         f = csv_file_obj.reader()
         next(f)
-        self.populate_table(schema_name, table_name, f, import_cols, get_ts)
+        self.populate_table(schema_name, table_name, f, import_cols, get_ts, existing_table=existing_table)
 
     def import_entire_file(
         self,

execsql/db/duckdb.py

@@ -18,6 +18,8 @@ from pathlib import Path
 from typing import Any
 
 from execsql.db.base import Database, statement_start
+from execsql.db.target_types import kind_for_type_name
+from execsql.types import DataType
 from execsql.exceptions import ErrInfo
 from execsql.utils.errors import exception_desc, fatal_error, install_hint
 import execsql.state as _state
@@ -320,6 +322,10 @@ class DuckDBDatabase(Database):
 
         return insert
 
+    def _described_kind(self, description: Any) -> type[DataType] | None:
+        """DuckDB describes a column by its type's name (``DECIMAL(18,3)``, ``TIMESTAMP WITH TIME ZONE``)."""
+        return kind_for_type_name(str(description[1]))
+
     def view_exists(self, view_name: str, schema_name: str | None = None) -> bool:
         """Return True if the named view exists in the DuckDB database."""
         # DuckDB information_schema has no 'views' table; views are listed in 'tables'

execsql/db/mysql.py

@@ -13,6 +13,7 @@ import tempfile
 from typing import Any, cast
 
 from execsql.db.base import Database
+from execsql.db.target_types import ColumnKinds, kind_for_type_name
 from execsql.exceptions import ErrInfo
 from execsql.utils.errors import exception_desc, fatal_error, install_hint
 from execsql.utils.auth import (
@@ -41,6 +42,11 @@ _PYTHON_TO_MYSQL_CHARSET: dict[str, str] = {
 }
 
 
+def _text(value: Any) -> str:
+    """A catalog value as text: some MySQL versions return ``SHOW COLUMNS`` types as bytes."""
+    return value.decode() if isinstance(value, (bytes, bytearray)) else str(value)
+
+
 def _crlf_terminated(filename: str) -> bool:
     """True if the file's first line ends with CRLF.
 
@@ -239,6 +245,11 @@ class MySQLDatabase(Database):
             self._fold_identifier(schema_name) if schema_name is not None else None,
         )
 
+    def column_kinds(self, sq_name: str) -> ColumnKinds:
+        """The execsql type of each column of *sq_name*, from ``SHOW COLUMNS`` (which tells BOOLEAN from TINYINT)."""
+        _description, rows = self._column_type_query(sq_name, f"show columns from {sq_name};")
+        return {str(row[0]).lower(): kind_for_type_name(_text(row[1])) for row in rows}
+
     def view_exists(self, view_name: str, schema_name: str | None = None) -> bool:
         return super().view_exists(
             self._fold_identifier(view_name),
@@ -305,7 +316,11 @@ class MySQLDatabase(Database):
                     )
                     self.conn = db_conn()
                 remember_password("MySQL", self.db_name, self.user, self.server_name, port=self.port)
-                self.execute("set session sql_mode='ANSI';")
+                # A fixed mode, not the server's: quote_literal relies on
+                # backslash escapes being on (no NO_BACKSLASH_ESCAPES).
+                # STRICT_TRANS_TABLES makes a value MySQL can't store as
+                # given an error instead of a clamped or truncated one (#101).
+                self.execute("set session sql_mode='ANSI,STRICT_TRANS_TABLES';")
             except SystemExit:
                 # If the user canceled the password prompt.
                 raise
@@ -343,14 +358,50 @@ class MySQLDatabase(Database):
             rows = curs.fetchall()
         return len(rows) > 0
 
+    def _fail_on_load_warnings(self, file_name: str, sq_name: str) -> None:
+        """Roll back and raise if the LOAD DATA just run changed any value while the session is in strict mode.
+
+        ``LOAD DATA LOCAL`` ignores strict mode: a value MySQL cannot store as
+        given is clamped or zeroed with a warning, not rejected (#101).  This
+        makes the load fail as the same rows inserted one by one would.  Notes
+        (a decimal rounded to the column's scale) are not warnings and pass, as
+        they do for an ``INSERT``.  A script that turned strict mode off
+        (``SET SESSION sql_mode = 'ANSI'``) keeps MySQL's changed values.
+        """
+        with self._cursor() as curs:
+            curs.execute("show warnings;")
+            warnings = curs.fetchall()
+            curs.execute("select @@session.sql_mode;")
+            mode = _text(curs.fetchone()[0]).upper()
+        if "STRICT_TRANS_TABLES" not in mode and "STRICT_ALL_TABLES" not in mode:
+            return
+        problems = [_text(row[2]) for row in warnings if _text(row[0]) in ("Warning", "Error")]
+        if not problems:
+            return
+        self.rollback()
+        shown = "; ".join(problems[:3])
+        more = f" (and {len(problems) - 3} more)" if len(problems) > 3 else ""
+        raise ErrInfo(
+            type="error",
+            other_msg=(
+                f"Can't import {file_name} into {sq_name}: MySQL would have stored changed values: {shown}{more}. "
+                "Nothing was loaded."
+            ),
+        )
+
     def import_tabular_file(
         self,
         schema_name: str | None,
         table_name: str,
         csv_file_obj: Any,
         skipheader: bool,
+        *,
+        existing_table: bool = False,
     ) -> None:
-        """Import a delimited file into a MySQL table."""
+        """Import a delimited file into a MySQL table.
+
+        The file's values go to the server as text, unconverted, so *existing_table* changes nothing here.
+        """
         # 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):
@@ -436,6 +487,7 @@ class MySQLDatabase(Database):
                 )
             try:
                 self.execute(import_sql)
+                self._fail_on_load_warnings(csv_file_obj.csvfname, sq_name)
             finally:
                 if load_file != csv_file_obj.csvfname:
                     os.unlink(load_file)

execsql/db/oracle.py

@@ -12,6 +12,8 @@ import re
 from typing import Any
 
 from execsql.db.base import Database
+from execsql.db.target_types import kind_for_type_name
+from execsql.types import DataType
 from execsql.db.tiers import SupportTier
 from execsql.exceptions import ErrInfo
 from execsql.utils.errors import exception_desc, fatal_error, install_hint
@@ -49,6 +51,29 @@ def _oracle_driver() -> Any:
         return None
 
 
+# oracledb DbType names -> the type names db.target_types reads.  NUMBER is
+# read from its precision and scale; a type not listed has no execsql type.
+_ORACLE_TYPE_NAMES = {
+    "DB_TYPE_VARCHAR": "varchar2",
+    "DB_TYPE_NVARCHAR": "nvarchar2",
+    "DB_TYPE_CHAR": "char",
+    "DB_TYPE_NCHAR": "nchar",
+    "DB_TYPE_LONG": "clob",
+    "DB_TYPE_CLOB": "clob",
+    "DB_TYPE_NCLOB": "nclob",
+    "DB_TYPE_BINARY_FLOAT": "binary_float",
+    "DB_TYPE_BINARY_DOUBLE": "binary_double",
+    "DB_TYPE_BOOLEAN": "boolean",
+    "DB_TYPE_DATE": "date",
+    "DB_TYPE_TIMESTAMP": "timestamp",
+    "DB_TYPE_TIMESTAMP_TZ": "timestamp with time zone",
+    "DB_TYPE_TIMESTAMP_LTZ": "timestamp with local time zone",
+    "DB_TYPE_RAW": "raw",
+    "DB_TYPE_LONG_RAW": "long raw",
+    "DB_TYPE_BLOB": "blob",
+}
+
+
 class OracleDatabase(Database):
     """Oracle adapter using the python-oracledb driver."""
 
@@ -268,6 +293,17 @@ class OracleDatabase(Database):
             rows = curs.fetchall()
         return [row[0] for row in rows]
 
+    def _described_kind(self, description: Any) -> type[DataType] | None:
+        """oracledb describes a column by a ``DbType`` (``DB_TYPE_NUMBER``), with its precision and scale."""
+        name = getattr(description[1], "name", "")
+        if name == "DB_TYPE_NUMBER":
+            precision, scale = description[4], description[5]
+            # NUMBER with no precision, and FLOAT, report scale -127.
+            type_name = f"number({precision},{scale})" if precision and scale is not None and scale >= 0 else "number"
+        else:
+            type_name = _ORACLE_TYPE_NAMES.get(name, "")
+        return kind_for_type_name(type_name, oracle=True)
+
     def view_exists(self, view_name: str, schema_name: str | None = None) -> bool:
         """Return True if the named view exists in the Oracle database."""
         # Oracle folds unquoted identifiers to uppercase.

execsql/db/postgres.py

@@ -14,6 +14,7 @@ import re
 from typing import Any
 
 from execsql.db.base import Database
+from execsql.db.target_types import ColumnKinds, kind_for_type_name
 from execsql.exceptions import ErrInfo
 from execsql.utils.errors import exception_desc, fatal_error, install_hint
 from execsql.utils.auth import (
@@ -224,6 +225,16 @@ class PostgresDatabase(Database):
             rows = curs.fetchall()
         return len(rows) > 0
 
+    def column_kinds(self, sq_name: str) -> ColumnKinds:
+        """The execsql type of each column of *sq_name*, from the catalog (``regclass`` follows the search path)."""
+        _description, rows = self._column_type_query(
+            sq_name,
+            "select attname, format_type(atttypid, atttypmod) from pg_attribute "
+            "where attrelid = %s::regclass and attnum > 0 and not attisdropped order by attnum;",
+            [sq_name],
+        )
+        return {name.lower(): kind_for_type_name(type_name) for name, type_name in rows}
+
     def view_exists(self, view_name: str, schema_name: str | None = None) -> bool:
         """Return True if the named view exists in the PostgreSQL database."""
         if schema_name is not None:
@@ -279,8 +290,13 @@ class PostgresDatabase(Database):
         table_name: str,
         csv_file_obj: Any,
         skipheader: bool,
+        *,
+        existing_table: bool = False,
     ) -> None:
-        """Import a delimited file into a PostgreSQL table, using COPY when possible."""
+        """Import a delimited file into a PostgreSQL table, using COPY when possible.
+
+        The file's values go to the server as text, unconverted, so *existing_table* changes nothing here.
+        """
         # 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/sqlite.py

@@ -182,8 +182,14 @@ class SQLiteDatabase(Database):
         rowsource: Any,
         column_list: list[str],
         tablespec_src: Any,
+        *,
+        existing_table: bool = False,
     ) -> None:
-        """Populate a SQLite table from a row source generator."""
+        """Populate a SQLite table from a row source generator.
+
+        Values are inserted as the source gives them (dates, times and
+        decimals as text), so *existing_table* changes nothing here.
+        """
         # The rowsource argument must be a generator yielding a list of values for the columns of the table.
         # The column_list argument must an iterable containing column names in the same order as produced by the rowsource.
         sq_name = self.schema_qualified_table_name(None, table_name)

execsql/db/sqlserver.py

@@ -8,6 +8,7 @@ Server via ``pyodbc``.  Corresponds to ``-t s`` on the CLI.
 """
 
 from execsql.db.base import Database
+from execsql.db.target_types import ColumnKinds, kind_for_type_name
 from execsql.db.odbc import connection_string, fresh_sessions, loggable
 from execsql.exceptions import ErrInfo
 from execsql.utils.errors import fatal_error, install_hint
@@ -228,6 +229,29 @@ class SqlServerDatabase(Database):
             rows = curs.fetchall()
         return len(rows) > 0
 
+    def column_kinds(self, sq_name: str) -> ColumnKinds:
+        """The execsql type of each column of *sq_name*, from ``sys.columns``.
+
+        pyodbc describes ``datetimeoffset`` and ``varbinary`` alike, so the
+        catalog is read instead.  A table it does not find through
+        ``object_id`` (a ``#temp`` table, which lives in tempdb) falls back
+        to the driver's description.
+        """
+        _description, rows = self._column_type_query(
+            sq_name,
+            "select c.name, type_name(c.system_type_id), c.precision, c.scale from sys.columns c "
+            "where c.object_id = object_id(?) order by c.column_id;",
+            [sq_name],
+        )
+        if not rows:
+            return super().column_kinds(sq_name)
+        return {
+            name.lower(): kind_for_type_name(
+                f"{type_name}({precision},{scale})" if type_name in ("decimal", "numeric") else type_name,
+            )
+            for name, type_name, precision, scale in rows
+        }
+
     def drop_table(self, tablename: str) -> None:
         """Drop *tablename*, schema-qualified and quoted by the caller."""
         # SQL Server and Firebird will throw an error if there are foreign keys to the table.

execsql/db/target_types.py

@@ -0,0 +1,277 @@
+"""The execsql data type of each column of a table that IMPORT or COPY loads.
+
+A load into a table that already exists converts each value by the type of
+the column it goes into, not by the type scanned from the source data
+(issue #100).  The adapters report each column's type: by the name their
+catalog gives it (PostgreSQL, MySQL, SQL Server, DuckDB, Oracle), or by the
+Python type their driver describes it with (Access, Firebird, ODBC DSNs).
+The functions here turn that
+into one of execsql's data types, or ``None`` when execsql has no
+conversion that fits (arrays, JSON, UUIDs, enums, geometry, intervals, …).
+
+Only the types that change how a value is converted are told apart: every
+character type is :class:`DT_Text`, every integer type :class:`DT_Long`,
+and so on.  A ``DECIMAL``/``NUMERIC``/``NUMBER`` with scale 0 holds whole
+numbers only, so it is :class:`DT_Long` too.
+"""
+
+from __future__ import annotations
+
+import datetime
+import math
+import re
+from collections.abc import Callable
+from decimal import Decimal
+from typing import Any, TypeAlias
+
+from execsql.exceptions import ErrInfo
+from execsql.types import (
+    DataType,
+    DT_Binary,
+    DT_Boolean,
+    DT_Date,
+    DT_Decimal,
+    DT_Float,
+    DT_Long,
+    DT_Text,
+    DT_Time,
+    DT_Timestamp,
+    DT_TimestampTZ,
+)
+
+__all__ = ["ColumnKinds", "existing_table_converter", "kind_for_python_type", "kind_for_type_name"]
+
+#: Lower-cased column name -> the execsql type values for it convert to, or None.
+#: A string, not ``dict[...]``: on Python 3.10 that object passes
+#: ``isinstance(x, type)``, so code that scans the adapter modules for classes
+#: would take it for one.
+ColumnKinds: TypeAlias = "dict[str, type[DataType] | None]"
+
+_TEXT = {
+    "char",
+    "character",
+    "varchar",
+    "character varying",
+    "varchar2",
+    "nchar",
+    "national character",
+    "nvarchar",
+    "nvarchar2",
+    "national character varying",
+    "bpchar",
+    "text",
+    "ntext",
+    "tinytext",
+    "mediumtext",
+    "longtext",
+    "string",
+    "clob",
+    "nclob",
+}
+_INTEGER = {
+    "integer",
+    "int",
+    "int1",
+    "int2",
+    "int4",
+    "int8",
+    "tinyint",
+    "smallint",
+    "mediumint",
+    "bigint",
+    "hugeint",
+    "utinyint",
+    "usmallint",
+    "uinteger",
+    "ubigint",
+    "uhugeint",
+    "serial",
+    "smallserial",
+    "bigserial",
+}
+_DECIMAL = {"decimal", "numeric", "number", "money", "smallmoney"}
+_FLOAT = {"float", "float4", "float8", "real", "double", "double precision", "binary_float", "binary_double"}
+_BOOLEAN = {"boolean", "bool"}
+_TIMESTAMP = {
+    "timestamp",
+    "timestamp without time zone",
+    "datetime",
+    "datetime2",
+    "smalldatetime",
+    "timestamp_s",
+    "timestamp_ms",
+    "timestamp_ns",
+}
+_TIMESTAMPTZ = {"timestamptz", "timestamp with time zone", "timestamp with local time zone", "datetimeoffset"}
+_TIME = {"time", "time without time zone"}
+_BINARY = {
+    "bytea",
+    "blob",
+    "tinyblob",
+    "mediumblob",
+    "longblob",
+    "binary",
+    "varbinary",
+    "binary varying",
+    "image",
+    "raw",
+    "long raw",
+}
+
+_PARAMS = re.compile(r"\(([^)]*)\)")
+
+
+def kind_for_type_name(type_name: str, *, oracle: bool = False) -> type[DataType] | None:
+    """The execsql type for a column declared as *type_name* (as the DBMS's catalog spells it).
+
+    *oracle*: Oracle's ``DATE`` holds a time of day too, so it is a timestamp there.
+    """
+    name = type_name.strip().lower()
+    if not name or "[" in name or name.endswith(" array"):
+        return None
+    params = _PARAMS.search(name)
+    args = [a.strip() for a in params.group(1).split(",")] if params else []
+    base = " ".join(_PARAMS.sub(" ", name).replace(" unsigned", " ").replace(" zerofill", " ").split())
+    if base == "tinyint" and args == ["1"]:
+        return DT_Boolean  # MySQL's BOOLEAN
+    if base == "bit":
+        # SQL Server's BIT; a wider BIT(n) is a bit string.
+        return DT_Boolean if args in ([], ["1"]) else None
+    if base in _TEXT:
+        return DT_Text
+    if base in _INTEGER:
+        return DT_Long
+    if base in _DECIMAL:
+        if args[1:] == ["0"] or len(args) == 1:
+            return DT_Long  # DECIMAL(p,0), NUMERIC(p), NUMBER(p): whole numbers
+        return DT_Decimal
+    if base in _FLOAT:
+        return DT_Float
+    if base in _BOOLEAN:
+        return DT_Boolean
+    if base == "date":
+        return DT_Timestamp if oracle else DT_Date
+    if base in _TIMESTAMP:
+        return DT_Timestamp
+    if base in _TIMESTAMPTZ:
+        return DT_TimestampTZ
+    if base in _TIME:
+        return DT_Time
+    if base in _BINARY:
+        return DT_Binary
+    return None
+
+
+def kind_for_python_type(type_code: object, scale: object = None) -> type[DataType] | None:
+    """The execsql type for a column a driver describes by the Python type it returns (pyodbc, firebird-driver).
+
+    Binary columns are left out: pyodbc describes a SQL Server
+    ``datetimeoffset`` as ``bytearray`` too.
+    """
+    if type_code is bool:
+        return DT_Boolean
+    if type_code is int:
+        return DT_Long
+    if type_code is float:
+        return DT_Float
+    if type_code is Decimal:
+        return DT_Long if scale == 0 else DT_Decimal
+    if type_code is str:
+        return DT_Text
+    if type_code is datetime.datetime:
+        return DT_Timestamp
+    if type_code is datetime.date:
+        return DT_Date
+    if type_code is datetime.time:
+        return DT_Time
+    return None
+
+
+# ---------------------------------------------------------------------------
+# Converting a value for the column it goes into
+# ---------------------------------------------------------------------------
+
+_INTEGER_TEXT = re.compile(r"^\s*[+-]?[0-9]+\s*$")
+_NUMBER_TEXT = re.compile(r"^\s*[+-]?(?:[0-9]+\.?[0-9]*|\.[0-9]+)(?:[eE][+-]?[0-9]+)?\s*$")
+# A whole number longer than this fits no integer column; it goes to the
+# database as given, which rejects it, instead of being expanded here.
+_MAX_INTEGER_DIGITS = 40
+
+Converter = Callable[[Any], Any]
+
+
+def _as_given(value: Any) -> Any:
+    return value
+
+
+def _whole_number_converter(column: str, table: str, default: Converter) -> Converter:
+    """Convert a value for integer column *column*: a fraction is an error, never rounded.
+
+    A value that is not a number (NULL, a date, a word) gets *default*, the
+    conversion it had before, and the database takes or rejects that.
+    """
+
+    def convert(value: Any) -> Any:
+        if isinstance(value, bool):
+            return default(value)
+        if isinstance(value, int):
+            return value
+        if isinstance(value, str):
+            if _INTEGER_TEXT.match(value):
+                return int(value)
+            if not _NUMBER_TEXT.match(value):
+                return default(value)
+            number = Decimal(value)
+        elif isinstance(value, Decimal):
+            number = value
+        elif isinstance(value, float):
+            if not math.isfinite(value):
+                return default(value)
+            number = Decimal(value)
+        else:
+            return default(value)
+        if not number.is_finite() or number.adjusted() >= _MAX_INTEGER_DIGITS:
+            return default(value)
+        if number == number.to_integral_value():
+            return int(number)
+        raise ErrInfo(
+            type="error",
+            other_msg=(
+                f"Can't load {value!r} into column {column} of {table}: the column holds whole numbers, "
+                "and the database would round the value."
+            ),
+        )
+
+    return convert
+
+
+def _true_false_as_number(default: Converter) -> Converter:
+    """Convert a value scanned as true/false for a number column: 1 or 0, read as before (``yes`` is 1)."""
+
+    def convert(value: Any) -> Any:
+        flag = default(value)
+        return int(flag) if isinstance(flag, bool) else flag
+
+    return convert
+
+
+def existing_table_converter(
+    kind: type[DataType] | None,
+    scanned: type[DataType],
+    default: Converter,
+    column: str,
+    table: str,
+) -> Converter:
+    """How a value for *column* of existing table *table* is converted.
+
+    *kind* is the column's type (``None`` if execsql has none that fits),
+    *scanned* the type the source column scanned as, and *default* the
+    conversion to that scanned type, which a new table's values get.
+    """
+    if kind is DT_Text:
+        return _as_given
+    if kind in (DT_Long, DT_Decimal, DT_Float) and scanned is DT_Boolean:
+        return _true_false_as_number(default)
+    if kind is DT_Long:
+        return _whole_number_converter(column, table, default)
+    return default

execsql/exporters/json.py

@@ -3,9 +3,11 @@ from __future__ import annotations
 """
 JSON export for execsql.
 
-Provides :func:`write_query_to_json` (standard JSON array of objects) and
-:func:`write_query_to_json_ts` (JSON with a top-level timestamp wrapper),
-both of which serialize a query result set to a file or stream.
+Provides :func:`write_query_to_json` (standard JSON array of objects),
+:func:`write_query_to_jsonl` (`JSON Lines <https://jsonlines.org/>`_, one
+object per line) and :func:`write_query_to_json_ts` (JSON with a top-level
+timestamp wrapper), all of which serialize a query result set to a file or
+stream.
 """
 
 import json
@@ -18,7 +20,13 @@ from execsql.models import DataTable, to_json_type
 from execsql.utils.errors import exception_desc
 from execsql.utils.fileio import filewriter_close
 
-__all__ = ["write_query_to_json", "write_query_to_json_ts"]
+__all__ = ["write_query_to_json", "write_query_to_json_ts", "write_query_to_jsonl"]
+
+
+def _row_json(hdrs: list[str], row: Any) -> str:
+    """One row as a compact JSON object; JSON and JSONL write rows alike."""
+    dictdata = dict(zip(hdrs, [str(v) if isinstance(v, str) else v for v in row]))
+    return json.dumps(dictdata, separators=(",", ":"), default=str)
 
 
 def write_query_to_json(
@@ -60,14 +68,50 @@ def write_query_to_json(
             else:
                 f.write(",\n")
             first = False
-            dictdata = dict(zip(uhdrs, [str(v) if isinstance(v, str) else v for v in row]))
-            jsondata = json.dumps(dictdata, separators=(",", ":"), default=str)
-            f.write(str(jsondata))
+            f.write(_row_json(uhdrs, row))
         f.write("\n]\n")
     finally:
         f.close()
 
 
+def write_query_to_jsonl(
+    select_stmt: str,
+    db: Any,
+    outfile: str,
+    append: bool = False,
+    desc: str | None = None,
+    zipfile: str | None = None,
+) -> None:
+    """Execute a SELECT and write the result set as JSON Lines: one JSON object per row, one row per line.
+
+    Values are written as :func:`write_query_to_json` writes them.  A line
+    break inside a value is escaped (``\\n``), so each row stays on one line.
+    With *append* the rows are added to the end of the file, which stays
+    valid JSON Lines.
+    """
+    conf = _state.conf
+    try:
+        hdrs, rows = db.select_rowsource(select_stmt)
+    except ErrInfo:
+        raise
+    except Exception as e:
+        raise ErrInfo("db", select_stmt, exception_msg=exception_desc()) from e
+    f: Any
+    if zipfile is None:
+        filewriter_close(outfile)
+        from execsql.utils.fileio import EncodedFile
+
+        f = EncodedFile(outfile, conf.output_encoding).open("at" if append else "wt")
+    else:
+        f = ZipWriter(zipfile, outfile, append)
+    try:
+        uhdrs = [str(h) for h in hdrs]
+        for row in rows:
+            f.write(_row_json(uhdrs, row) + "\n")
+    finally:
+        f.close()
+
+
 def write_query_to_json_ts(
     select_stmt: str,
     db: Any,

execsql/exporters/protocol.py

@@ -51,6 +51,7 @@ class QueryExporter(Protocol):
     Conforming functions
     --------------------
     - ``write_query_to_json``
+    - ``write_query_to_jsonl``
     - ``write_query_to_html``
     - ``write_query_to_cgi_html``
     - ``write_query_to_latex``

execsql/importers/base.py

@@ -142,7 +142,7 @@ def import_data_table(
             )
         import_cols = hdrs
     try:
-        db.populate_table(schemaname, tablename, data, import_cols, get_ts)
+        db.populate_table(schemaname, tablename, data, import_cols, get_ts, existing_table=not is_new)
         db.commit()
     except ErrInfo:
         raise

execsql/importers/csv.py

@@ -91,7 +91,7 @@ def importtable(
                     other_msg=f"Non-existent table name ({tablename}) used with the IMPORT_FILE metacommand",
                 )
     try:
-        db.import_tabular_file(schemaname, tablename, inf, skipheader=True)
+        db.import_tabular_file(schemaname, tablename, inf, skipheader=True, existing_table=not is_new)
         db.commit()
     except ErrInfo:
         raise

execsql/metacommands/__init__.py

@@ -474,13 +474,29 @@ JSON_VARIANT_FORMATS = ["JSON_TS", "JSON_TABLESCHEMA"]
 QUERY_EXPORT_FORMATS = (
     DELIMITED_FORMATS
     + TEXT_FORMATS
-    + ["ODS", "XLSX", "JSON", "HTML", "CGI-HTML", "VALUES", "LATEX", "RAW", "B64", "FEATHER", "YAML", "MARKDOWN", "MD"]
+    + [
+        "ODS",
+        "XLSX",
+        "JSON",
+        "JSONL",
+        "HTML",
+        "CGI-HTML",
+        "VALUES",
+        "LATEX",
+        "RAW",
+        "B64",
+        "FEATHER",
+        "YAML",
+        "MARKDOWN",
+        "MD",
+    ]
 )
 TABLE_EXPORT_FORMATS = (
     DELIMITED_FORMATS
     + TEXT_FORMATS
     + [
         "JSON",
+        "JSONL",
         "XML",
         "VALUES",
         "HTML",

execsql/metacommands/io_export.py

@@ -27,7 +27,7 @@ from execsql.exporters.delimited import write_delimited_file
 from execsql.exporters.duckdb import write_query_to_duckdb
 from execsql.exporters.feather import write_query_to_feather, write_query_to_hdf5
 from execsql.exporters.html import write_query_to_cgi_html, write_query_to_html
-from execsql.exporters.json import write_query_to_json, write_query_to_json_ts
+from execsql.exporters.json import write_query_to_json, write_query_to_json_ts, write_query_to_jsonl
 from execsql.exporters.latex import write_query_to_latex
 from execsql.exporters.ods import write_queries_to_ods, write_query_to_ods
 from execsql.exporters.xlsx import write_queries_to_xlsx, write_query_to_xlsx
@@ -123,6 +123,8 @@ def _dispatch_format(
         write_query_to_xml(select_stmt, xml_table, db, outfile, append, desc=description, zipfile=zipfilename)
     elif filefmt == "json":
         write_query_to_json(select_stmt, db, outfile, append, desc=description, zipfile=zipfilename)
+    elif filefmt == "jsonl":
+        write_query_to_jsonl(select_stmt, db, outfile, append, desc=description, zipfile=zipfilename)
     elif filefmt in ("json_ts", "json_tableschema"):
         write_query_to_json_ts(select_stmt, db, outfile, append, not notype, desc=description, zipfile=zipfilename)
     elif filefmt == "values":

execsql/metacommands/io_fileops.py

@@ -158,7 +158,7 @@ def x_copy(**kwargs: Any) -> None:
         return get_ts_tablespec
 
     try:
-        db2.populate_table(schema2, table2, rows_for_insert, hdrs, get_ts)
+        db2.populate_table(schema2, table2, rows_for_insert, hdrs, get_ts, existing_table=not new_tbl2)
         db2.commit()
     except BaseException:
         _close_rowsource(rows_to_close)
@@ -245,7 +245,7 @@ def x_copy_query(**kwargs: Any) -> None:
         return get_ts_tablespec
 
     try:
-        db2.populate_table(schema2, table2, rows_for_insert, hdrs, get_ts)
+        db2.populate_table(schema2, table2, rows_for_insert, hdrs, get_ts, existing_table=not new_tbl2)
         db2.commit()
     except BaseException:
         _close_rowsource(rows_to_close)

execsql/metacommands/reference.py

@@ -1364,6 +1364,16 @@ _SYSTEM_VARIABLES: tuple[SystemVariable, ...] = (
         "TRUE or FALSE: whether the changes were committed.",
         "metacommands.md#pg_upsert",
     ),
+    SystemVariable(
+        "$PG_UPSERT_STATUS",
+        "How the run ended: committed, dry_run, no_changes, qa_failed, cancelled or db_error.",
+        "metacommands.md#pg_upsert",
+    ),
+    SystemVariable(
+        "$PG_UPSERT_ERROR",
+        "The database error message when $PG_UPSERT_STATUS is db_error; otherwise empty.",
+        "metacommands.md#pg_upsert",
+    ),
     SystemVariable("$PG_UPSERT_STAGING_SCHEMA", "Staging schema name used.", "metacommands.md#pg_upsert"),
     SystemVariable("$PG_UPSERT_BASE_SCHEMA", "Base schema name used.", "metacommands.md#pg_upsert"),
     SystemVariable("$PG_UPSERT_TABLES", "Comma-separated list of table names processed.", "metacommands.md#pg_upsert"),

execsql/metacommands/upsert.py

@@ -185,6 +185,11 @@ def _set_subvars(result: Any) -> None:
     sv("$PG_UPSERT_ROWS_UPDATED", str(result.total_updated))
     sv("$PG_UPSERT_ROWS_INSERTED", str(result.total_inserted))
     sv("$PG_UPSERT_COMMITTED", str(result.committed).upper())
+    # How the run ended: committed, dry_run, no_changes, qa_failed, cancelled
+    # or db_error.  Empty for QA and CHECK, which do not run an upsert.
+    status = getattr(result, "status", None)
+    sv("$PG_UPSERT_STATUS", status.value if status is not None else "")
+    sv("$PG_UPSERT_ERROR", getattr(result, "error", None) or "")
     sv("$PG_UPSERT_STAGING_SCHEMA", result.staging_schema)
     sv("$PG_UPSERT_BASE_SCHEMA", result.base_schema)
     sv("$PG_UPSERT_TABLES", ", ".join(t.table_name for t in result.tables))
@@ -426,6 +431,14 @@ def _handle_pg_upsert_errors(fn: Any, metacommandline: str | None) -> Any:
     try:
         return fn()
     except UserCancelledError as exc:
+        # No result describes a run cancelled outside pg-upsert's own run();
+        # say what is known rather than leave an earlier run's values.
+        sv = _state.subvars.add_substitution
+        sv("$PG_UPSERT_STATUS", "cancelled")
+        sv("$PG_UPSERT_ERROR", "")
+        sv("$PG_UPSERT_COMMITTED", "FALSE")
+        sv("$PG_UPSERT_ROWS_UPDATED", "0")
+        sv("$PG_UPSERT_ROWS_INSERTED", "0")
         raise ErrInfo(
             "cmd",
             command_text=metacommandline,

execsql/script/engine.py

@@ -108,6 +108,7 @@ class MetaCommand:
         """Match *cmd_str* against this entry's regex and, if it matches, invoke the handler.
 
         Returns ``(True, return_value)`` on a match, ``(False, None)`` otherwise.
+        Raises :class:`ErrInfo` when the handler fails.
         """
         # Runs the metacommand if the command string matches the regex.
         m = self.rx.match(cmd_str.strip())
@@ -125,13 +126,10 @@ class MetaCommand:
                 er = ErrInfo("cmd", command_text=cmd_str, exception_msg=exception_desc())
                 er.__cause__ = exc
             if er:
-                if _state.status.halt_on_metacommand_err:
-                    from execsql.utils.errors import exit_now
-
-                    exit_now(1, er)
-                if self.set_error_flag:
-                    _state.status.metacommand_error = True
-                    return True, None
+                # The caller records the error ($LAST_ERROR, $ERROR_MESSAGE,
+                # the log, the error history) and halts or carries on.
+                if self.set_error_flag or _state.status.halt_on_metacommand_err:
+                    raise er
             else:
                 if self.set_error_flag:
                     _state.status.metacommand_error = False

execsql/script/executor.py

@@ -350,7 +350,9 @@ def _exec_metacommand(
         if ctx.exec_log is not None:
             ctx.exec_log.log_status_info(f"Metacommand error: {logged_error(e)}")
         if status.halt_on_metacommand_err:
-            raise e
+            exit_now(1, e)
+        if (manifest := _manifest.current()) is not None:
+            manifest.record_metacommand(cmd, source, line_no, metacommandlist)
         status.error_history.append((source, line_no, cmd, e.errmsg()))
         return None
     # No handler matched — truly unknown metacommand

execsql/script/variables.py

@@ -317,6 +317,10 @@ class SubVarSet:
         Uses case-insensitive string search instead of per-variable regex
         compilation to avoid O(N) ``re.compile`` calls on every invocation.
         """
+        # Every token below starts with one of these, so text without them
+        # can't match; skip the scan over every defined variable.
+        if "!!" not in command_str and "!'!" not in command_str and '!"!' not in command_str:
+            return command_str, False
         cmd_lower = command_str.lower()
 
         def _check_nul(name: str, value: str) -> None:

execsql/types.py

@@ -855,8 +855,8 @@ dbt_dsn.name_datatype(DT_Binary, "LONGBINARY")
 
 dbt_mysql = DbType("MySQL")
 dbt_mysql.name_datatype(DT_TimestampTZ, "varchar", True, "char")
-dbt_mysql.name_datatype(DT_Timestamp, "datetime", conv_mod_fn=lambda x: x if x is not None else "")
-dbt_mysql.name_datatype(DT_Date, "date", conv_mod_fn=lambda x: x if x is not None else "")
+dbt_mysql.name_datatype(DT_Timestamp, "datetime")
+dbt_mysql.name_datatype(DT_Date, "date")
 dbt_mysql.name_datatype(DT_Time, "time")
 dbt_mysql.name_datatype(DT_Integer, "integer", False, "signed integer")
 dbt_mysql.name_datatype(DT_Long, "bigint", False, "signed integer")

{execsql2-2.32.0.dist-info → execsql2-2.34.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: execsql2
-Version: 2.32.0
+Version: 2.34.0
 Summary: Runs a SQL script against a PostgreSQL, SQLite, MariaDB/MySQL, DuckDB, Firebird, MS-Access, MS-SQL-Server, or Oracle database, or an ODBC DSN. Provides metacommands to import and export data, copy data between databases, conditionally execute SQL and metacommands, and dynamically alter SQL and metacommands with substitution variables.
 Project-URL: Homepage, https://execsql2.readthedocs.io/en/stable/
 Project-URL: Repository, https://github.com/geocoug/execsql
@@ -318,7 +318,7 @@ See the [full options reference](https://execsql2.readthedocs.io/en/stable/getti
 **Data movement**
 
 - Import data from CSV, TSV, JSON, Excel, OpenDocument, Feather, or Parquet files into a database table.
-- Export query results in 20+ formats including CSV, TSV, JSON, YAML, XML, HTML, Markdown, LaTeX, XLSX, OpenDocument, Feather, Parquet, HDF5, DuckDB, SQLite, plain text, and Jinja2 templates.
+- Export query results in 20+ formats including CSV, TSV, JSON, JSON Lines, YAML, XML, HTML, Markdown, LaTeX, XLSX, OpenDocument, Feather, Parquet, HDF5, DuckDB, SQLite, plain text, and Jinja2 templates.
 - Copy data between databases, including across different DBMS types.
 
 **Script logic**
@@ -441,7 +441,7 @@ execsql format --no-sql --in-place scripts/
 ```yaml
 repos:
   - repo: https://github.com/geocoug/execsql
-    rev: v2.32.0
+    rev: v2.34.0
     hooks:
       - id: execsql-format
       - id: execsql-lint

{execsql2-2.32.0.dist-info → execsql2-2.34.0.dist-info}/RECORD

@@ -13,7 +13,7 @@ execsql/plugins.py,sha256=RykMlIjTyWcnQc9ygjLErS3wdcsZSsG9QTIvg4DwfAI,13626
 execsql/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 execsql/state.py,sha256=rXhxx58dVFjhG58HGOXm3ewloVlvpcaYnW1rij4qjkM,23478
 execsql/state.pyi,sha256=ZDHZ1DPKYu4Qs4bcJT31XNv4GOt6O4s_zH4UHCowovw,4344
-execsql/types.py,sha256=XmLfqjXSxBJamZbz0JPodipXi1YzcN_2MjooPyzJsyY,33819
+execsql/types.py,sha256=HiIhc8wqm9Trt8WYP40VU93uuBSPo1uPP3z-sMsUI1o,33719
 execsql/cli/__init__.py,sha256=FHg2lm2gt4L-XBnlVORn3qWHZ4739Ao-uwBIURfVIjg,2798
 execsql/cli/application.py,sha256=tsSYE8cerJxY6y73GM_Xr1WBwc6A0_al8y969B6lPP8,12542
 execsql/cli/dispatch.py,sha256=deyN2QQYvdzMSqGGa3CSMpaqdLNeMgc5Uke0mUbl764,2704
@@ -35,17 +35,18 @@ execsql/data/execsql.conf.template,sha256=Mz8wZxu0U2bfL-fsDpRHvdLkwNpfuZrl4QUMjp
 execsql/data/script_header.sql,sha256=a7WKScekNgJoxVEmMRTkWv8NsAzW1jJ4vJfGy9HVy0g,349
 execsql/db/__init__.py,sha256=jTbuafuKOqYtXFR1wvCOoKK5Lr3l1uErfaIbIr6UywI,1063
 execsql/db/access.py,sha256=fxiC3rtoOJzrNXNxau-w7oh1fd9tyh2_PMliBbFc164,21427
-execsql/db/base.py,sha256=WdF1X0xG01ZKaYNkxcyUSKJCV04cceThPkvERlN-iu0,44619
+execsql/db/base.py,sha256=nMaODzV2_JqJzXJCshlWRQ9ZANPGK6IcIJ4_PBtXyT0,47714
 execsql/db/dsn.py,sha256=Evrc6MUllJVFDn0jZB_iks-aKCsXuNF9XYjAkttqgGQ,6995
-execsql/db/duckdb.py,sha256=6vD5b_tpvfByoFEajZNY5HLzVUnH1eOuPpzNGAKFsIQ,13624
+execsql/db/duckdb.py,sha256=c8VdZcmZdmyH8abrxM8mUk0BGIbittp-oV6UK7lsbgg,13954
 execsql/db/factory.py,sha256=Uz7Xcbff6ZZbtLM55FhHCwGdo4KKfqU_1kyjvOHn-HY,5691
 execsql/db/firebird.py,sha256=CoNnzFtOFAkp8OJByXXXclitCPAAjM23eFJGfy3C7IE,10171
-execsql/db/mysql.py,sha256=FVId78NifBmNfEI8zmqjRMJ3FUy7hskv411LqABAAOQ,24198
+execsql/db/mysql.py,sha256=X-brnIFiQaOwVbY0uqPrC4esclhBv4sg-gHW3EVxHNw,26923
 execsql/db/odbc.py,sha256=l03UNHi8sFtjHbgOKUNA2teKOisNk-8laQGCsHZs2eo,2526
-execsql/db/oracle.py,sha256=i5qPahsy_z1AuZT7l54Hzixknkvbzd-SCQgiVcTN94w,13796
-execsql/db/postgres.py,sha256=sX2azdSt9N6jm_I47Zg8fukdYExGHRq_7XwVRZcfgAo,23647
-execsql/db/sqlite.py,sha256=fEpNPkfJGnqm1Wx_rZK5SEqaWsBqLy85Jxk_5NsnqgM,12109
-execsql/db/sqlserver.py,sha256=6-wySx9BrSTAyXl5BnBLjRYEpl4_GubDjiGuvpehgco,10528
+execsql/db/oracle.py,sha256=lUqdqzNOdNCkJCwbv9yHgaupeBuayZYsyoIDw76xrh4,15333
+execsql/db/postgres.py,sha256=V3ldh51OIxuKkEAQz8k0TrzczbOFqoGMCSXlX3gH1-4,24433
+execsql/db/sqlite.py,sha256=YTfESfdWdny4hIV23fjJbzFuEchq2IFAmQhRynweJL0,12308
+execsql/db/sqlserver.py,sha256=WIVvTp1MNKaUZn912U7ErcjSqhaLTqnZ2hfv_Gcso74,11601
+execsql/db/target_types.py,sha256=68nSyYY0mj6sgS26zeOYcFuUJA_ik08-0BeNsSM7UrE,8563
 execsql/db/tiers.py,sha256=PH2sUYwlYqcANGVKXprWQKVIlM6fpWU9q74djn8oFwc,2924
 execsql/debug/__init__.py,sha256=j6EGUR0dHzUhWN1mHHtf1-Lhjq3Sb1V-vmnq2Ztgj1M,178
 execsql/debug/repl.py,sha256=jnwrqRac4krc1pES7Ni-j1Dyw3mJIcWl5LQQIX1GkRw,20753
@@ -55,13 +56,13 @@ execsql/exporters/delimited.py,sha256=N0cP_CNlb_LLCUqbHmTQsOGufWnD_ddGdeFnXPE8Er
 execsql/exporters/duckdb.py,sha256=IQp7ayIJHB2lf6mBSxl6k5R2AeUEvgD75Q5Y55mH8jI,3214
 execsql/exporters/feather.py,sha256=tah48aep0cQRikZcmADXUPTzFddgDUT78Ndw_l0Hsj4,4178
 execsql/exporters/html.py,sha256=hwf9UHs7EZ7xiP3p9ilBIsAukXcDu-KO2dcQHVh2z30,10111
-execsql/exporters/json.py,sha256=wWGT6zjvIdWlO5FmXbaEw1xOhy23f1YY6bm5uQD_NS0,4393
+execsql/exporters/json.py,sha256=kCR7HH_tC9xka5UDXLX4jgomXNEhhSHdRCIsYfEKiS4,5814
 execsql/exporters/latex.py,sha256=bdUN3GwfENUZHgpw6bvjsjfivDgzyf-HRkYTP-eH-pM,5480
 execsql/exporters/markdown.py,sha256=FuMGFxm9uZUOrdEuXT2ZZLCqmVDly7SMrFlrjP6kVEI,4827
 execsql/exporters/ods.py,sha256=hMKhUwLTKVf28JY1x7pdCGBl-WAE75oO9Oa7oUITS60,24916
 execsql/exporters/parquet.py,sha256=mbCo2Wlit1lkXmyo5EyLd_ATIHSICS49bouiBT2kdAs,1121
 execsql/exporters/pretty.py,sha256=SiJHBXIjoFsOHegXcdrtxYa6xSIPga1U0DQEy7pK4QY,4145
-execsql/exporters/protocol.py,sha256=BxATgz0xKHbB2FpZBeNg7wZfIiCohhD1awlr3JCec0c,4372
+execsql/exporters/protocol.py,sha256=7PBFmvMlt2M33Aoo7pwze83SuasquozR1KS0vWQffYM,4403
 execsql/exporters/raw.py,sha256=9o3BMt7UYmnjbP8OEzmM2kNKfwwERi2yDcuNfUoEfuQ,2530
 execsql/exporters/sqlite.py,sha256=QjP_W90S-hecNqp2A-Vy58DD8MZitME1sTq4lqIS43w,3401
 execsql/exporters/templates.py,sha256=N9PRFet0mYuDQFu7PNbq5c6qGu2You2qfHpqnxg17NA,7065
@@ -77,8 +78,8 @@ execsql/gui/console.py,sha256=dzdSl4NJNvRd9VvlwRCXHvfnXjQPimyTx7NcibcUZC8,18305
 execsql/gui/desktop.py,sha256=y-T317NzSs9kcA4-NZW-Dx2cZ4Bv1mPoCr7hwQCJYoo,59467
 execsql/gui/tui.py,sha256=VoUtjSMopYtbtc8_-qV7YQAFvc-bS7zrZ5J2hl1cPxM,66853
 execsql/importers/__init__.py,sha256=zZwdQxMaValCNqUrVdvaA7XPU3J8NmqVJ4uolNWY2iU,299
-execsql/importers/base.py,sha256=_RkCCP8cgqXfNioFVhuo8DAmrbZ-YBdW3rdpKntv-BY,5608
-execsql/importers/csv.py,sha256=IANjZhAhKUXJo_W1RAR-6smVCLSO7_CVHAHdzhtzAck,5005
+execsql/importers/base.py,sha256=4a4ypTr5qW38ByYbRW6cklveQ4Y7wMIYRa4-lFa_uZo,5635
+execsql/importers/csv.py,sha256=RLEs0QLqaREGBQxo2ovYS6cRqLbTKi4rPBdkANDt56I,5032
 execsql/importers/feather.py,sha256=g2B69d2uv9vmnXcmjFyTVsMP40LYEzFYkhk3gD26mGw,1900
 execsql/importers/json.py,sha256=fL47h09Zzx4Qw3TTQRQJbdPdD3qVMiU-kK9C7j1IQzg,5534
 execsql/importers/ods.py,sha256=scSId1sQpvWxtyPsp6QWTmuXn-h34gbbC4FM2fmhvFA,2980
@@ -96,7 +97,7 @@ execsql/lsp/hover.py,sha256=JemZqJ8d7FHouMhW92jkfek14fL9rl6JBQU7JIXJHos,5038
 execsql/lsp/navigation.py,sha256=_f-zW82P4Wkelbsdedz_5l_ztFt-CFD8VSiVE5JaSAM,6436
 execsql/lsp/rename.py,sha256=fYk1gDSWWhqyoIGZO5hVIHPYYdGKNjgZS0mijFDFpac,3756
 execsql/lsp/server.py,sha256=gTjk1agZbygdbcowa3jkL45WJ37sxhJ58oiLB7BM6Bw,19893
-execsql/metacommands/__init__.py,sha256=MO5cF84jHakrgYDR8C4-YzeMTLU6oCDeB7x-kUpoVws,12970
+execsql/metacommands/__init__.py,sha256=aMf-3IRjMpNFSUI-IMAcvL-kXZHq5qF6W_p3UawdQwM,13115
 execsql/metacommands/conditions.py,sha256=4DsMXr6vnfbtcKqgnxYV4UK4NmAfE_hpfgkFjlH0bjo,29844
 execsql/metacommands/connect.py,sha256=SPk4h9yiUgTD3w1gNOT_oYx8VShggsO357by5Hoy6OI,15344
 execsql/metacommands/control.py,sha256=9swW6X8jXDUpu5cHiAnQVx1ahFyWxlx7mjg4dqYfX5Y,9355
@@ -105,22 +106,22 @@ execsql/metacommands/debug.py,sha256=mKRT7uLwnw34Xl46fNDI_zH4MsPpZyihoLlonapbXuU
 execsql/metacommands/dispatch.py,sha256=so0ebcnv66NhVDtA1Bt4GelD0hsC5w7gy7rItz2Mdos,87430
 execsql/metacommands/effects.py,sha256=cRSo48R4nRJzkRR3OGHLhJzofcdAaNIobaxmn1N9TGw,3813
 execsql/metacommands/io.py,sha256=vlGBje5sgnqeilooMdhJDgSRIhysHy5_7LrKtik9Xjs,3011
-execsql/metacommands/io_export.py,sha256=YamxQwURRjZRpCG2z8W3QurncCmEmAyLFqDkxtHo5dY,14434
-execsql/metacommands/io_fileops.py,sha256=CmdgfgTHFWlzsA5XzsHeu6B9OTncb0K8n9uEgS68dkQ,13306
+execsql/metacommands/io_export.py,sha256=_1o5T3Ejqq_0N1hYwaRPgDktn8nZT8sQLMyXPRgXEec,14587
+execsql/metacommands/io_fileops.py,sha256=ru7zYgNV7rg0WtaDwhdYjy5iJTcecvjzR1PCdMNGG0A,13364
 execsql/metacommands/io_import.py,sha256=gJICeK1MOfG6D73I7m8zBCalvr_ZJzD-QBKOpKYeYXo,15684
 execsql/metacommands/io_write.py,sha256=yXDkMbQ3haDARVATVUYZprakyJHSyk1NywdKkFLpQ14,12783
 execsql/metacommands/prompt.py,sha256=PlXhtBYCembG_1SSCrwpQR10mGF3_jXodu4aCSHlSCM,37950
-execsql/metacommands/reference.py,sha256=yiv_qNp-MPI2UNBOzfwT11JU-xvWM9lw8yBZjP_VlsY,53953
+execsql/metacommands/reference.py,sha256=qBsOfcu4pi3XQCL-ywusfbrTtpqwqrWUlVraj8tj5Co,54325
 execsql/metacommands/script_ext.py,sha256=CsUbyq8QFPnnvfX_k7fPlYNvvRw1xLmAWER4Exo5pwc,3658
 execsql/metacommands/system.py,sha256=6X2qmMpGUHDzyEluEotXt0Ks9jKQTpc2x0eoYNgN12M,7997
-execsql/metacommands/upsert.py,sha256=Dl7NfaAH8ziGBqcLCgcat3Hcw9vSewK1eo7-nzToI4g,20725
+execsql/metacommands/upsert.py,sha256=hcYGonmh2sdijbqwNynn1-iajMnLp7x5vbRbtfjaf8c,21461
 execsql/script/__init__.py,sha256=I7hVO6wm3iOocxRRGEcFHhjdtL1moKbUYLB-wKbjPdk,3267
 execsql/script/ast.py,sha256=WqCpFxhxrT2IIGvbArTp3QS0BZryRZAb7IL4ri3I6xg,20591
 execsql/script/control.py,sha256=WqLy-HLPqHG3vEzYpKMiIJsD7LpORjyQuUWzFzcGz4w,2327
-execsql/script/engine.py,sha256=wjXKwPIis-T2Y8rLnRXQ_ymUFdXff1MlI2IIYmxihKo,18448
-execsql/script/executor.py,sha256=p3Aj7Ab8HwZRnmYds_e6h6yhRzCCa9XXbdVDkpg6NaQ,40855
+execsql/script/engine.py,sha256=h1pUSXGqwJASLJizqzd9LBMn_U5Vuqc1UbaZk1xUinw,18468
+execsql/script/executor.py,sha256=p6VWZeTMRPD_621I-CF4K2aaFaAbrY5I82hksrACFJQ,40999
 execsql/script/parser.py,sha256=z73v6t6ZbPUKkRu-UOIL6q1cCRDeoRvG2aXXC8NpMvE,37162
-execsql/script/variables.py,sha256=Tb01aHqOdWZbkgj-oW0ky3KWNy5N34XLD-Fm2eShYZM,17462
+execsql/script/variables.py,sha256=XHRnViFp0zPy-skGpYbpckkYAcczqpw1lqTVLR9eZvo,17735
 execsql/utils/__init__.py,sha256=0uR6JwVJQRX3vceByNBduCAf5dd5assKjeqJUWvpZoA,278
 execsql/utils/auth.py,sha256=0LYKdNMhodq9R0B8WyKp69a-xlP9wOR6Ua9Lgo2aJnQ,14868
 execsql/utils/color.py,sha256=goQqhnLg8yERpFolQikA9zYSVcuAm0unKTJiWTbQm-U,634
@@ -135,22 +136,22 @@ execsql/utils/paths.py,sha256=7IIHT6vqXTfs6Ltfrzm_I2ZV4pU8IuedOLkHo6a1_K8,1175
 execsql/utils/regex.py,sha256=DGzPBl0Kt4--RbwPhoZI6Bm6N_CBUvI0DbqE4EF6qp8,3718
 execsql/utils/strings.py,sha256=UQNjpRCEFa1UO6feU-M-9e24wWAvizs_iu_4fFusLxo,8516
 execsql/utils/timer.py,sha256=eDYf5VzCNFk7oo90InJucUm3XcBdhYMogjZMqeg9xzc,1899
-execsql2-2.32.0.data/data/execsql2_extras/README.md,sha256=6f5bWiBlKRn8s6GVrU423-HFrU1Jwbk2AabxraLu3AY,5398
-execsql2-2.32.0.data/data/execsql2_extras/config_settings.sqlite,sha256=aY5cxR7Q7J6zJ4bC9lu5mHUrhy211Cq3MNKPQVCt02E,20480
-execsql2-2.32.0.data/data/execsql2_extras/example_config_prompt.sql,sha256=2e8KzzVWhho8KxYVHETSVmZdhW7wodioDsqBLSL6m4s,7487
-execsql2-2.32.0.data/data/execsql2_extras/make_config_db.sql,sha256=WwyC6dK-Eh5CAVppiBCDHqiI1_wEI9U95Ytpr4lsZkg,8726
-execsql2-2.32.0.data/data/execsql2_extras/md_compare.sql,sha256=ARYEcOlxWLxfw-KCKDeJRdCqnuCb9PVwGaHtITR2sYU,26535
-execsql2-2.32.0.data/data/execsql2_extras/md_glossary.sql,sha256=gu2PDTm295YvxR7cDp25Mf-xXHly0BvlMudoNOrep5Q,10931
-execsql2-2.32.0.data/data/execsql2_extras/md_upsert.sql,sha256=YNUTFS6yB4bZXs-wRDn6dN8jL5wIumzZyE2uo5arIos,113407
-execsql2-2.32.0.data/data/execsql2_extras/pg_compare.sql,sha256=WcupGxQoWtMwHVPuy42xCpP4gAV4Ttb1W-_hwh-3xb4,24529
-execsql2-2.32.0.data/data/execsql2_extras/pg_glossary.sql,sha256=CfQz2HZj2nMvJfYfQrAmNYdx0uRrOIWsCXwVo5gKv_k,9953
-execsql2-2.32.0.data/data/execsql2_extras/script_template.sql,sha256=s5i0HULxp49N2Cpd24iALleM_dBq5oLuN3Arx_4Z7-o,11140
-execsql2-2.32.0.data/data/execsql2_extras/ss_compare.sql,sha256=PpU-vPyqqC1faBoo5zwVZlZHYKkT79QZisWVlk4o-ss,26415
-execsql2-2.32.0.data/data/execsql2_extras/ss_glossary.sql,sha256=_oTiZHpadPXWrNs8VoRe9PZgX9XdK490NMVWVTVtjl4,13110
-execsql2-2.32.0.data/data/execsql2_extras/ss_upsert.sql,sha256=Dvst877h4KHn8ayYF9EXI_OxqLQ89wyfcnGYYT4szro,118304
-execsql2-2.32.0.dist-info/METADATA,sha256=q3H3q9BleScKMNArYi3SplieuzY-X6flVjmfU5KHib8,26927
-execsql2-2.32.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-execsql2-2.32.0.dist-info/entry_points.txt,sha256=jOf53-4IVGjEZeNYUOF1GGaiPNfVZcNKxP3vDFKEyMA,58
-execsql2-2.32.0.dist-info/licenses/LICENSE.txt,sha256=LBdhuxejF8_bLCHZ2kWfmDXpDGUu914Gbd6_3JjCRe0,676
-execsql2-2.32.0.dist-info/licenses/NOTICE,sha256=McYzgxYav3U1OaVsY4Su1sfBrfmplpRdA9b6-gCDQCg,342
-execsql2-2.32.0.dist-info/RECORD,,
+execsql2-2.34.0.data/data/execsql2_extras/README.md,sha256=6f5bWiBlKRn8s6GVrU423-HFrU1Jwbk2AabxraLu3AY,5398
+execsql2-2.34.0.data/data/execsql2_extras/config_settings.sqlite,sha256=aY5cxR7Q7J6zJ4bC9lu5mHUrhy211Cq3MNKPQVCt02E,20480
+execsql2-2.34.0.data/data/execsql2_extras/example_config_prompt.sql,sha256=2e8KzzVWhho8KxYVHETSVmZdhW7wodioDsqBLSL6m4s,7487
+execsql2-2.34.0.data/data/execsql2_extras/make_config_db.sql,sha256=WwyC6dK-Eh5CAVppiBCDHqiI1_wEI9U95Ytpr4lsZkg,8726
+execsql2-2.34.0.data/data/execsql2_extras/md_compare.sql,sha256=ARYEcOlxWLxfw-KCKDeJRdCqnuCb9PVwGaHtITR2sYU,26535
+execsql2-2.34.0.data/data/execsql2_extras/md_glossary.sql,sha256=gu2PDTm295YvxR7cDp25Mf-xXHly0BvlMudoNOrep5Q,10931
+execsql2-2.34.0.data/data/execsql2_extras/md_upsert.sql,sha256=YNUTFS6yB4bZXs-wRDn6dN8jL5wIumzZyE2uo5arIos,113407
+execsql2-2.34.0.data/data/execsql2_extras/pg_compare.sql,sha256=WcupGxQoWtMwHVPuy42xCpP4gAV4Ttb1W-_hwh-3xb4,24529
+execsql2-2.34.0.data/data/execsql2_extras/pg_glossary.sql,sha256=CfQz2HZj2nMvJfYfQrAmNYdx0uRrOIWsCXwVo5gKv_k,9953
+execsql2-2.34.0.data/data/execsql2_extras/script_template.sql,sha256=s5i0HULxp49N2Cpd24iALleM_dBq5oLuN3Arx_4Z7-o,11140
+execsql2-2.34.0.data/data/execsql2_extras/ss_compare.sql,sha256=PpU-vPyqqC1faBoo5zwVZlZHYKkT79QZisWVlk4o-ss,26415
+execsql2-2.34.0.data/data/execsql2_extras/ss_glossary.sql,sha256=_oTiZHpadPXWrNs8VoRe9PZgX9XdK490NMVWVTVtjl4,13110
+execsql2-2.34.0.data/data/execsql2_extras/ss_upsert.sql,sha256=Dvst877h4KHn8ayYF9EXI_OxqLQ89wyfcnGYYT4szro,118304
+execsql2-2.34.0.dist-info/METADATA,sha256=-If95mpt8uHmRfovA0qRritNaIxwEIW6v3d71fcCAHE,26939
+execsql2-2.34.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+execsql2-2.34.0.dist-info/entry_points.txt,sha256=jOf53-4IVGjEZeNYUOF1GGaiPNfVZcNKxP3vDFKEyMA,58
+execsql2-2.34.0.dist-info/licenses/LICENSE.txt,sha256=LBdhuxejF8_bLCHZ2kWfmDXpDGUu914Gbd6_3JjCRe0,676
+execsql2-2.34.0.dist-info/licenses/NOTICE,sha256=McYzgxYav3U1OaVsY4Su1sfBrfmplpRdA9b6-gCDQCg,342
+execsql2-2.34.0.dist-info/RECORD,,