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

execsql/db/access.py

@@ -15,7 +15,7 @@ from pathlib import Path
 from typing import Any, cast
 
 from execsql.db.base import Database, _fetched
-from execsql.db.odbc import odbc_value
+from execsql.db.odbc import fresh_sessions, odbc_value
 from execsql.db.tiers import SupportTier
 from execsql.exceptions import ErrInfo
 from execsql.utils.errors import exception_desc, fatal_error, install_hint
@@ -108,6 +108,8 @@ class AccessDatabase(Database):
         # Open an ODBC connection.
         import pyodbc
 
+        fresh_sessions(pyodbc)
+
         if self.conn is not None:
             self.conn.close()
             self.conn = None

execsql/db/base.py

@@ -665,6 +665,23 @@ class Database(ABC):
         self.execute(f"drop table if exists {tablename} cascade;")
         self.commit()
 
+    def row_inserter(self, curs: Any, table: str, columns: list[str]) -> Callable[[list[list[Any]]], None]:
+        """Return a function that inserts one batch of rows into *table* through *curs*.
+
+        *table* is schema-qualified and quoted; *columns* are the quoted
+        column names, in the order of each row's values.  IMPORT and COPY call
+        the function once per batch, all inside one transaction.  This one
+        runs ``executemany``.  An adapter may override it with a faster bulk
+        path only if that path stores exactly what ``executemany`` stores, for
+        every value type and column type: a faster load must not change data.
+        """
+        sql = f"insert into {table} ({','.join(columns)}) values ({self.paramsubs(len(columns))});"
+
+        def insert(rows: list[list[Any]]) -> None:
+            curs.executemany(sql, rows)
+
+        return insert
+
     def populate_table(
         self,
         schema_name: str | None,
@@ -740,6 +757,7 @@ class Database(ABC):
 
         def _import_loop(curs) -> int:
             nonlocal eof, total_rows, task_id
+            insert = self.row_inserter(curs, sq_name, columns)
             while True:
                 b = []
                 for _j in range(_state.conf.import_row_buffer):
@@ -809,7 +827,7 @@ class Database(ABC):
                                 b.append(row)
                 if len(b) > 0:
                     try:
-                        curs.executemany(sql, b)
+                        insert(b)
                     except ErrInfo:
                         raise
                     except Exception as e:

execsql/db/dsn.py

@@ -10,6 +10,7 @@ the CLI.
 
 
 from execsql.db.base import Database
+from execsql.db.odbc import fresh_sessions
 from execsql.db.tiers import SupportTier
 from execsql.exceptions import ErrInfo
 from execsql.utils.errors import exception_desc, fatal_error, install_hint
@@ -75,6 +76,8 @@ class DsnDatabase(Database):
         # Open an ODBC connection using a DSN.
         import pyodbc
 
+        fresh_sessions(pyodbc)
+
         if self.conn is not None:
             self.conn.close()
             self.conn = None

execsql/db/duckdb.py

@@ -8,8 +8,12 @@ analytics databases via the ``duckdb`` package.  Corresponds to ``-t k``
 on the CLI.
 """
 
+import importlib.util
 import re
+import sys
 from collections import deque
+from collections.abc import Callable, Iterator
+from contextlib import contextmanager
 from pathlib import Path
 from typing import Any
 
@@ -18,7 +22,7 @@ from execsql.exceptions import ErrInfo
 from execsql.utils.errors import exception_desc, fatal_error, install_hint
 import execsql.state as _state
 
-__all__ = ["DuckDBDatabase"]
+__all__ = ["DuckDBDatabase", "insert_rows"]
 
 # Statements that return rows; any other statement DuckDB answers with a
 # one-column "Count" result (rows inserted, updated or deleted).
@@ -28,6 +32,53 @@ _QUERY_RX = re.compile(r"(?:SELECT|WITH|VALUES|FROM|TABLE|SHOW|DESCRIBE|SUMMARIZ
 _TRANSACTION_RX = re.compile(r"(?P<begin>BEGIN|START\s+TRANSACTION)\b|(?P<end>COMMIT|END|ROLLBACK|ABORT)\b", re.I)
 
 
+# Parameters bound by one INSERT ... VALUES statement in insert_rows(); a
+# wide table gets fewer rows per statement.
+_PARAMS_PER_STATEMENT = 10_000
+
+
+@contextmanager
+def _pandas_lookup_skipped() -> Iterator[None]:
+    """Make DuckDB's check for pandas fail at once while it binds rows.
+
+    The duckdb package asks Python's import system for ``pandas`` twice for
+    every row it binds, and when pandas is not installed nothing remembers
+    the answer, so each row searches ``sys.path`` again: about three
+    quarters of an INSERT's time.  A ``None`` in ``sys.modules`` makes that
+    import fail without the search.  It is set only when pandas is not
+    installed, so no import that could have succeeded fails, and it is
+    removed afterwards.
+    """
+    if "pandas" in sys.modules or importlib.util.find_spec("pandas") is not None:
+        yield
+        return
+    sys.modules["pandas"] = None  # type: ignore[assignment]
+    try:
+        yield
+    finally:
+        if "pandas" in sys.modules and sys.modules["pandas"] is None:
+            del sys.modules["pandas"]
+
+
+def insert_rows(curs: Any, table: str, columns: list[str], rows: list[Any]) -> None:
+    """Insert *rows* into *table* with multi-row ``INSERT ... VALUES`` statements.
+
+    *table* is quoted (and schema-qualified as needed); *columns* are the
+    quoted column names, in the order of each row's values.  DuckDB's
+    ``executemany`` runs one row at a time; binding many rows in one
+    statement is several times faster and stores the same values.
+    """
+    if not rows:
+        return
+    per_statement = max(1, _PARAMS_PER_STATEMENT // max(1, len(columns)))
+    head = f"insert into {table} ({','.join(columns)}) values "
+    row_marks = "(" + ",".join("?" * len(columns)) + ")"
+    with _pandas_lookup_skipped():
+        for start in range(0, len(rows), per_statement):
+            chunk = rows[start : start + per_statement]
+            curs.execute(head + ",".join([row_marks] * len(chunk)), [value for row in chunk for value in row])
+
+
 class _SharedCursor:
     """A cursor that runs on the database's one connection.
 
@@ -261,6 +312,14 @@ class DuckDBDatabase(Database):
             curs.execute(sql, params)
             return len(curs.fetchall()) > 0
 
+    def row_inserter(self, curs: Any, table: str, columns: list[str]) -> Callable[[list[list[Any]]], None]:
+        """Insert each batch with multi-row ``INSERT ... VALUES`` (:func:`insert_rows`)."""
+
+        def insert(rows: list[list[Any]]) -> None:
+            insert_rows(curs, table, columns, rows)
+
+        return insert
+
     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/odbc.py

@@ -7,15 +7,32 @@ taken from a substitution variable) would end its attribute early and
 start another.  :func:`odbc_value` brace-quotes such values;
 :func:`connection_string` joins the attributes, and :func:`loggable`
 gives the same string with the password masked for the log.
