sqlspec 0.13.1__py3-none-any.whl → 0.14.1__py3-none-any.whl

sqlspec/utils/__init__.py

@@ -1,3 +1,4 @@
 from sqlspec.utils import deprecation, fixtures, module_loader, singleton, sync_tools, text
+from sqlspec.utils.statement_hashing import hash_expression
 
-__all__ = ("deprecation", "fixtures", "module_loader", "singleton", "sync_tools", "text")
+__all__ = ("deprecation", "fixtures", "hash_expression", "module_loader", "singleton", "sync_tools", "text")

sqlspec/utils/statement_hashing.py

@@ -0,0 +1,203 @@
+"""Statement hashing utilities for cache key generation.
+
+This module provides centralized hashing logic for SQL statements,
+including expressions, parameters, filters, and complete SQL objects.
+"""
+
+from typing import TYPE_CHECKING, Any, Optional
+
+from sqlglot import exp
+
+if TYPE_CHECKING:
+    from sqlspec.statement.filters import StatementFilter
+    from sqlspec.statement.sql import SQL
+
+__all__ = ("hash_expression", "hash_parameters", "hash_sql_statement")
+
+
+def hash_expression(expr: Optional[exp.Expression], _seen: Optional[set[int]] = None) -> int:
+    """Generate deterministic hash from AST structure.
+
+    Args:
+        expr: SQLGlot Expression to hash
+        _seen: Set of seen object IDs to handle circular references
+
+    Returns:
+        Deterministic hash of the AST structure
+    """
+    if expr is None:
+        return hash(None)
+
+    if _seen is None:
+        _seen = set()
+
+    expr_id = id(expr)
+    if expr_id in _seen:
+        return hash(expr_id)
+
+    _seen.add(expr_id)
+
+    # Build hash from type and args
+    components: list[Any] = [type(expr).__name__]
+
+    for key, value in sorted(expr.args.items()):
+        components.extend((key, _hash_value(value, _seen)))
+
+    return hash(tuple(components))
+
+
+def _hash_value(value: Any, _seen: set[int]) -> int:
+    """Hash different value types consistently.
+
+    Args:
+        value: Value to hash (can be Expression, list, dict, or primitive)
+        _seen: Set of seen object IDs to handle circular references
+
+    Returns:
+        Deterministic hash of the value
+    """
+    if isinstance(value, exp.Expression):
+        return hash_expression(value, _seen)
+    if isinstance(value, list):
+        return hash(tuple(_hash_value(v, _seen) for v in value))
+    if isinstance(value, dict):
+        items = sorted((k, _hash_value(v, _seen)) for k, v in value.items())
+        return hash(tuple(items))
+    if isinstance(value, tuple):
+        return hash(tuple(_hash_value(v, _seen) for v in value))
+    # Primitives: str, int, bool, None, etc.
+    return hash(value)
+
+
+def hash_parameters(
+    positional_params: Optional[list[Any]] = None,
+    named_params: Optional[dict[str, Any]] = None,
+    original_parameters: Optional[Any] = None,
+) -> int:
+    """Generate hash for SQL parameters.
+
+    Args:
+        positional_params: List of positional parameters
+        named_params: Dictionary of named parameters
+        original_parameters: Original parameters (for execute_many)
+
+    Returns:
+        Combined hash of all parameters
+    """
+    param_hash = 0
+
+    # Hash positional parameters
+    if positional_params:
+        # Handle unhashable types like lists
+        hashable_params = []
+        for param in positional_params:
+            if isinstance(param, (list, dict)):
+                # Convert unhashable types to hashable representations
+                hashable_params.append(repr(param))
+            else:
+                hashable_params.append(param)
+        param_hash ^= hash(tuple(hashable_params))
+
+    # Hash named parameters
+    if named_params:
+        # Handle unhashable types in named params
+        hashable_items = []
+        for key, value in sorted(named_params.items()):
+            if isinstance(value, (list, dict)):
+                hashable_items.append((key, repr(value)))
+            else:
+                hashable_items.append((key, value))
+        param_hash ^= hash(tuple(hashable_items))
+
+    # Hash original parameters (important for execute_many)
+    if original_parameters is not None:
+        if isinstance(original_parameters, list):
+            # For execute_many, hash the count and first few items to avoid
+            # performance issues with large parameter sets
+            param_hash ^= hash(("original_count", len(original_parameters)))
+            if original_parameters:
+                # Hash first 3 items as representatives
+                sample_size = min(3, len(original_parameters))
+                sample_hash = hash(repr(original_parameters[:sample_size]))
+                param_hash ^= hash(("original_sample", sample_hash))
+        else:
+            param_hash ^= hash(("original", repr(original_parameters)))
+
+    return param_hash
+
+
+def hash_filters(filters: Optional[list["StatementFilter"]] = None) -> int:
+    """Generate hash for statement filters.
+
+    Args:
+        filters: List of statement filters
+
+    Returns:
+        Hash of the filters
+    """
+    if not filters:
+        return 0
+
+    # Use class names and any hashable attributes
+    filter_components = []
+    for f in filters:
+        # Use class name as primary identifier
+        components: list[Any] = [f.__class__.__name__]
+
+        # Add any hashable attributes if available
+        if hasattr(f, "__dict__"):
+            for key, value in sorted(f.__dict__.items()):
+                try:
+                    # Try to hash the value
+                    hash(value)
+                    components.append((key, value))
+                except TypeError:  # noqa: PERF203
+                    # If not hashable, use repr
+                    components.append((key, repr(value)))
+
+        filter_components.append(tuple(components))
+
+    return hash(tuple(filter_components))
+
+
+def hash_sql_statement(statement: "SQL") -> str:
+    """Generate a complete cache key for a SQL statement.
+
+    This centralizes all the complex hashing logic that was previously
+    scattered across different parts of the codebase.
+
+    Args:
+        statement: SQL statement object
+
+    Returns:
+        Cache key string
+    """
+    from sqlspec.utils.type_guards import is_expression
+
+    # Hash the expression or raw SQL
+    if is_expression(statement._statement):
+        expr_hash = hash_expression(statement._statement)
+    else:
+        expr_hash = hash(statement._raw_sql)
+
+    # Hash all parameters
+    param_hash = hash_parameters(
+        positional_params=statement._positional_params,
+        named_params=statement._named_params,
+        original_parameters=statement._original_parameters,
+    )
+
+    # Hash filters
+    filter_hash = hash_filters(statement._filters)
+
+    # Combine with other state
+    state_components = [
+        expr_hash,
+        param_hash,
+        filter_hash,
+        hash(statement._dialect),  # Use _dialect instead of _config.dialect
+        hash(statement._is_many),
+        hash(statement._is_script),
+    ]
+
+    return f"sql:{hash(tuple(state_components))}"

