execsql2 2.31.1__tar.gz → 2.31.2__tar.gz

{execsql2-2.31.1 → execsql2-2.31.2}/CHANGELOG.md

@@ -13,6 +13,14 @@ ______________________________________________________________________
 
 ______________________________________________________________________
 
+## [2.31.2] - 2026-10-16
+
+### Fixed
+
+- **SQL Server, Access and ODBC DSN connections** start a new database session on every `CONNECT` and `execsql.run()`: temp tables and `SET` options no longer carry over from an earlier connection in the same process on macOS and Linux. execsql turns off pyodbc's connection pooling, which also applies to other pyodbc connections your program makes.
+
+______________________________________________________________________
+
 ## [2.31.1] - 2026-10-16
 
 ### Added

{execsql2-2.31.1 → execsql2-2.31.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: execsql2
-Version: 2.31.1
+Version: 2.31.2
 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.31.2
     hooks:
       - id: execsql-format
       - id: execsql-lint

{execsql2-2.31.1 → execsql2-2.31.2}/README.md

@@ -321,7 +321,7 @@ execsql format --no-sql --in-place scripts/
 ```yaml
 repos:
   - repo: https://github.com/geocoug/execsql
-    rev: v2.31.1
+    rev: v2.31.2
     hooks:
       - id: execsql-format
       - id: execsql-lint

{execsql2-2.31.1 → execsql2-2.31.2}/docs/about/divergence.md

@@ -264,6 +264,7 @@ All 33 mutable runtime globals in `state.py` have been consolidated into a `Runt
 - **PostgreSQL driver is psycopg3** — the PostgreSQL adapter uses `psycopg` (psycopg3, installed via the `psycopg[binary]` extra) instead of upstream's `psycopg2`. The connection now passes the libpq `dbname` keyword (psycopg3 rejects psycopg2's `database`), `VACUUM` toggles `conn.autocommit` instead of the removed `set_session()`, server-side `COPY` import uses psycopg3's `cursor.copy()` context manager instead of `copy_expert()`, and binary `IMPORT` sends raw `bytes` instead of `psycopg2.Binary()`. This also makes `db.conn` directly usable by the `PG_UPSERT` metacommand's pg-upsert ≥1.26.0 dependency, which itself requires a psycopg3 connection. The connection sets `prepare_threshold=None` to disable psycopg3's automatic server-side prepared statements, which psycopg2 never used; without this, re-running a query (e.g. via `EXPORT`) against an object the script drops/recreates or alters raises `FeatureNotSupported: cached plan must not change result type`.
 - **Oracle driver is python-oracledb** — the Oracle adapter imports `oracledb`, the driver the `oracle` extra installs, instead of upstream's `cx_Oracle` (which ships no wheels for Python 3.12+). The `makedsn` / `connect` calls are the same. `cx_Oracle` is still used when it is the only Oracle driver installed.
 - **SQL Server tries ODBC Driver 18 first** — upstream's driver list stopped at Driver 17, so a machine with only Microsoft's current driver could not connect. Driver 18 encrypts the connection and verifies the server's certificate; the `trust_server_certificate` setting accepts a self-signed one.
+- **Each pyodbc connection is a new session** — the SQL Server, Access and ODBC DSN adapters set `pyodbc.pooling = False` before they connect. With pyodbc's default pooling, unixODBC (macOS, Linux) handed a closed connection's session unchanged to the next connection to the same server, so temp tables and `SET` options from one `CONNECT`, or one `execsql.run()`, were still there in the next. pyodbc applies the setting at the process's first pyodbc connection, so it also covers other pyodbc connections the process makes, and has no effect if the program connected with pyodbc before execsql did.
 - **`Database` is an ABC** — `open_db()` and `exec_cmd()` are abstract methods. Subclasses that omit them raise `TypeError` at instantiation instead of at call time.
 - **Connection timeouts** — PostgreSQL and SQLite adapters accept a connection timeout parameter (default 30 seconds).
 - **DuckDB temporal types** — `TIMESTAMPTZ`, `TIMESTAMP`, `DATE`, `TIME` now map to native DuckDB types instead of `TEXT`.