+:func:`fresh_sessions` makes each pyodbc connection a new database session.
 """
 
 from __future__ import annotations
 
-__all__ = ["connection_string", "loggable", "odbc_value"]
+from typing import Any
+
+__all__ = ["connection_string", "fresh_sessions", "loggable", "odbc_value"]
 
 _SECRET_KEYS = frozenset({"pwd", "password"})
 
 
+def fresh_sessions(pyodbc: Any) -> None:
+    """Turn off pyodbc's connection pooling, so each connection is a new session.
+
+    With pooling on, closing a connection hands its session back to the ODBC
+    driver manager, and unixODBC gives it unchanged to the next connection to
+    the same server: temp tables and ``SET`` options from one ``CONNECT`` or
+    ``execsql.run()`` were still there in the next.  pyodbc applies the
+    setting when the process makes its first pyodbc connection, so it covers
+    every pyodbc connection in the process, and has no effect if one was
+    made before execsql's first.
+    """
+    pyodbc.pooling = False
+
+
 def odbc_value(value: object) -> str:
     """Return *value* as an ODBC attribute value, brace-quoted when it needs it.
 

execsql/db/sqlserver.py

@@ -8,7 +8,7 @@ Server via ``pyodbc``.  Corresponds to ``-t s`` on the CLI.
 """
 
 from execsql.db.base import Database
-from execsql.db.odbc import connection_string, loggable
+from execsql.db.odbc import connection_string, fresh_sessions, loggable
 from execsql.exceptions import ErrInfo
 from execsql.utils.errors import fatal_error, install_hint
 from execsql.utils.auth import (
@@ -98,6 +98,8 @@ class SqlServerDatabase(Database):
         """Open a connection to the SQL Server database via pyodbc."""
         import pyodbc
 
+        fresh_sessions(pyodbc)
+
         if self.conn is None:
             begin_login()
             if self.user and self.need_passwd and not self.password:

execsql/exporters/duckdb.py

@@ -10,7 +10,6 @@ Requires the ``execsql2[duckdb]`` extra.
 
 import datetime as _datetime
 import decimal as _decimal
-import math
 from pathlib import Path
 from typing import Any
 
@@ -38,9 +37,9 @@ def export_duckdb(
         fatal_error(f"The duckdb module is required to export data in that format. {install_hint('duckdb')}")
         return
 
+    from execsql.db.duckdb import insert_rows
     from execsql.models import DataTable
 
-    chunksize = 10000
     # B07a/F026: tablename and catalog are substituted from user input.
     # Identifier-quote the table-name interpolation site and use
     # placeholders for the information_schema literal-value query.
@@ -70,15 +69,8 @@ def export_duckdb(
     curs.execute(sql)
     # Export all rows of data
     columns = [dbt_duckdb.quoted(col) for col in hdrs]
-    colspec = ",".join(columns)
-    paramspec = ",".join(("?",) * len(columns))
-    sql = f"insert into {qtable} ({colspec}) values ({paramspec});"
-    n_chunks = math.ceil(len(rowdata) / chunksize)
     curs.execute("BEGIN TRANSACTION;")
-    for i in range(n_chunks):
-        start = i * chunksize
-        end = start + chunksize
-        curs.executemany(sql, rowdata[start:end])
+    insert_rows(curs, qtable, columns, rowdata)
     curs.execute("COMMIT;")
     curs.close()
     ddb.close()

execsql/models.py

@@ -50,6 +50,16 @@ __all__ = [
 ColumnType = tuple[str, type[DataType], int | None, bool, int | None, int | None]
 
 
+def _text_length(value: Any) -> int:
+    """Return the length of *value* written as text (a column may turn out to be text)."""
+    if isinstance(value, str):
+        return len(value)
+    try:
+        return len(str(value))
+    except Exception:
+        return len(bytes(value))
+
+
 class Column:
     """Compile data-type match statistics for a single column of imported data."""
 
@@ -84,40 +94,39 @@ class Column:
             """Test whether a non-null value matches this data type and update statistics."""
             # datavalue must be non-null
             if not self.failed:
-                is_match = self.dt.matches(datavalue)
-                if is_match:
-                    self.count += 1
-                    if isinstance(datavalue, str):
-                        vlen = len(datavalue)
-                    else:
-                        # This column may turn out to have to be text, so we need the maximum length
-                        # of any data value when represented as text.
-                        try:
-                            vlen = len(str(datavalue))
-                        except Exception:
-                            vlen = len(bytes(datavalue))
-                    if self.maxlen > 0 and vlen != self.maxlen:
-                        self.varlen = True
-                    if vlen > self.maxlen:
-                        self.maxlen = vlen
-                    if self.dt.precision is not None and self.dt.scale is not None:
-                        int_digits = self.dt.precision - self.dt.scale
-                        if self.maxprecision is None:
-                            self.maxprecision = self.dt.precision
-                            self.scale = self.dt.scale
-                            self.maxscale = self.dt.scale
-                            self.max_int_digits = int_digits
-                        else:
-                            assert self.maxscale is not None
-                            assert self.max_int_digits is not None
-                            self.maxprecision = max(self.dt.precision, self.maxprecision)
-                            if self.dt.scale != self.scale:
-                                self.varscale = True
-                            self.maxscale = max(self.dt.scale, self.maxscale)
-                            self.max_int_digits = max(int_digits, self.max_int_digits)
+                if self.dt.matches(datavalue):
+                    self.record(_text_length(datavalue))
                 else:
                     self.failed = True
 
+        def record(self, vlen: int) -> None:
+            """Count a value this data type matched, *vlen* characters long as text.
+
+            Call it right after :meth:`DataType.matches` accepted the value:
+            a decimal type's precision and scale are those of the value it
+            last matched.
+            """
+            self.count += 1
+            if self.maxlen > 0 and vlen != self.maxlen:
+                self.varlen = True
+            if vlen > self.maxlen:
+                self.maxlen = vlen
+            if self.dt.precision is not None and self.dt.scale is not None:
+                int_digits = self.dt.precision - self.dt.scale
+                if self.maxprecision is None:
+                    self.maxprecision = self.dt.precision
+                    self.scale = self.dt.scale
+                    self.maxscale = self.dt.scale
+                    self.max_int_digits = int_digits
+                else:
+                    assert self.maxscale is not None
+                    assert self.max_int_digits is not None
+                    self.maxprecision = max(self.dt.precision, self.maxprecision)
+                    if self.dt.scale != self.scale:
+                        self.varscale = True
+                    self.maxscale = max(self.dt.scale, self.maxscale)
+                    self.max_int_digits = max(int_digits, self.max_int_digits)
+
     def __init__(self, colname: str, infer_strings: bool = True) -> None:
         """Create a column characteriser for the named column.
 