sqlspec/utils/type_guards.py

@@ -69,11 +69,15 @@ __all__ = (
     "extract_dataclass_items",
     "has_bytes_conversion",
     "has_dict_attribute",
+    "has_expression_attr",
     "has_expressions",
+    "has_parameter_builder",
     "has_parameter_value",
     "has_query_builder_parameters",
     "has_risk_level",
     "has_sql_method",
+    "has_sqlglot_expression",
+    "has_to_statement",
     "has_with_method",
     "is_async_closeable_connection",
     "is_async_copy_capable",
@@ -890,3 +894,31 @@ def is_object_store_item(obj: Any) -> "TypeGuard[ObjectStoreItemProtocol]":
     from sqlspec.protocols import ObjectStoreItemProtocol
 
     return isinstance(obj, ObjectStoreItemProtocol)
+
+
+def has_sqlglot_expression(obj: Any) -> "TypeGuard[Any]":
+    """Check if an object has a sqlglot_expression property."""
+    from sqlspec.protocols import HasSQLGlotExpressionProtocol
+
+    return isinstance(obj, HasSQLGlotExpressionProtocol)
+
+
+def has_parameter_builder(obj: Any) -> "TypeGuard[Any]":
+    """Check if an object has an add_parameter method."""
+    from sqlspec.protocols import HasParameterBuilderProtocol
+
+    return isinstance(obj, HasParameterBuilderProtocol)
+
+
+def has_expression_attr(obj: Any) -> "TypeGuard[Any]":
+    """Check if an object has an _expression attribute."""
+    from sqlspec.protocols import HasExpressionProtocol
+
+    return isinstance(obj, HasExpressionProtocol)
+
+
+def has_to_statement(obj: Any) -> "TypeGuard[Any]":
+    """Check if an object has a to_statement method."""
+    from sqlspec.protocols import HasToStatementProtocol
+
+    return isinstance(obj, HasToStatementProtocol)

{sqlspec-0.13.1.dist-info → sqlspec-0.14.1.dist-info}/METADATA

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

sqlspec-0.14.1.dist-info/RECORD

@@ -0,0 +1,145 @@
+sqlspec/__init__.py,sha256=SEPpbVPjSiF9kS4FpowO7S0jm8YNMD9FiX-5lrrCbY0,1676
+sqlspec/__main__.py,sha256=tdu1ldelPAReNMbglVkTg7SVTEMTtxW1Ik3kLKdUonw,252
+sqlspec/__metadata__.py,sha256=hNP3wXvtk8fQVPKGjRLpZ9mP-gaPJqzrmgm3UqpDIXQ,460
+sqlspec/_serialization.py,sha256=7zox4G9zIps-DCdIEwYs4gwALfEOy1g_sWS4r5kpzO8,2604
+sqlspec/_sql.py,sha256=zqMtVWBZzbnNErB8VyJkjDCPq0RNkhGUPA2ZCOtzmGo,35759
+sqlspec/_typing.py,sha256=Vn1CTCfedAHZV3pKZP-l_mPw9pTxesCzRKVRypzNY_k,17903
+sqlspec/base.py,sha256=a7adbCUzohf1MU-iP0TxazGsk9fsJhJmxuFKNWkgC6o,18355
+sqlspec/cli.py,sha256=V8dYi286yXsrZg-w8vsh9OWKngViYCQJejujLjoV5co,9980
+sqlspec/config.py,sha256=IfjXcHFXmGseUcMsf4eEHgeh7oOc2EEIg34R7BC62UI,13144
+sqlspec/exceptions.py,sha256=T2h-tCN05sRKSpXDjPtYXvNgwInNVzTpha1PIkSUROQ,14168
+sqlspec/loader.py,sha256=sR8hSbxbuo3QFC0YoIaT9Xf05QNqtG_WX912IG56kas,15353
+sqlspec/protocols.py,sha256=Uum9tliNG6MOcXBK6KRBmkWGikhEAzH2qIAgZITXd1U,18094
+sqlspec/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sqlspec/typing.py,sha256=qkUcvruNzRUUfpv4AkbQezpy9SokhVHXlMbfFNwQlnU,8721
+sqlspec/adapters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sqlspec/adapters/adbc/__init__.py,sha256=v9bs7501PgEyzR1XIsEpE2Wdrj9DOYkZ4grysw72UXk,218
+sqlspec/adapters/adbc/config.py,sha256=LjcVqN3DUOxxz7u2j6o3DhIq4srS7TJrcUqQ86FFBGs,19898
+sqlspec/adapters/adbc/driver.py,sha256=xHjeDukF8P9y491037kF7pt3mleb4jBHh8yIeiDG36c,17940
+sqlspec/adapters/adbc/transformers.py,sha256=97L-5z278TSkjkK0fucDYb5i5G4WZheMkU8hlF53_Fk,4880
+sqlspec/adapters/aiosqlite/__init__.py,sha256=7wPmhXQeu4jRi-LZzPxAPTdgRmgmyqCn9U-4wnCWoLM,258
+sqlspec/adapters/aiosqlite/config.py,sha256=Rg2RduE5wLM7JkEITtQg6kJQ2n6YVgKsl0S-io-18n0,7246
+sqlspec/adapters/aiosqlite/driver.py,sha256=40c3YVO9UcnUDSlqwEpuI2CNMzsufR4WVGeUKBMcnMY,12176
+sqlspec/adapters/asyncmy/__init__.py,sha256=zYpebEt_PrNCifLcqXiCcWVm0Zl-LvWbFDromWwSTw8,270
+sqlspec/adapters/asyncmy/config.py,sha256=jYeF80DKdd5arS4kSPz4hcpLnzv1WgQa5s9DmEy02OU,10155
+sqlspec/adapters/asyncmy/driver.py,sha256=-rZcBj-gbJ6r3qZQzltqfOHyA70iSg9r4XtieuLliGg,10571
+sqlspec/adapters/asyncpg/__init__.py,sha256=svnbKlOin8jRL88AdAqflBEU-WEAzp0Thc2y50QsxIo,310
+sqlspec/adapters/asyncpg/config.py,sha256=8fKZ55YynepP7eC6A0Z3jpXcGVoSuLW9yGUH04O2a4A,11857
+sqlspec/adapters/asyncpg/driver.py,sha256=sfoxCkHzJvRuE5kNRUH--zCecf2kcqNnDz9OIYsLv54,18629
+sqlspec/adapters/bigquery/__init__.py,sha256=fWRH-BoCNX4rYwhU2DK64cXWpfkYpWIExddJAti0bxM,250
+sqlspec/adapters/bigquery/config.py,sha256=z6FFWUvk3AdXcPRmOYf1lg-UlBqCq8EEDcxDz8-lI0Y,15773
+sqlspec/adapters/bigquery/driver.py,sha256=zUZGGOuzQ4M4Ekt0H59UUQvX8AT4i-YUalkp2Ql6lKo,30956
+sqlspec/adapters/duckdb/__init__.py,sha256=I1f6szfpKKrq6WhyDoUXD3i3NN4yjsh94_fhP1URI5M,351
+sqlspec/adapters/duckdb/config.py,sha256=5k2fgJN1yTZuq4I0VRyIaiMno507sd6R_sl5G8sgpsI,18974
+sqlspec/adapters/duckdb/driver.py,sha256=499tJ9xLj_09MDmnhuGHPiknzT7OFhCmorxB1yHXvXs,19051
+sqlspec/adapters/oracledb/__init__.py,sha256=nn3whn0UyBThoXnE1-5_byVuc9PJjvB2P896p7LpNZI,474
+sqlspec/adapters/oracledb/config.py,sha256=IRIwiWOo0BWoilGxtkrGNZEzVc8o8JqBQXSWdQoKgK8,22017
+sqlspec/adapters/oracledb/driver.py,sha256=S7AyrOk1YbtGsdwrRJJi9-iI2hsBBE8rE67Tlw2kXMY,25790
+sqlspec/adapters/psqlpy/__init__.py,sha256=dp0-96V4SAbNEvOqlJ8PWEyJMYzZGElVoyneZqJ-fbQ,297
+sqlspec/adapters/psqlpy/config.py,sha256=7sM-RGEVpkJLHrX7DemlreL7spJdcrVZ0dDQSMDyt4k,15309
+sqlspec/adapters/psqlpy/driver.py,sha256=GifEdVZKgqKaN0pajWCpZVvW0bKNRXeMZUhcNu-tetQ,10839
+sqlspec/adapters/psycopg/__init__.py,sha256=ukkCUPrJPyAG78v4rOqcK4WZDs26PeB9Ra9qkFrGJ3E,484
+sqlspec/adapters/psycopg/config.py,sha256=PAKtLZHQjGI3oCzoUL5jd0pNrOEdFTtRPsr9-kRmiqo,26300
+sqlspec/adapters/psycopg/driver.py,sha256=lFoqYgG19lAA32_zjkx2yzYosBoINdnWG20KLDz2a3Q,42123
+sqlspec/adapters/sqlite/__init__.py,sha256=1lYrJ-DojUAOvXMoZRUJNEVyMmYhO41hMJnDWCEeXlw,234
+sqlspec/adapters/sqlite/config.py,sha256=ab9gYZvisBMO-lcB93ufmNn8lajs0-ZnFSrCtghWXPY,5757
+sqlspec/adapters/sqlite/driver.py,sha256=Joov0hv709BrkNFFEyBC8saa3MgAM8uW0Du-kQxXedk,13343
+sqlspec/driver/__init__.py,sha256=0udRS5IlJ17HzOCvzapG8c_88yAwTQri1XLD_3fZxZU,671
+sqlspec/driver/_async.py,sha256=UYNjJ70kcIeRWfMBfXqBeVhtqGP9QhmANT2bR2VkRH8,10594
+sqlspec/driver/_common.py,sha256=ohRsk4RmwHO0qLuDbjUpbXB9URC5CWrUOE-lSkFW5JI,15831
+sqlspec/driver/_sync.py,sha256=yivXeRRIFpWkS62Kbi-pRDYidhh3epdJTbjqhLxwFNo,10434
+sqlspec/driver/connection.py,sha256=zKP2p-VLxN07IPfOIBKMRELHN7ZMjmRVUKBgSW-6RQg,6610
+sqlspec/driver/parameters.py,sha256=hxS3K6oICM8mtvRI3429jHPlJJL524b26wU3XFiFlKA,3995
+sqlspec/driver/mixins/__init__.py,sha256=fvzM9gVjjnfUUTZ1TaDv-tEnxS1X-lxYiH7kZvBptzk,922
+sqlspec/driver/mixins/_cache.py,sha256=GmQZLId_RdJX9BpEnVgWYWVmii3yjqGdnA6p1yawo08,3990
+sqlspec/driver/mixins/_csv_writer.py,sha256=-uRe7QZRWtdZTFG3Fiej4Ia8EyQcjYr7oPT6wb0qTOc,2716
+sqlspec/driver/mixins/_pipeline.py,sha256=71OyeDxAQc7KNGFqObMYUU_4LBCMvsm0qCZDiHEDwOI,19548
+sqlspec/driver/mixins/_query_tools.py,sha256=c12s9gmOhAmgvIbK301SllOz89svgOXau5PwwnNu_TY,29186
+sqlspec/driver/mixins/_result_utils.py,sha256=JzMpBXLxn9POMUnqaShhU1qc8TlHwCEy8H5vqnpNnXE,5672
+sqlspec/driver/mixins/_sql_translator.py,sha256=wMv8FtGmulewCTFMdiQhlkiTz8hf7PKy_8VKP55aTuU,1499
+sqlspec/driver/mixins/_storage.py,sha256=YNpkp_ZLXCIwJjosaUJXEFHhi8QGtgP1lKKop_YSWPc,38120
+sqlspec/driver/mixins/_type_coercion.py,sha256=Al5IhsYzCnauOYW9o-STZ9DbIi9u8qYHJDeNDppN5q4,4558
+sqlspec/extensions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sqlspec/extensions/aiosql/__init__.py,sha256=-9cefc9pYPf9vCgALoB-y1DtmcgRjKe2azfl6RIarAA,414
+sqlspec/extensions/aiosql/adapter.py,sha256=jLOMftHnUR42khs63aYFS2TYa6udUPf4WrYbgHoUajg,16522
+sqlspec/extensions/litestar/__init__.py,sha256=tOmQ7RHSWOot7p30gk0efxxuP0OCq1opyyZqNmQY7FE,320
+sqlspec/extensions/litestar/_utils.py,sha256=o-FuUj1_WkDrLxQxiP6hXDak66XfyRP3QLyEVKrIRjI,1954
+sqlspec/extensions/litestar/cli.py,sha256=NYjPIWe0jESBgS0AG-3bdpcC5YM4RmZeeeTeFQK5Yqo,1362
+sqlspec/extensions/litestar/config.py,sha256=vLXM425tCV3IbJiNO1ZG90ctjBTb9oQCuLsqCaUYmo8,4685
+sqlspec/extensions/litestar/handlers.py,sha256=bVoWmHhCsHZkXZXYHE23yDaJlRoydfvU-boJjA3BSLE,10478
+sqlspec/extensions/litestar/plugin.py,sha256=SCkO6_dq6fiISXzNWqQTinbNayCMqzQ33EU9QhMWyAg,5539
+sqlspec/extensions/litestar/providers.py,sha256=wUGqPeNV58rPqL1iwDQg439C4y-Zg-eXEogjeFsv0iQ,21021
+sqlspec/migrations/__init__.py,sha256=-Shsli3g2C7e8adYVrOwBskTb7iESiAy4NChvcueZkY,776
+sqlspec/migrations/base.py,sha256=kvv_Vi4-ZV4_HY0Ug2cZdL3V7bkMSCKyzqus3kOyKyo,11894
+sqlspec/migrations/commands.py,sha256=1Q_rO21uruurAdAxtw81PkH28iUSmay1Zi87kSYwRRY,19672
+sqlspec/migrations/runner.py,sha256=CH9zh-BurgkgmSXU-dHdzl0Y1JqWfWJuYJ7SUtW89_0,6893
+sqlspec/migrations/tracker.py,sha256=CLsqb6dy34WMvkhvKVBkj8s07FhAnWsgQ77k16bz_s4,5412
+sqlspec/migrations/utils.py,sha256=NKyJbfHlcCMfzJzuQc9pItvoYPt4lG-mG8u4oBmLo6o,2614
+sqlspec/statement/__init__.py,sha256=NDvdrpr1EqAZXp4HmhTVaRnWVscahPSHpmSO8DHSoMY,536
+sqlspec/statement/cache.py,sha256=eS0vi5icd2TWOF1bFL2XKemF0NBW2dKMHNqSCCtwiF0,1387
+sqlspec/statement/filters.py,sha256=CmgGtQ7W5gJHnskpWXXJ7jdVmtoEGioHRTPntAEil2E,23478
+sqlspec/statement/parameters.py,sha256=SOXN7tT5KzOHFj4mlMMJMx_HanoBvzOd7ywBmMYPQAc,39236
+sqlspec/statement/result.py,sha256=-yARFxg7Wsm8nAeHMpnJ58OLd2VujFiZx29wfo7eFVs,14514
+sqlspec/statement/splitter.py,sha256=mCzJsNEtJFk4A0FdTELkG_qOggRFCQC_ZEJisVo9orY,24111
+sqlspec/statement/sql.py,sha256=j85wR8EsgPjNkG5BokFr5RyYd06DpkDX6gSc8u7S0oA,75745
+sqlspec/statement/builder/__init__.py,sha256=sDC8HQ-LnfqzF-XmTT0YErp8wTaJiIu5YP3pdhb2MgY,1618
+sqlspec/statement/builder/_base.py,sha256=DArCuNwDXslt73Jk5Io3WqUP1ZXA0e4cUXtzFjvQ5g4,14738
+sqlspec/statement/builder/_column.py,sha256=0yTC00IMRVVuOXYXdz2Uy7BmtLe48apIY1N6oSUbp0s,12918
+sqlspec/statement/builder/_ddl.py,sha256=6VfhavHfS4vONRPXvQl2TohizhJNGUTwWGnN9XWqT1o,51521
+sqlspec/statement/builder/_ddl_utils.py,sha256=6BEcVuSAt0mHPuT8QZQJapWorPxgMzaEX0PxKeYxMQg,4327
+sqlspec/statement/builder/_delete.py,sha256=fDuLaQIcYAJEZrQ0tdnuSmo2DcbHPiOej_YceOBKI1c,2882
+sqlspec/statement/builder/_insert.py,sha256=6LARJr81LAR418DNlzsy8qPErER14a-Dy0Cs9UZK20w,10130
+sqlspec/statement/builder/_merge.py,sha256=xjyKDqU7ABb0gA6vMoQXJGTPsUkk1j6Siohj9wHWGaE,2784
+sqlspec/statement/builder/_parsing_utils.py,sha256=dxvbSkYMAHbHJx3nMU_4S2baEJ6Vp1TIJpl7BehAlpY,5841
+sqlspec/statement/builder/_select.py,sha256=RSVTloFC7v0KYcc-zrToLiZTmO8D18hCZQ1UCs4e4NU,8527
+sqlspec/statement/builder/_update.py,sha256=d-epAsZn3HKU_QNWIP6X6dlXZTokSwLRMbN86pFyN_8,6247
+sqlspec/statement/builder/mixins/__init__.py,sha256=W5xXHE315-vAg76gbRBsQmYu72XY7wZ2vTbXM1xR_tk,2002
+sqlspec/statement/builder/mixins/_cte_and_set_ops.py,sha256=VH7a6rZ29C7z30z_z-joRu2XVP4jsNqtQzHpYyfQ2w0,8911
+sqlspec/statement/builder/mixins/_delete_operations.py,sha256=0f8ZZMFx5b53EUx1oF264owLb6aWP45naeB6g-BZQys,1068
+sqlspec/statement/builder/mixins/_insert_operations.py,sha256=93kVOOCZBxMAN0uILNejFYIDrBg04NsPIvz-cTTGKzA,5415
+sqlspec/statement/builder/mixins/_join_operations.py,sha256=lSGFtq_KJ985SCmUKmIx-4NwniIwQIVmLJYryF5mtc4,5658
+sqlspec/statement/builder/mixins/_merge_operations.py,sha256=RrjyueCzxOhqyJSrJQlL89LkJyKES2-kMsfKy-w89XQ,16846
+sqlspec/statement/builder/mixins/_order_limit_operations.py,sha256=7UOvQrRwTnOpBAXTGV509aqNj63J5UhuMIHYBjLh8vE,4538
+sqlspec/statement/builder/mixins/_pivot_operations.py,sha256=yyKxBHaw9ApO4mwALo3ulohT08Z3kh07Mtst4DMULk4,6181
+sqlspec/statement/builder/mixins/_select_operations.py,sha256=WM_wZPdKy8m-kAlfrMECFX1c2U5sZk-qRH_pTAMlUW4,25433
+sqlspec/statement/builder/mixins/_update_operations.py,sha256=h9yMqIfLJvZlv8uJBZktqT3pJyu62DxPKffSedS0NuI,7508
+sqlspec/statement/builder/mixins/_where_clause.py,sha256=yBRXq0pPMJKvpbaGI0FLZQNE2gw9ND_wofXTnsSXtZw,27018
+sqlspec/statement/pipelines/__init__.py,sha256=aN8GtpqtjTKALANNm8KH5Adq9ijP1_Kq_I9s0S7t0QI,7343
+sqlspec/statement/pipelines/context.py,sha256=ZL_1XvkPxadUtRijOh-pJ7jOkkikpNt8lymc20Jnmv8,3915
+sqlspec/statement/pipelines/analyzers/__init__.py,sha256=RY7W0AiWG-8qdrTmRSGlEofjrPPJCJUnNK-LRukKt5Q,330
+sqlspec/statement/pipelines/analyzers/_analyzer.py,sha256=0_FDty6H_4JvQwee_NrzmptX9-VdhyAePXUstuq4MU4,27474
+sqlspec/statement/pipelines/transformers/__init__.py,sha256=Kh4CE_izdwEsSF7Is6_6NXqtNmbLm5x5OWdnlUGp9ok,480
+sqlspec/statement/pipelines/transformers/_expression_simplifier.py,sha256=-imYcKeYcE66Uj04k-QywCcjvuZmvha_2H6rTy7wdSo,3376
+sqlspec/statement/pipelines/transformers/_literal_parameterizer.py,sha256=N6a2lMGBHXcoHuSySY_9JhObNkPWabUBpR_25ZCnv0w,57183
+sqlspec/statement/pipelines/transformers/_remove_comments_and_hints.py,sha256=-gM6VnlhNtQzSbQq44hQ5mhaPqNsjzeCaTgXTycgkOk,3008
+sqlspec/statement/pipelines/validators/__init__.py,sha256=cdlwdLhOT2OwTbueIsA7bfRG2b6y-j7dw9pMzl5AP0M,747
+sqlspec/statement/pipelines/validators/_dml_safety.py,sha256=s7Eee60u6w0K35vz4GVAwsB5Xy8zUqWhiIx_pRVfERo,10585
+sqlspec/statement/pipelines/validators/_parameter_style.py,sha256=Dj85rkH1GyO4dRDgix-4CR9i3sTN_dO4pfmnIe8ORmg,17810
+sqlspec/statement/pipelines/validators/_performance.py,sha256=HjXi24xh5jAHoP-tRZisu21E6ZnE1il4nQOMgRc80qo,26275
+sqlspec/statement/pipelines/validators/_security.py,sha256=3WuH9n4j-VKOgmQnZvFIoI4MieRBVShtOZvXl2SJsyk,42103
+sqlspec/storage/__init__.py,sha256=ZS8rmhN8e_h_df-Oab64Jh4EbddElBbmrtHkuO-KqOE,703
+sqlspec/storage/capabilities.py,sha256=fsnQ9jbjHBFvd3P9yWAzfjPpVYUGcsTtR6fm5iOCvXY,3054
+sqlspec/storage/registry.py,sha256=lv9pGt6vt0tDNAlao9qA7rSsFsCZtaOr48aG15IoMFA,10976
+sqlspec/storage/backends/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sqlspec/storage/backends/base.py,sha256=34XYQuz1tQ-q_ZZwOz-Kimgvl088SR3VUYJoA-STslc,6350
+sqlspec/storage/backends/fsspec.py,sha256=wo40MwtEjNTc73ZNTCmNC2-Img0zldUCaFGh9H3BZuE,14715
+sqlspec/storage/backends/obstore.py,sha256=FnoVzTzzNn5NRXR8GgETqD3Rq9C5EWAmfWmY4JDFVJE,21214
+sqlspec/utils/__init__.py,sha256=3nF4cd2RQX5SoCILETafwj-Vn6FVu7PCXtZhp6CbpL0,262
+sqlspec/utils/cached_property.py,sha256=Sw_JZxfChSJu72gvYBJPF-89FyyIJAPf-1ETlDq-F2E,648
+sqlspec/utils/correlation.py,sha256=4jqpjMivxI1tQ13Ed-P0hLdFHUKUQ9GlvIM69_HOlS4,4370
+sqlspec/utils/deprecation.py,sha256=zrmb_eKRlLWVA6dWrjUbN3Vz6D3_-Z_15Ixk4H-sDRk,3850
+sqlspec/utils/fixtures.py,sha256=q_Pghpmw2VgJ9P0TfkyjSF5PvdaD5Y2Laha0Bj4IDrA,1838
+sqlspec/utils/logging.py,sha256=56a5tqx4jfTqm20WDyj5c7Dy-h_O0KambIKOMr1-Oms,3780
+sqlspec/utils/module_loader.py,sha256=9LcmEhy4T0jgkCaDVkxX47PSgJOMeJ8IV67yXEWBp-U,3074
+sqlspec/utils/serializers.py,sha256=TKsRryRcYMnb8Z8MGkYGClIxcYvC8CW7MsrPQTJqEcY,154
+sqlspec/utils/singleton.py,sha256=KZ7481tlDAxq6gcAlpULVqPLNc9P0XkHOEp7hfWIHcI,1096
+sqlspec/utils/statement_hashing.py,sha256=Y5OKJNucINCqXeRL9d2nGRzGuIlkK5RgK40QRZfedKU,6396
+sqlspec/utils/sync_tools.py,sha256=ckP1_uLh40C2pDvdc4FsR4NkmZVa1zEB8jhUxPLIuAI,8726
+sqlspec/utils/text.py,sha256=DpEnRuSDv3acp4VQQGEOQixlJnLGZsN5YBws4rkI6t0,4756
+sqlspec/utils/type_guards.py,sha256=0sDlkB4HVl0uVA4asDNQgbGTu9Q7YaUrGllhneOi0LY,26755
+sqlspec-0.14.1.dist-info/METADATA,sha256=-AljfX5325tdemtqBiV88XvctU2KTuBPlia6TFem-dI,16663
+sqlspec-0.14.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+sqlspec-0.14.1.dist-info/entry_points.txt,sha256=G-ZqY1Nuuw3Iys7nXw23f6ILenk_Lt47VdK2mhJCWHg,53
+sqlspec-0.14.1.dist-info/licenses/LICENSE,sha256=MdujfZ6l5HuLz4mElxlu049itenOR3gnhN1_Nd3nVcM,1078
+sqlspec-0.14.1.dist-info/licenses/NOTICE,sha256=Lyir8ozXWov7CyYS4huVaOCNrtgL17P-bNV-5daLntQ,1634
+sqlspec-0.14.1.dist-info/RECORD,,

sqlspec-0.14.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+sqlspec = sqlspec.__main__:run_cli

sqlspec/service/__init__.py

@@ -1,4 +0,0 @@
-from sqlspec.service.base import SQLSpecAsyncService, SQLSpecSyncService
-from sqlspec.service.pagination import OffsetPagination
-
-__all__ = ("OffsetPagination", "SQLSpecAsyncService", "SQLSpecSyncService")

sqlspec/service/_util.py

@@ -1,147 +0,0 @@
-from collections.abc import Sequence
-from functools import partial
-from typing import Any, Optional, TypeVar, Union, cast, overload
-
-from sqlspec.driver.mixins._result_utils import _DEFAULT_TYPE_DECODERS, _default_msgspec_deserializer
-from sqlspec.exceptions import SQLSpecError
-from sqlspec.service.pagination import OffsetPagination
-from sqlspec.statement.filters import FilterTypeT, LimitOffsetFilter, StatementFilter
-from sqlspec.typing import BaseModel, DataclassProtocol, ModelDTOT, ModelT, Struct, convert, get_type_adapter
-from sqlspec.utils.type_guards import is_dataclass, is_msgspec_struct, is_pydantic_model
-
-__all__ = ("ResultConverter", "find_filter")
-
-
-T = TypeVar("T")
-
-
-def find_filter(
-    filter_type: "type[FilterTypeT]", filters: "Optional[Sequence[StatementFilter]]" = None
-) -> "Optional[FilterTypeT]":
-    """Get the filter specified by filter type from the filters.
-
-    Args:
-        filter_type: The type of filter to find.
-        filters: filter types to apply to the query
-
-    Returns:
-        The match filter instance or None
-    """
-    if filters is None:
-        return None
-    return next(
-        (cast("Optional[FilterTypeT]", filter_) for filter_ in filters if isinstance(filter_, filter_type)), None
-    )
-
-
-# TODO: add overloads for each type of pagination in the future
-class ResultConverter:
-    """Simple mixin to help convert to dictionary or list of dictionaries to specified schema type.
-
-    Single objects are transformed to the supplied schema type, and lists of objects are transformed into a list of the supplied schema type.
-
-    Args:
-        data: A database model instance or row mapping.
-              Type: :class:`~sqlspec.typing.ModelDictT`
-
-    Returns:
-        The converted schema object.
-    """
-
-    @overload
-    def to_schema(
-        self,
-        data: "ModelT",
-        total: "int | None" = None,
-        filters: "Sequence[StatementFilter] | None" = None,
-        *,
-        schema_type: None = None,
-    ) -> "ModelT": ...
-    @overload
-    def to_schema(
-        self,
-        data: "dict[str, Any] | Struct | BaseModel | DataclassProtocol",
-        total: "int | None" = None,
-        filters: "Sequence[StatementFilter] | None" = None,
-        *,
-        schema_type: "type[ModelDTOT]",
-    ) -> "ModelDTOT": ...
-    @overload
-    def to_schema(
-        self,
-        data: "Sequence[ModelT]",
-        total: "int | None" = None,
-        filters: "Sequence[StatementFilter] | None" = None,
-        *,
-        schema_type: None = None,
-    ) -> "OffsetPagination[ModelT]": ...
-    @overload
-    def to_schema(
-        self,
-        data: "Sequence[dict[str, Any] | Struct | BaseModel | DataclassProtocol]",
-        total: "int | None" = None,
-        filters: "Sequence[StatementFilter] | None" = None,
-        *,
-        schema_type: "type[ModelDTOT]",
-    ) -> "OffsetPagination[ModelDTOT]": ...
-    def to_schema(
-        self,
-        data: "ModelT | Sequence[ModelT] | dict[str, Any] | Struct | BaseModel | DataclassProtocol | Sequence[dict[str, Any] | Struct | BaseModel | DataclassProtocol]",
-        total: "int | None" = None,
-        filters: "Sequence[StatementFilter] | None" = None,
-        *,
-        schema_type: "type[ModelDTOT] | None" = None,
-    ) -> "Union[ModelT,   ModelDTOT ,  OffsetPagination[ModelT] , OffsetPagination[ModelDTOT]]":
-        if not isinstance(data, Sequence):
-            if schema_type is None:
-                return cast("ModelT", data)
-            if is_dataclass(schema_type):
-                return cast("ModelDTOT", schema_type(**data))  # type: ignore[operator]
-            if is_msgspec_struct(schema_type):
-                return cast(
-                    "ModelDTOT",
-                    convert(
-                        obj=data,
-                        type=schema_type,
-                        from_attributes=True,
-                        dec_hook=partial(_default_msgspec_deserializer, type_decoders=_DEFAULT_TYPE_DECODERS),
-                    ),
-                )
-            if is_pydantic_model(schema_type):  # pyright: ignore
-                return cast(
-                    "ModelDTOT",
-                    get_type_adapter(schema_type).validate_python(data, from_attributes=True),  # pyright: ignore
-                )
-        assert isinstance(data, Sequence)
-        limit_offset = find_filter(LimitOffsetFilter, filters=filters)
-        if schema_type is None:
-            return OffsetPagination[ModelT](
-                items=cast("list[ModelT]", data),
-                limit=limit_offset.limit if limit_offset else len(data),
-                offset=limit_offset.offset if limit_offset else 0,
-                total=total if total is not None else len(data),
-            )
-        converted_items: Sequence[ModelDTOT]
-        if is_dataclass(schema_type):
-            converted_items = [schema_type(**item) for item in data]  # type: ignore[operator]
-        elif is_msgspec_struct(schema_type):
-            converted_items = convert(
-                obj=data,
-                type=list[schema_type],  # type: ignore[valid-type]
-                from_attributes=True,
-                dec_hook=partial(_default_msgspec_deserializer, type_decoders=_DEFAULT_TYPE_DECODERS),
-            )
-        elif is_pydantic_model(schema_type):  # pyright: ignore
-            converted_items = get_type_adapter(list[schema_type]).validate_python(data, from_attributes=True)  # type: ignore[valid-type] # pyright: ignore[reportUnknownArgumentType]
-        else:
-            # This will also catch the case where a single item had an unrecognized schema_type
-            # if it somehow bypassed the initial single-item checks.
-            msg = "`schema_type` should be a valid Dataclass, Pydantic model or Msgspec struct"
-            raise SQLSpecError(msg)
-
-        return OffsetPagination[ModelDTOT](
-            items=cast("list[ModelDTOT]", converted_items),
-            limit=limit_offset.limit if limit_offset else len(data),
-            offset=limit_offset.offset if limit_offset else 0,
-            total=total if total is not None else len(data),
-        )

sqlspec/service/pagination.py

@@ -1,26 +0,0 @@
-from collections.abc import Sequence
-from dataclasses import dataclass
-from typing import Generic, TypeVar
-
-T = TypeVar("T")
-
-__all__ = ("OffsetPagination",)
-
-
-@dataclass
-class OffsetPagination(Generic[T]):
-    """Container for data returned using limit/offset pagination."""
-
-    __slots__ = ("items", "limit", "offset", "total")
-
-    items: Sequence[T]
-    """List of data being sent as part of the response."""
-    limit: int
-    """Maximal number of items to send."""
-    offset: int
-    """Offset from the beginning of the query.
-
-    Identical to an index.
-    """
-    total: int
-    """Total number of items."""