{execsql2-2.31.1 → execsql2-2.31.2}/docs/api/index.md

@@ -78,11 +78,12 @@ for t in threads:
 
 Each run has its own [file writer](#file-output), so two runs writing files at the same time both get complete files, and a run that halts on an error stops only its own output. Plugin metacommands are registered once per process, not once per call, and a `--manifest` recorder belongs to the run that started it.
 
-Three things are still shared by every thread in the process, so keep them apart yourself:
+Four things are still shared by every thread in the process, so keep them apart yourself:
 
 - **The working directory.** `CD` calls `os.chdir()`, which moves every thread while the script runs. Use absolute paths in scripts that run concurrently, or don't use `CD` in them. When a script that ran `CD` finishes, `run()` changes back to the directory it was in before that `CD`, so the caller ends where it started; a run without `CD` leaves the directory as it finds it.
 - **The same output file.** Two runs writing one file at the same time can interleave their lines. Give each run its own output paths.
 - **Interactive prompts.** `PROMPT` and the other GUI metacommands are not meant to be driven from several threads at once.
+- **pyodbc's connection pooling.** Before its first SQL Server, Access or ODBC DSN connection, execsql turns pooling off (`pyodbc.pooling = False`), so every `CONNECT` and every `run()` gets a new database session: a temp table or `SET` option from one run is gone in the next. pyodbc reads the setting at the process's first pyodbc connection, so your own pyodbc connections are not pooled either, and if your program connects with pyodbc before execsql does, pooling stays on and runs against the same server can share a session.
 
 ### File Output { #file-output }
 

{execsql2-2.31.1 → execsql2-2.31.2}/docs/guides/formatter.md

@@ -272,7 +272,7 @@ select id,name,created_at from users where active = true order by name;
 ```yaml
 repos:
   - repo: https://github.com/geocoug/execsql
-    rev: v2.31.1
+    rev: v2.31.2
     hooks:
       - id: execsql-format
       - id: execsql-lint # optional: fail the commit on lint errors

{execsql2-2.31.1 → execsql2-2.31.2}/docs/reference/lint.md

@@ -158,7 +158,7 @@ The `execsql-lint` [pre-commit](https://pre-commit.com/) hook runs `execsql lint
 ```yaml
 repos:
   - repo: https://github.com/geocoug/execsql
-    rev: v2.31.1
+    rev: v2.31.2
     hooks:
       - id: execsql-lint
         args: [--ignore, V002] # optional: any execsql lint option

{execsql2-2.31.1 → execsql2-2.31.2}/extras/vscode-execsql/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "execsql-syntax",
-  "version": "2.31.1",
+  "version": "2.31.2",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "execsql-syntax",
-      "version": "2.31.1",
+      "version": "2.31.2",
       "license": "GPL-3.0-or-later",
       "dependencies": {
         "vscode-languageclient": "10.1.2"

{execsql2-2.31.1 → execsql2-2.31.2}/extras/vscode-execsql/package.json

@@ -2,7 +2,7 @@
   "name": "execsql-syntax",
   "displayName": "execsql",
   "description": "Syntax highlighting, lint findings, completion, hover, navigation, quick fixes and formatting for execsql scripts.",
-  "version": "2.31.1",
+  "version": "2.31.2",
   "publisher": "geocoug",
   "license": "GPL-3.0-or-later",
   "icon": "icon.png",

{execsql2-2.31.1 → execsql2-2.31.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "execsql2"
-version = "2.31.1"
+version = "2.31.2"
 description = "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."
 readme = { file = "README.md", content-type = "text/markdown" }
 license = { file = "LICENSE.txt" }
@@ -188,7 +188,7 @@ line-ending = "auto"
 exclude = ["*.md"]
 
 [tool.bumpversion]
-current_version = "2.31.1"
+current_version = "2.31.2"
 commit = true
 tag = true
 tag_name = "v{new_version}"

{execsql2-2.31.1 → execsql2-2.31.2}/src/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

{execsql2-2.31.1 → execsql2-2.31.2}/src/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

{execsql2-2.31.1 → execsql2-2.31.2}/src/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.
 

{execsql2-2.31.1 → execsql2-2.31.2}/src/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:

execsql2-2.31.2/tests/db/test_odbc_fresh_sessions.py

@@ -0,0 +1,54 @@
+"""Each pyodbc connection execsql opens is a new database session.
+
+With pyodbc's connection 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.  The adapters
+turn pooling off before they connect.
+"""
+
+from __future__ import annotations
+
+import sys
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from execsql.db.access import AccessDatabase
+from execsql.db.dsn import DsnDatabase
+from execsql.db.sqlserver import SqlServerDatabase
+
+pytestmark = pytest.mark.usefixtures("fake_drivers")
+
+
+def _pooling_at_connect() -> list[object]:
+    """Make pyodbc.connect record the pooling setting it was called under."""
+    pyodbc = sys.modules["pyodbc"]
+    pyodbc.pooling = True  # pyodbc's default
+    seen: list[object] = []
+
+    def connect(*_args, **_kwargs):
+        seen.append(pyodbc.pooling)
+        return MagicMock()
+
+    pyodbc.connect = connect
+    return seen
+
+
+def test_sql_server_connects_without_pooling():
+    seen = _pooling_at_connect()
+    SqlServerDatabase("host", "db", "sa", port=1433, password="pw")
+    assert seen == [False]
+
+
+def test_dsn_connects_without_pooling():
+    seen = _pooling_at_connect()
+    DsnDatabase("MYDSN", None, need_passwd=False, encoding="utf-8")
+    assert seen == [False]
+
+
+def test_access_connects_without_pooling(tmp_path):
+    seen = _pooling_at_connect()
+    with patch.object(AccessDatabase, "open_dao", return_value=None):
+        AccessDatabase(str(tmp_path / "data.accdb"))
+    assert seen == [False]

{execsql2-2.31.1 → execsql2-2.31.2}/tests/db/test_sqlserver_inprocess.py

@@ -431,3 +431,32 @@ def test_to_replacement_creates_a_table_that_does_not_exist(tmp_path, monkeypatc
             "if object_id('repl_src') is not null drop table repl_src;\n",
             dsn=dsn,
         )
+
+
+def test_each_run_gets_a_fresh_session():
+    """A temp table or SET option from one run() is gone in the next.
+
+    In a fresh interpreter: pyodbc applies its pooling setting at the
+    process's first connection, and this module has already connected.
+    """
+    import subprocess
+    import sys
+
+    dsn = f"mssql://{_MS_USER}:{_MS_PASS}@{_MS_HOST}:{_MS_PORT}/{_MS_DB}?trust_server_certificate=yes"
+    code = f"""
+import execsql
+dsn = {dsn!r}
+first = execsql.run(sql="create table #probe (i int);\\nset language Deutsch;\\n", dsn=dsn)
+assert first.success, first.errors
+second = execsql.run(
+    sql="select case when object_id('tempdb..#probe') is null then 'gone' else 'kept' end as probe"
+    " into #seen;\\n-- !x! subdata probe #seen\\n"
+    "select @@LANGUAGE as lang into #lang;\\n-- !x! subdata lang #lang\\n",
+    dsn=dsn,
+)
+assert second.success, second.errors
+print(second.variables["probe"], second.variables["lang"])
+"""
+    proc = subprocess.run([sys.executable, "-c", code], capture_output=True, text=True, timeout=120, check=False)
+    assert proc.returncode == 0, proc.stderr
+    assert proc.stdout.split() == ["gone", "us_english"]

{execsql2-2.31.1 → execsql2-2.31.2}/uv.lock

@@ -912,7 +912,7 @@ wheels = [
 
 [[package]]
 name = "execsql2"
-version = "2.31.1"
+version = "2.31.2"
 source = { editable = "." }
 dependencies = [
     { name = "python-dateutil" },