@@ -177,6 +186,15 @@ class Column:
         self.str_accums = tuple(ac for ac in self.accums if isinstance(ac.dt, (DT_Character, DT_Varchar, DT_Text)))
         # A bytes value is checked as binary or text only: int(b"12") is 12.
         self.bytes_accums = tuple(ac for ac in self.accums if isinstance(ac.dt, DT_Binary)) + self.str_accums
+        # A value is tried only against the types that matched every value
+        # before it: a type that failed once cannot be the column's type.
+        self._live = list(self.accums)
+        self._live_str = list(self.str_accums)
+        self._live_bytes = list(self.bytes_accums)
+        # The settings the scan reads for every value, read once.
+        self._trim_strings = conf.trim_strings
+        self._replace_newlines = conf.replace_newlines
+        self._empty_strings = conf.empty_strings
         self.dt_eval = False
         # self.dt is a tuple of: 0: column name; 1: data type class; 2: max length or None;
         # 3: bool indicating any null values; 4: precision or None; 5: scale or None.
@@ -187,31 +205,38 @@ class Column:
 
     def eval_types(self, column_value: Any) -> None:
         """Evaluate which data types the value matches and update counters."""
-        # Evaluate which data type(s) the value matches, and increment the appropriate counter(s).
-        import execsql.state as _state
-
         self.dt_eval = False
         self.rowcount += 1
