sqlspec 0.54.1__tar.gz → 0.54.3__tar.gz

{sqlspec-0.54.1 → sqlspec-0.54.3}/Makefile

@@ -67,6 +67,7 @@ destroy:                                            ## Destroy the virtual envir
 	@echo "${INFO} Destroying virtual environment... 🗑️"
 	@uv run pre-commit clean >/dev/null 2>&1
 	@rm -rf .venv
+	@find sqlspec \( -name '*.so' -o -name '*.c' \) -delete >/dev/null 2>&1 || true
 	@echo "${OK} Virtual environment destroyed 🗑️"
 
 # =============================================================================

{sqlspec-0.54.1 → sqlspec-0.54.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlspec
-Version: 0.54.1
+Version: 0.54.3
 Summary: SQL Experiments in Python
 Project-URL: Discord, https://discord.gg/litestar
 Project-URL: Issue, https://github.com/litestar-org/sqlspec/issues/

{sqlspec-0.54.1 → sqlspec-0.54.3}/pyproject.toml

@@ -24,7 +24,7 @@ maintainers = [{ name = "Litestar Developers", email = "hello@litestar.dev" }]
 name = "sqlspec"
 readme = "README.md"
 requires-python = ">=3.10, <4.0"
-version = "0.54.1"
+version = "0.54.3"
 
 [project.urls]
 Discord = "https://discord.gg/litestar"
@@ -197,7 +197,6 @@ packages = ["sqlspec"]
 # Keep that smoke build from auto-discovering ignored scratch directories.
 packages = []
 
-
 [tool.hatch.build.targets.wheel.hooks.mypyc]
 dependencies = ["hatch-mypyc", "hatch-cython", "mypy>=2.0.0"]
 enable-by-default = false
@@ -308,7 +307,7 @@ opt_level = "3"   # Maximum optimization (0-3)
 allow_dirty = true
 commit = false
 commit_args = "--no-verify"
-current_version = "0.54.1"
+current_version = "0.54.3"
 ignore_missing_files = false
 ignore_missing_version = false
 message = "chore(release): bump to v{new_version}"

{sqlspec-0.54.1 → sqlspec-0.54.3}/sqlspec/adapters/aiosqlite/driver.py

@@ -26,7 +26,13 @@ from sqlspec.adapters.aiosqlite.core import (
 from sqlspec.adapters.aiosqlite.data_dictionary import AiosqliteDataDictionary
 from sqlspec.core import ArrowResult, ParameterStyle, TypedParameter, get_cache_config, register_driver_profile
 from sqlspec.core.result import DMLResult
-from sqlspec.driver import AsyncDriverAdapterBase, AsyncRowStream, BaseAsyncExceptionHandler
+from sqlspec.driver import (
+    AsyncDriverAdapterBase,
+    AsyncRowStream,
+    BaseAsyncExceptionHandler,
+    parameter_value_needs_processing,
+    type_coercion_fallbacks,
+)
 from sqlspec.exceptions import SQLSpecError
 from sqlspec.utils.type_guards import resolve_row_format
 
@@ -259,6 +265,7 @@ class AiosqliteDriver(AsyncDriverAdapterBase):
         row_len = len(first_sequence)
         coercion_map = type_coercion_map
         has_type_coercion = bool(coercion_map)
+        fallback_items = type_coercion_fallbacks(coercion_map) if coercion_map else ()
 
         if row_len == 1:
             if has_type_coercion and coercion_map is not None:
@@ -268,8 +275,7 @@ class AiosqliteDriver(AsyncDriverAdapterBase):
                         return False
                     if len(sequence) != 1:
                         return False
-                    value_type = type(sequence[0])
-                    if value_type is TypedParameter or value_type in coercion_map:
+                    if parameter_value_needs_processing(sequence[0], coercion_map, fallback_items):
                         return False
                 return True
 
@@ -291,8 +297,7 @@ class AiosqliteDriver(AsyncDriverAdapterBase):
                 if len(sequence) != row_len:
                     return False
                 for value in sequence:
-                    value_type = type(value)
-                    if value_type is TypedParameter or value_type in coercion_map:
+                    if parameter_value_needs_processing(value, coercion_map, fallback_items):
                         return False
             return True
 

{sqlspec-0.54.1 → sqlspec-0.54.3}/sqlspec/adapters/oracledb/litestar/store.py

@@ -1,6 +1,6 @@
 """Oracle session store for Litestar integration."""
 
-from datetime import datetime, timedelta, timezone
+from datetime import timedelta, timezone
 from typing import TYPE_CHECKING
 
 from sqlspec.extensions.litestar.store import BaseSQLSpecStore
@@ -16,6 +16,17 @@ __all__ = ("OracleAsyncStore", "OracleSyncStore")
 ORACLE_SMALL_BLOB_LIMIT = 32000
 
 
+def _oracle_expiry_seconds(expires_in: "int | timedelta | None") -> "int | None":
+    """Convert a session TTL value to whole seconds for Oracle interval binds."""
+    if expires_in is None:
+        return None
+
+    expires_in_seconds = int(expires_in.total_seconds()) if isinstance(expires_in, timedelta) else int(expires_in)
+    if expires_in_seconds <= 0:
+        return None
+    return expires_in_seconds
+
+
 def _coerce_bytes_payload(value: object) -> bytes:
     """Coerce a payload into bytes for session storage."""
     if value is None:
@@ -170,14 +181,18 @@ class OracleAsyncStore(BaseSQLSpecStore["OracleAsyncConfig"]):
             data_blob, expires_at = row
 
             if renew_for is not None and expires_at is not None:
-                new_expires_at = self._calculate_expires_at(renew_for)
-                if new_expires_at is not None:
+                expires_in_seconds = _oracle_expiry_seconds(renew_for)
+                if expires_in_seconds is not None:
                     update_sql = f"""
                     UPDATE {self._table_name}
-                    SET expires_at = :expires_at, updated_at = SYSTIMESTAMP
+                    SET expires_at = CASE
+                            WHEN :expires_in_seconds IS NULL THEN NULL
+                            ELSE SYSTIMESTAMP + NUMTODSINTERVAL(:expires_in_seconds, 'SECOND')
+                        END,
+                        updated_at = SYSTIMESTAMP
                     WHERE session_id = :session_id
                     """
-                    await cursor.execute(update_sql, {"expires_at": new_expires_at, "session_id": key})
+                    await cursor.execute(update_sql, {"expires_in_seconds": expires_in_seconds, "session_id": key})
                     await conn.commit()
 
             return await _read_blob_async(data_blob)
@@ -191,7 +206,7 @@ class OracleAsyncStore(BaseSQLSpecStore["OracleAsyncConfig"]):
             expires_in: Time until expiration.
         """
         data = self._value_to_bytes(value)
-        expires_at = self._calculate_expires_at(expires_in)
+        expires_in_seconds = _oracle_expiry_seconds(expires_in)
 
         conn_context = self._config.provide_connection()
         async with conn_context as conn:
@@ -205,13 +220,25 @@ class OracleAsyncStore(BaseSQLSpecStore["OracleAsyncConfig"]):
                 WHEN MATCHED THEN
                     UPDATE SET
                         data = EMPTY_BLOB(),
-                        expires_at = :expires_at,
+                        expires_at = CASE
+                            WHEN :expires_in_seconds IS NULL THEN NULL
+                            ELSE SYSTIMESTAMP + NUMTODSINTERVAL(:expires_in_seconds, 'SECOND')
+                        END,
                         updated_at = SYSTIMESTAMP
                 WHEN NOT MATCHED THEN
                     INSERT (session_id, data, expires_at, created_at, updated_at)
-                    VALUES (:session_id, EMPTY_BLOB(), :expires_at, SYSTIMESTAMP, SYSTIMESTAMP)
+                    VALUES (
+                        :session_id,
+                        EMPTY_BLOB(),
+                        CASE
+                            WHEN :expires_in_seconds IS NULL THEN NULL
+                            ELSE SYSTIMESTAMP + NUMTODSINTERVAL(:expires_in_seconds, 'SECOND')
+                        END,
+                        SYSTIMESTAMP,
+                        SYSTIMESTAMP
+                    )
                 """
-                await cursor.execute(merge_sql, {"session_id": key, "expires_at": expires_at})
+                await cursor.execute(merge_sql, {"session_id": key, "expires_in_seconds": expires_in_seconds})
 
                 select_sql = f"""
                 SELECT data FROM {self._table_name}
@@ -232,13 +259,25 @@ class OracleAsyncStore(BaseSQLSpecStore["OracleAsyncConfig"]):
                 WHEN MATCHED THEN
                     UPDATE SET
                         data = :data,
-                        expires_at = :expires_at,
+                        expires_at = CASE
+                            WHEN :expires_in_seconds IS NULL THEN NULL
+                            ELSE SYSTIMESTAMP + NUMTODSINTERVAL(:expires_in_seconds, 'SECOND')
+                        END,
                         updated_at = SYSTIMESTAMP
                 WHEN NOT MATCHED THEN
                     INSERT (session_id, data, expires_at, created_at, updated_at)
-                    VALUES (:session_id, :data, :expires_at, SYSTIMESTAMP, SYSTIMESTAMP)
+                    VALUES (
+                        :session_id,
+                        :data,
+                        CASE
+                            WHEN :expires_in_seconds IS NULL THEN NULL
+                            ELSE SYSTIMESTAMP + NUMTODSINTERVAL(:expires_in_seconds, 'SECOND')
+                        END,
+                        SYSTIMESTAMP,
+                        SYSTIMESTAMP
+                    )
                 """
-                await cursor.execute(sql, {"session_id": key, "data": data, "expires_at": expires_at})
+                await cursor.execute(sql, {"session_id": key, "data": data, "expires_in_seconds": expires_in_seconds})
                 await conn.commit()
 
     async def delete(self, key: str) -> None:
@@ -298,7 +337,7 @@ class OracleAsyncStore(BaseSQLSpecStore["OracleAsyncConfig"]):
             Seconds until expiration, or None if no expiry or key doesn't exist.
         """
         sql = f"""
-        SELECT expires_at FROM {self._table_name}
+        SELECT expires_at, SYSTIMESTAMP FROM {self._table_name}
         WHERE session_id = :session_id
         """
 
@@ -311,17 +350,17 @@ class OracleAsyncStore(BaseSQLSpecStore["OracleAsyncConfig"]):
             if row is None or row[0] is None:
                 return None
 
-            expires_at = row[0]
+            expires_at, db_now = row
 
             if expires_at.tzinfo is None:
                 expires_at = expires_at.replace(tzinfo=timezone.utc)
+            if db_now.tzinfo is None:
+                db_now = db_now.replace(tzinfo=timezone.utc)
 
-            now = datetime.now(timezone.utc)
-
-            if expires_at <= now:
+            if expires_at <= db_now:
                 return 0
 
-            delta = expires_at - now
+            delta = expires_at - db_now
             return int(delta.total_seconds())
 
     async def delete_expired(self) -> int:
@@ -468,14 +507,18 @@ class OracleSyncStore(BaseSQLSpecStore["OracleSyncConfig"]):
             data_blob, expires_at = row
 
             if renew_for is not None and expires_at is not None:
-                new_expires_at = self._calculate_expires_at(renew_for)
-                if new_expires_at is not None:
+                expires_in_seconds = _oracle_expiry_seconds(renew_for)
+                if expires_in_seconds is not None:
                     update_sql = f"""
                     UPDATE {self._table_name}
-                    SET expires_at = :expires_at, updated_at = SYSTIMESTAMP
+                    SET expires_at = CASE
+                            WHEN :expires_in_seconds IS NULL THEN NULL
+                            ELSE SYSTIMESTAMP + NUMTODSINTERVAL(:expires_in_seconds, 'SECOND')
+                        END,
+                        updated_at = SYSTIMESTAMP
                     WHERE session_id = :session_id
                     """
-                    cursor.execute(update_sql, {"expires_at": new_expires_at, "session_id": key})
+                    cursor.execute(update_sql, {"expires_in_seconds": expires_in_seconds, "session_id": key})
                     conn.commit()
 
             return _read_blob_sync(data_blob)
@@ -495,7 +538,7 @@ class OracleSyncStore(BaseSQLSpecStore["OracleSyncConfig"]):
     def _set(self, key: str, value: "str | bytes", expires_in: "int | timedelta | None" = None) -> None:
         """Synchronous implementation of set."""
         data = self._value_to_bytes(value)
-        expires_at = self._calculate_expires_at(expires_in)
+        expires_in_seconds = _oracle_expiry_seconds(expires_in)
 
         with self._config.provide_connection() as conn:
             cursor = conn.cursor()
@@ -508,13 +551,25 @@ class OracleSyncStore(BaseSQLSpecStore["OracleSyncConfig"]):
                 WHEN MATCHED THEN
                     UPDATE SET
                         data = EMPTY_BLOB(),
-                        expires_at = :expires_at,
+                        expires_at = CASE
+                            WHEN :expires_in_seconds IS NULL THEN NULL
+                            ELSE SYSTIMESTAMP + NUMTODSINTERVAL(:expires_in_seconds, 'SECOND')
+                        END,
                         updated_at = SYSTIMESTAMP
                 WHEN NOT MATCHED THEN
                     INSERT (session_id, data, expires_at, created_at, updated_at)
-                    VALUES (:session_id, EMPTY_BLOB(), :expires_at, SYSTIMESTAMP, SYSTIMESTAMP)
+                    VALUES (
+                        :session_id,
+                        EMPTY_BLOB(),
+                        CASE
+                            WHEN :expires_in_seconds IS NULL THEN NULL
+                            ELSE SYSTIMESTAMP + NUMTODSINTERVAL(:expires_in_seconds, 'SECOND')
+                        END,
+                        SYSTIMESTAMP,
+                        SYSTIMESTAMP
+                    )
                 """
-                cursor.execute(merge_sql, {"session_id": key, "expires_at": expires_at})
+                cursor.execute(merge_sql, {"session_id": key, "expires_in_seconds": expires_in_seconds})
 
                 select_sql = f"""
                 SELECT data FROM {self._table_name}
@@ -535,13 +590,25 @@ class OracleSyncStore(BaseSQLSpecStore["OracleSyncConfig"]):
                 WHEN MATCHED THEN
                     UPDATE SET
                         data = :data,
-                        expires_at = :expires_at,
+                        expires_at = CASE
+                            WHEN :expires_in_seconds IS NULL THEN NULL
+                            ELSE SYSTIMESTAMP + NUMTODSINTERVAL(:expires_in_seconds, 'SECOND')
+                        END,
                         updated_at = SYSTIMESTAMP
                 WHEN NOT MATCHED THEN
                     INSERT (session_id, data, expires_at, created_at, updated_at)
-                    VALUES (:session_id, :data, :expires_at, SYSTIMESTAMP, SYSTIMESTAMP)
+                    VALUES (
+                        :session_id,
+                        :data,
+                        CASE
+                            WHEN :expires_in_seconds IS NULL THEN NULL
+                            ELSE SYSTIMESTAMP + NUMTODSINTERVAL(:expires_in_seconds, 'SECOND')
+                        END,
+                        SYSTIMESTAMP,
+                        SYSTIMESTAMP
+                    )
                 """
-                cursor.execute(sql, {"session_id": key, "data": data, "expires_at": expires_at})
+                cursor.execute(sql, {"session_id": key, "data": data, "expires_in_seconds": expires_in_seconds})
                 conn.commit()
 
     async def set(self, key: str, value: "str | bytes", expires_in: "int | timedelta | None" = None) -> None:
@@ -613,7 +680,7 @@ class OracleSyncStore(BaseSQLSpecStore["OracleSyncConfig"]):
     def _expires_in(self, key: str) -> "int | None":
         """Synchronous implementation of expires_in."""
         sql = f"""
-        SELECT expires_at FROM {self._table_name}
+        SELECT expires_at, SYSTIMESTAMP FROM {self._table_name}
         WHERE session_id = :session_id
         """
 
@@ -625,17 +692,17 @@ class OracleSyncStore(BaseSQLSpecStore["OracleSyncConfig"]):
             if row is None or row[0] is None:
                 return None
 
-            expires_at = row[0]
+            expires_at, db_now = row
 
             if expires_at.tzinfo is None:
                 expires_at = expires_at.replace(tzinfo=timezone.utc)
+            if db_now.tzinfo is None:
+                db_now = db_now.replace(tzinfo=timezone.utc)
 
-            now = datetime.now(timezone.utc)
-
-            if expires_at <= now:
+            if expires_at <= db_now:
                 return 0
 
-            delta = expires_at - now
+            delta = expires_at - db_now
             return int(delta.total_seconds())
 
     async def expires_in(self, key: str) -> "int | None":

{sqlspec-0.54.1 → sqlspec-0.54.3}/sqlspec/adapters/psqlpy/core.py

@@ -644,7 +644,7 @@ def build_insert_statement(table: str, columns: "list[str]") -> str:
 
 def _sequence_needs_numeric_coercion(values: "list[Any] | tuple[Any, ...]") -> bool:
     """Return True when any value in a parameter sequence needs numeric coercion."""
-    return any(type(value) in _NUMERIC_COERCE_TYPES for value in values)
+    return any(isinstance(value, _NUMERIC_COERCE_TYPES) for value in values)
 
 
 def _format_execute_many_param_set(param_set: Any, *, coerce_numeric: bool) -> "list[Any]":

{sqlspec-0.54.1 → sqlspec-0.54.3}/sqlspec/adapters/sqlite/driver.py

@@ -19,7 +19,13 @@ from sqlspec.adapters.sqlite.core import (
 from sqlspec.adapters.sqlite.data_dictionary import SqliteDataDictionary
 from sqlspec.core import ArrowResult, ParameterStyle, TypedParameter, get_cache_config, register_driver_profile
 from sqlspec.core.result import DMLResult
-from sqlspec.driver import BaseSyncExceptionHandler, SyncDriverAdapterBase, SyncRowStream
+from sqlspec.driver import (
+    BaseSyncExceptionHandler,
+    SyncDriverAdapterBase,
+    SyncRowStream,
+    parameter_value_needs_processing,
+    type_coercion_fallbacks,
+)
 from sqlspec.exceptions import SQLSpecError
 from sqlspec.utils.type_guards import resolve_row_format
 
@@ -284,6 +290,7 @@ class SqliteDriver(SyncDriverAdapterBase):
         row_len = len(first_sequence)
         coercion_map = type_coercion_map
         has_type_coercion = bool(coercion_map)
+        fallback_items = type_coercion_fallbacks(coercion_map) if coercion_map else ()
 
         # Common benchmark shape: list[tuple[value]]
         if row_len == 1:
@@ -294,8 +301,7 @@ class SqliteDriver(SyncDriverAdapterBase):
                         return False
                     if len(sequence) != 1:
                         return False
-                    value_type = type(sequence[0])
-                    if value_type is TypedParameter or value_type in coercion_map:
+                    if parameter_value_needs_processing(sequence[0], coercion_map, fallback_items):
                         return False
                 return True
 
@@ -317,8 +323,7 @@ class SqliteDriver(SyncDriverAdapterBase):
                 if len(sequence) != row_len:
                     return False
                 for value in sequence:
-                    value_type = type(value)
-                    if value_type is TypedParameter or value_type in coercion_map:
+                    if parameter_value_needs_processing(value, coercion_map, fallback_items):
                         return False
             return True
 

{sqlspec-0.54.1 → sqlspec-0.54.3}/sqlspec/core/cache.py

@@ -30,6 +30,8 @@ if TYPE_CHECKING:
 
     import sqlglot.expressions as exp
 
+    from sqlspec.core.parameters import ParameterProfile
+
 
 __all__ = (
     "CacheConfig",
@@ -581,24 +583,40 @@ class CachedStatement:
     where drivers require list type.
     """
 
-    __slots__ = ("compiled_sql", "expression", "parameters")
+    __slots__ = (
+        "applied_wrap_types",
+        "compiled_sql",
+        "expression",
+        "input_named_parameters",
+        "parameter_profile",
+        "parameters",
+    )
 
     def __init__(
         self,
         compiled_sql: str,
         parameters: "tuple[Any, ...] | list[Any] | dict[str, Any] | None",
         expression: "exp.Expr | None",
+        input_named_parameters: "tuple[str, ...] | None" = None,
+        parameter_profile: "ParameterProfile | None" = None,
+        applied_wrap_types: bool = False,
     ) -> None:
+        self.applied_wrap_types = applied_wrap_types
         self.compiled_sql = compiled_sql
-        self.parameters = parameters
         self.expression = expression
+        self.input_named_parameters = input_named_parameters or ()
+        self.parameter_profile = parameter_profile
+        self.parameters = parameters
 
     def __repr__(self) -> str:
         return (
             "CachedStatement("
             f"compiled_sql={self.compiled_sql!r}, "
             f"parameters={self.parameters!r}, "
-            f"expression={self.expression!r})"
+            f"expression={self.expression!r}, "
+            f"input_named_parameters={self.input_named_parameters!r}, "
+            f"parameter_profile={self.parameter_profile!r}, "
+            f"applied_wrap_types={self.applied_wrap_types!r})"
         )
 
     def __eq__(self, other: object) -> bool:
@@ -608,10 +626,20 @@ class CachedStatement:
             self.compiled_sql == other.compiled_sql
             and self.parameters == other.parameters
             and self.expression == other.expression
+            and self.input_named_parameters == other.input_named_parameters
+            and self.parameter_profile == other.parameter_profile
+            and self.applied_wrap_types == other.applied_wrap_types
         )
 
     def __hash__(self) -> int:
-        return hash((self.compiled_sql, self.parameters, self.expression))
+        return hash((
+            self.compiled_sql,
+            self.parameters,
+            self.expression,
+            self.input_named_parameters,
+            self.parameter_profile,
+            self.applied_wrap_types,
+        ))
 
 
 def create_cache_key(namespace: str, key: str, dialect: str | None = None) -> str:

{sqlspec-0.54.1 → sqlspec-0.54.3}/sqlspec/core/result/_base.py

@@ -71,7 +71,17 @@ class StatementResult(ABC, Iterable[Any]):
         metadata: Additional metadata about the operation.
     """
 
-    __slots__ = ("data", "execution_time", "last_inserted_id", "metadata", "rows_affected", "statement")
+    __slots__ = (
+        "_operation_type",
+        "data",
+        "execution_time",
+        "last_inserted_id",
+        "metadata",
+        "rows_affected",
+        "statement",
+    )
+
+    _operation_type: "OperationType"
 
     def __init__(
         self,
@@ -93,6 +103,7 @@ class StatementResult(ABC, Iterable[Any]):
             metadata: Additional metadata about the operation.
         """
         self.statement = statement
+        self._operation_type = statement.operation_type
         self.data = data
         self.rows_affected = rows_affected
         self.last_inserted_id = last_inserted_id
@@ -147,7 +158,7 @@ class StatementResult(ABC, Iterable[Any]):
         Returns:
             The type of SQL operation that produced this result.
         """
-        return self.statement.operation_type
+        return self._operation_type
 
 
 @mypyc_attr(allow_interpreted_subclasses=False)
@@ -163,7 +174,6 @@ class SQLResult(StatementResult):
 
     __slots__ = (
         "_materialized_dicts",
-        "_operation_type",
         "_row_format",
         "_schema_row_cache",
         "_schema_rows_cache",
@@ -180,8 +190,6 @@ class SQLResult(StatementResult):
         "total_statements",
     )
 
-    _operation_type: "OperationType"
-
     def __init__(
         self,
         statement: "SQL",
@@ -260,15 +268,6 @@ class SQLResult(StatementResult):
         if self.total_count is None:
             self.total_count = len(data) if data is not None else 0
 
-    @property
-    def operation_type(self) -> "OperationType":
-        """Get operation type for this result.
-
-        Returns:
-            The type of SQL operation that produced this result.
-        """
-        return self._operation_type
-
     def _get_rows(self) -> "list[dict[str, Any]]":
         """Get row data as list of dicts, materializing lazily from raw format.