-        conf = _state.conf
-        if column_value is not None and isinstance(column_value, str):
-            if conf.trim_strings:
+        is_str = isinstance(column_value, str)
+        if is_str:
+            if self._trim_strings:
                 column_value = column_value.strip()
-            if conf.replace_newlines:
+            if self._replace_newlines:
                 column_value = re.sub(r"[\s\t]*[\r\n]+[\s\t]*", " ", column_value)
-        if column_value is None or (
-            not conf.empty_strings and isinstance(column_value, str) and len(column_value.strip()) == 0
-        ):
+        if column_value is None or (not self._empty_strings and is_str and len(column_value.strip()) == 0):
             self.nullrows += 1
             return
-        if not self.infer_strings and isinstance(column_value, str):
-            for dt in self.str_accums:
-                dt.check(column_value)
+        if not self.infer_strings and is_str:
+            live = self._live_str
         elif not self.infer_strings and isinstance(column_value, (bytes, bytearray, memoryview)):
-            for dt in self.bytes_accums:
-                dt.check(column_value)
+            live = self._live_bytes
         else:
-            for dt in self.accums:
-                dt.check(column_value)
+            live = self._live
+        vlen = None
+        any_failed = False
+        # The value is not NULL, the one case DataType.matches() adds to _is_match().
+        for ac in live:
+            if ac.dt._is_match(column_value):
+                if vlen is None:
+                    vlen = _text_length(column_value)
+                ac.record(vlen)
+            else:
+                ac.failed = True
+                any_failed = True
+        if any_failed:
+            self._live = [ac for ac in self._live if not ac.failed]
+            self._live_str = [ac for ac in self._live_str if not ac.failed]
+            self._live_bytes = [ac for ac in self._live_bytes if not ac.failed]
 
     def column_type(self) -> ColumnType:
         """Return the inferred type of this column as a 6-tuple."""

execsql/types.py

@@ -550,6 +550,8 @@ class DT_Character(DataType):
         return "DT_Character()"
 
     def _is_match(self, data: object) -> bool:
+        if isinstance(data, str):  # what _from_data() returns a str as, unchanged
+            return True
         if isinstance(data, bytearray):
             return False
         return super()._is_match(data)
@@ -582,6 +584,8 @@ class DT_Varchar(DataType):
         return "DT_Varchar()"
 
     def _is_match(self, data: object) -> bool:
+        if isinstance(data, str):  # the length check _from_data() makes
+            return len(data) <= 255
         if isinstance(data, bytearray):
             return False
         return super()._is_match(data)
@@ -609,6 +613,8 @@ class DT_Text(DataType):
         return "DT_Text()"
 
     def _is_match(self, data: object) -> bool:
+        if isinstance(data, str):  # what _from_data() returns a str as, unchanged
+            return True
         if isinstance(data, bytearray):
             return False
         return super()._is_match(data)
@@ -634,6 +640,14 @@ class DT_Binary(DataType):
     def __repr__(self) -> str:
         return "DT_Binary()"
 
+    def _is_match(self, data: object) -> bool:
+        # bytearray(n) is n zero bytes, so an int converts when it is not
+        # negative.  Building it to find out allocated n bytes per value: a
+        # column of epoch milliseconds asked for a terabyte each.
+        if isinstance(data, int):
+            return data >= 0
+        return super()._is_match(data)
+
 
 class DbType:
     """Map Python DataType subclasses to DBMS-specific SQL type names."""

execsql/utils/datetime.py

@@ -14,7 +14,9 @@ today's date.  ``1-2``, ``5/6`` and ``March 5`` are not timestamps.
 """
 
 import datetime
+import functools
 import re
+import time
 from typing import Any, cast
 
 from dateutil import parser as _dateutil_parser
@@ -58,9 +60,21 @@ _DEFAULT_B = datetime.datetime(2002, 2, 2)
 
 def _parse(datestr: str, strict: bool) -> datetime.datetime | None:
     """Parse *datestr* with dateutil; when *strict*, only a fully written date."""
-    try:
-        if not strict:
+    if not strict:
+        try:
             return cast(datetime.datetime, _dateutil_parser.parse(datestr))
+        except (ValueError, OverflowError, TypeError):
+            return None
+    # A strict parse depends only on the string and on the local zone names
+    # dateutil matches a written zone against, so repeated values (dates
+    # recur, and type inference parses each one for both timestamp types)
+    # are parsed once.
+    return _parse_strict(datestr, time.tzname)
+
+
+@functools.lru_cache(maxsize=4096)
+def _parse_strict(datestr: str, _local_zone_names: tuple[str, str]) -> datetime.datetime | None:
+    try:
         if not _FULL_YEAR.search(datestr):
             short = _SHORT_YEAR.match(datestr)
             # Month first only: dateutil would read 13-05-24 day-first,

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: execsql2
-Version: 2.31.1
+Version: 2.32.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
@@ -441,7 +441,7 @@ execsql format --no-sql --in-place scripts/
 ```yaml
 repos:
   - repo: https://github.com/geocoug/execsql
-    rev: v2.31.1
+    rev: v2.32.0
     hooks:
       - id: execsql-format
       - id: execsql-lint

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

@@ -7,13 +7,13 @@ execsql/exceptions.py,sha256=aHavdblmP7m5ZLxyyKKmPSwwbdmP962j4ShP1Gd9r64,9651
 execsql/format.py,sha256=z-KZ8VY1muz8S6iaErZX9E_7wE_VtjEcUB7e_KyhfyI,59565
 execsql/interactive.py,sha256=7vm7NAlcarBJJOIffcLOcJqH9ZCInvHB_CmC2sQsXf8,8241
 execsql/manifest.py,sha256=eJp39R8bYuFuJiGaBbDsk_lua13uJHXPOdwWdUfE-CQ,9027
-execsql/models.py,sha256=caUGQ3C9hvFaj6c6-GwBzZc8FAGTD1ZSJYd8bFyRh5I,16410
+execsql/models.py,sha256=heq4wrTJHOHF5sCIbvnCiaNHteeT8G06aBoRAsF9vuI,17191
 execsql/parser.py,sha256=bw26e1lD-PZscV11VtBdqSLkjpcYfNLQC2EYfYD5UwU,16012
 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=zey_bc2AzbUduLoK-nps16qX2zazDYf_iapWkG_cbmA,33130
+execsql/types.py,sha256=XmLfqjXSxBJamZbz0JPodipXi1YzcN_2MjooPyzJsyY,33819
 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
@@ -34,25 +34,25 @@ execsql/data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 execsql/data/execsql.conf.template,sha256=Mz8wZxu0U2bfL-fsDpRHvdLkwNpfuZrl4QUMjp7SXyk,12770
 execsql/data/script_header.sql,sha256=a7WKScekNgJoxVEmMRTkWv8NsAzW1jJ4vJfGy9HVy0g,349
 execsql/db/__init__.py,sha256=jTbuafuKOqYtXFR1wvCOoKK5Lr3l1uErfaIbIr6UywI,1063
-execsql/db/access.py,sha256=tNhBuLW5QwMOc8REnu2Qt1Ge86ozMEk4MhHlUvYrJ-I,21379
-execsql/db/base.py,sha256=tBAcNRiYE7VZo98S75mu6Y2ySdBNoh8LzzTn7TgLOBs,43684
-execsql/db/dsn.py,sha256=CaISffisqO5IjSE-elEpwK9vXLaArp3ItpV8lvRTu-I,6920
-execsql/db/duckdb.py,sha256=KC8Tqbnemg3wsYH_efnFmxtybPbMXElFDsoeq_FeVus,11143
+execsql/db/access.py,sha256=fxiC3rtoOJzrNXNxau-w7oh1fd9tyh2_PMliBbFc164,21427
+execsql/db/base.py,sha256=WdF1X0xG01ZKaYNkxcyUSKJCV04cceThPkvERlN-iu0,44619
+execsql/db/dsn.py,sha256=Evrc6MUllJVFDn0jZB_iks-aKCsXuNF9XYjAkttqgGQ,6995
+execsql/db/duckdb.py,sha256=6vD5b_tpvfByoFEajZNY5HLzVUnH1eOuPpzNGAKFsIQ,13624
 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/odbc.py,sha256=uus6J0kbLyvAvvARA_X5n10hbx49Wba258Sm7ZYSnoA,1760
+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=5WUU67rFN28iiNriIWvgT2Dj7z0F0zKOJFWTsSBd0dg,10480
+execsql/db/sqlserver.py,sha256=6-wySx9BrSTAyXl5BnBLjRYEpl4_GubDjiGuvpehgco,10528
 execsql/db/tiers.py,sha256=PH2sUYwlYqcANGVKXprWQKVIlM6fpWU9q74djn8oFwc,2924
 execsql/debug/__init__.py,sha256=j6EGUR0dHzUhWN1mHHtf1-Lhjq3Sb1V-vmnq2Ztgj1M,178
 execsql/debug/repl.py,sha256=jnwrqRac4krc1pES7Ni-j1Dyw3mJIcWl5LQQIX1GkRw,20753
 execsql/exporters/__init__.py,sha256=-Cnji-OgodJV8ftcDcOyTof0kQMy9J5kKVC8GVFpc3o,670
 execsql/exporters/base.py,sha256=_GoO0YqwlTxrjogxHI3CxxRR64sMgIEjRogt0KCqzoY,6402
 execsql/exporters/delimited.py,sha256=N0cP_CNlb_LLCUqbHmTQsOGufWnD_ddGdeFnXPE8Erc,35606
-execsql/exporters/duckdb.py,sha256=1Qo6idHvQIJjGbA5trt_s5to9XtoDpcS_wWGXOrVe6I,3495
+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
@@ -125,7 +125,7 @@ execsql/utils/__init__.py,sha256=0uR6JwVJQRX3vceByNBduCAf5dd5assKjeqJUWvpZoA,278
 execsql/utils/auth.py,sha256=0LYKdNMhodq9R0B8WyKp69a-xlP9wOR6Ua9Lgo2aJnQ,14868
 execsql/utils/color.py,sha256=goQqhnLg8yERpFolQikA9zYSVcuAm0unKTJiWTbQm-U,634
 execsql/utils/crypto.py,sha256=KlT6lPk-v0-qQQfAMfWvT9Q6kRdCD3_5JVaLajNocKM,3051
-execsql/utils/datetime.py,sha256=rqtGrc0t37V00mvirJ8wJKHmDtDSYzTg_UgCyIBzv9E,5583
+execsql/utils/datetime.py,sha256=9ZizCFBYut5gC4gU3Cmegfddv1HLoU5xVQWm9thy5EI,6127
 execsql/utils/errors.py,sha256=WKojSMjNecL9riRo9TnZ4fXofZr2uDo2_4B6n-zP31M,11693
 execsql/utils/fileio.py,sha256=IqIEhun9aOnr1oBCWK2z2VAPVo95bZ54cVglLW4rV9M,48208
 execsql/utils/gui.py,sha256=1iiupP9AsLdR6ST0gcLE143o6y6YGUFlNv_pdVPxfCE,23943
@@ -135,22 +135,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.31.1.data/data/execsql2_extras/README.md,sha256=6f5bWiBlKRn8s6GVrU423-HFrU1Jwbk2AabxraLu3AY,5398
-execsql2-2.31.1.data/data/execsql2_extras/config_settings.sqlite,sha256=aY5cxR7Q7J6zJ4bC9lu5mHUrhy211Cq3MNKPQVCt02E,20480
-execsql2-2.31.1.data/data/execsql2_extras/example_config_prompt.sql,sha256=2e8KzzVWhho8KxYVHETSVmZdhW7wodioDsqBLSL6m4s,7487
-execsql2-2.31.1.data/data/execsql2_extras/make_config_db.sql,sha256=WwyC6dK-Eh5CAVppiBCDHqiI1_wEI9U95Ytpr4lsZkg,8726
-execsql2-2.31.1.data/data/execsql2_extras/md_compare.sql,sha256=ARYEcOlxWLxfw-KCKDeJRdCqnuCb9PVwGaHtITR2sYU,26535
-execsql2-2.31.1.data/data/execsql2_extras/md_glossary.sql,sha256=gu2PDTm295YvxR7cDp25Mf-xXHly0BvlMudoNOrep5Q,10931
-execsql2-2.31.1.data/data/execsql2_extras/md_upsert.sql,sha256=YNUTFS6yB4bZXs-wRDn6dN8jL5wIumzZyE2uo5arIos,113407
-execsql2-2.31.1.data/data/execsql2_extras/pg_compare.sql,sha256=WcupGxQoWtMwHVPuy42xCpP4gAV4Ttb1W-_hwh-3xb4,24529
-execsql2-2.31.1.data/data/execsql2_extras/pg_glossary.sql,sha256=CfQz2HZj2nMvJfYfQrAmNYdx0uRrOIWsCXwVo5gKv_k,9953
-execsql2-2.31.1.data/data/execsql2_extras/script_template.sql,sha256=s5i0HULxp49N2Cpd24iALleM_dBq5oLuN3Arx_4Z7-o,11140
-execsql2-2.31.1.data/data/execsql2_extras/ss_compare.sql,sha256=PpU-vPyqqC1faBoo5zwVZlZHYKkT79QZisWVlk4o-ss,26415
-execsql2-2.31.1.data/data/execsql2_extras/ss_glossary.sql,sha256=_oTiZHpadPXWrNs8VoRe9PZgX9XdK490NMVWVTVtjl4,13110
-execsql2-2.31.1.data/data/execsql2_extras/ss_upsert.sql,sha256=Dvst877h4KHn8ayYF9EXI_OxqLQ89wyfcnGYYT4szro,118304
-execsql2-2.31.1.dist-info/METADATA,sha256=_zRvNxl03raboxUe3f_1vjBqiNUyT_k5vF9RJhZI9Tk,26927
-execsql2-2.31.1.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-execsql2-2.31.1.dist-info/entry_points.txt,sha256=jOf53-4IVGjEZeNYUOF1GGaiPNfVZcNKxP3vDFKEyMA,58
-execsql2-2.31.1.dist-info/licenses/LICENSE.txt,sha256=LBdhuxejF8_bLCHZ2kWfmDXpDGUu914Gbd6_3JjCRe0,676
-execsql2-2.31.1.dist-info/licenses/NOTICE,sha256=McYzgxYav3U1OaVsY4Su1sfBrfmplpRdA9b6-gCDQCg,342
-execsql2-2.31.1.dist-info/RECORD,,
+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,,