sqlspec 0.8.0__py3-none-any.whl → 0.9.0__py3-none-any.whl

sqlspec/exceptions.py

@@ -1,3 +1,5 @@
+from collections.abc import Generator
+from contextlib import contextmanager
 from typing import Any, Optional
 
 __all__ = (
@@ -6,7 +8,9 @@ __all__ = (
     "MissingDependencyError",
     "MultipleResultsFoundError",
     "NotFoundError",
+    "ParameterStyleMismatchError",
     "RepositoryError",
+    "SQLParsingError",
     "SQLSpecError",
     "SerializationError",
 )
@@ -74,6 +78,20 @@ class SQLParsingError(SQLSpecError):
         super().__init__(message)
 
 
+class ParameterStyleMismatchError(SQLSpecError):
+    """Error when parameter style doesn't match SQL placeholder style.
+
+    This exception is raised when there's a mismatch between the parameter type
+    (dictionary, tuple, etc.) and the placeholder style in the SQL query
+    (named, positional, etc.).
+    """
+
+    def __init__(self, message: Optional[str] = None) -> None:
+        if message is None:
+            message = "Parameter style mismatch: dictionary parameters provided but no named placeholders found in SQL."
+        super().__init__(message)
+
+
 class ImproperConfigurationError(SQLSpecError):
     """Improper Configuration error.
 
@@ -99,3 +117,15 @@ class NotFoundError(RepositoryError):
 
 class MultipleResultsFoundError(RepositoryError):
     """A single database result was required but more than one were found."""
+
+
+@contextmanager
+def wrap_exceptions(wrap_exceptions: bool = True) -> Generator[None, None, None]:
+    try:
+        yield
+
+    except Exception as exc:
+        if wrap_exceptions is False:
+            raise
+        msg = "An error occurred during the operation."
+        raise RepositoryError(detail=msg) from exc

sqlspec/extensions/litestar/config.py

@@ -12,6 +12,7 @@ from sqlspec.extensions.litestar.handlers import (
     lifespan_handler_maker,
     manual_handler_maker,
     pool_provider_maker,
+    session_provider_maker,
 )
 
 if TYPE_CHECKING:
@@ -25,6 +26,7 @@ if TYPE_CHECKING:
     from sqlspec.base import (
         AsyncConfigT,
         ConnectionT,
+        DriverT,
         PoolT,
         SyncConfigT,
     )
@@ -33,6 +35,7 @@ CommitMode = Literal["manual", "autocommit", "autocommit_include_redirect"]
 DEFAULT_COMMIT_MODE: CommitMode = "manual"
 DEFAULT_CONNECTION_KEY = "db_connection"
 DEFAULT_POOL_KEY = "db_pool"
+DEFAULT_SESSION_KEY = "db_session"
 
 
 @dataclass
@@ -40,11 +43,13 @@ class DatabaseConfig:
     config: "Union[SyncConfigT, AsyncConfigT]" = field()  # type: ignore[valid-type]   # pyright: ignore[reportGeneralTypeIssues]
     connection_key: str = field(default=DEFAULT_CONNECTION_KEY)
     pool_key: str = field(default=DEFAULT_POOL_KEY)
+    session_key: str = field(default=DEFAULT_SESSION_KEY)
     commit_mode: "CommitMode" = field(default=DEFAULT_COMMIT_MODE)
     extra_commit_statuses: "Optional[set[int]]" = field(default=None)
     extra_rollback_statuses: "Optional[set[int]]" = field(default=None)
     connection_provider: "Callable[[State,Scope], Awaitable[ConnectionT]]" = field(init=False, repr=False, hash=False)  # pyright: ignore[reportGeneralTypeIssues]
     pool_provider: "Callable[[State,Scope], Awaitable[PoolT]]" = field(init=False, repr=False, hash=False)  # pyright: ignore[reportGeneralTypeIssues]
+    session_provider: "Callable[[State,Scope], Awaitable[DriverT]]" = field(init=False, repr=False, hash=False)  # pyright: ignore[reportGeneralTypeIssues]
     before_send_handler: "BeforeMessageSendHookHandler" = field(init=False, repr=False, hash=False)
     lifespan_handler: "Callable[[Litestar], AbstractAsyncContextManager[None]]" = field(
         init=False,
@@ -79,3 +84,4 @@ class DatabaseConfig:
         self.lifespan_handler = lifespan_handler_maker(config=self.config, pool_key=self.pool_key)
         self.connection_provider = connection_provider_maker(connection_key=self.connection_key, config=self.config)
         self.pool_provider = pool_provider_maker(pool_key=self.pool_key, config=self.config)
+        self.session_provider = session_provider_maker(session_key=self.session_key, config=self.config)

sqlspec/extensions/litestar/handlers.py

@@ -186,3 +186,28 @@ def pool_provider_maker(
         return cast("PoolT", pool)
 
     return provide_pool
+
+
+def session_provider_maker(
+    session_key: str,
+    config: "DatabaseConfigProtocol[ConnectionT, PoolT, DriverT]",
+) -> "Callable[[State,Scope], Awaitable[DriverT]]":
+    """Build the session provider for the database configuration.
+
+    Args:
+        session_key: The dependency key to use for the session within Litestar.
+        config: The database configuration.
+
+    Returns:
+        The generated session provider for the database.
+    """
+
+    async def provide_session(state: "State", scope: "Scope") -> "DriverT":
+        session = get_sqlspec_scope_state(scope, session_key)
+        if session is None:
+            connection = await maybe_async_(config.create_connection)()
+            session = config.driver_type(connection=connection)  # pyright: ignore[reportCallIssue]
+            set_sqlspec_scope_state(scope, session_key, session)
+        return cast("DriverT", session)
+
+    return provide_session

sqlspec/extensions/litestar/plugin.py

@@ -23,6 +23,7 @@ CommitMode = Literal["manual", "autocommit", "autocommit_include_redirect"]
 DEFAULT_COMMIT_MODE: CommitMode = "manual"
 DEFAULT_CONNECTION_KEY = "db_connection"
 DEFAULT_POOL_KEY = "db_pool"
+DEFAULT_SESSION_KEY = "db_session"
 
 
 class SQLSpec(InitPluginProtocol, SQLSpecBase):
@@ -85,7 +86,11 @@ class SQLSpec(InitPluginProtocol, SQLSpecBase):
             app_config.before_send.append(c.before_send_handler)
             app_config.lifespan.append(c.lifespan_handler)  # pyright: ignore[reportUnknownMemberType]
             app_config.dependencies.update(
-                {c.connection_key: Provide(c.connection_provider), c.pool_key: Provide(c.pool_provider)},
+                {
+                    c.connection_key: Provide(c.connection_provider),
+                    c.pool_key: Provide(c.pool_provider),
+                    c.session_key: Provide(c.session_provider),
+                },
             )
 
         return app_config

sqlspec/statement.py

@@ -0,0 +1,373 @@
+# ruff: noqa: RUF100, PLR6301, PLR0912, PLR0915, C901, PLR0911, PLR0914, N806
+import logging
+import re
+from dataclasses import dataclass
+from functools import cached_property
+from typing import (
+    Any,
+    Optional,
+    Union,
+)
+
+import sqlglot
+from sqlglot import exp
+
+from sqlspec.exceptions import ParameterStyleMismatchError, SQLParsingError
+from sqlspec.typing import StatementParameterType
+
+__all__ = ("SQLStatement",)
+
+logger = logging.getLogger("sqlspec")
+
+# Regex to find :param style placeholders, skipping those inside quotes or SQL comments
+# Adapted from previous version in psycopg adapter
+PARAM_REGEX = re.compile(
+    r"""(?<![:\w]) # Negative lookbehind to avoid matching things like ::type or \:escaped
+    (?:
+        (?P<dquote>"(?:[^"]|"")*") |     # Double-quoted strings (support SQL standard escaping "")
+        (?P<squote>'(?:[^']|'')*') |     # Single-quoted strings (support SQL standard escaping '')
+        (?P<comment>--.*?\n|\/\*.*?\*\/) | # SQL comments (single line or multi-line)
+        : (?P<var_name>[a-zA-Z_][a-zA-Z0-9_]*)   # :var_name identifier
+    )
+    """,
+    re.VERBOSE | re.DOTALL,
+)
+
+
+@dataclass()
+class SQLStatement:
+    """An immutable representation of a SQL statement with its parameters.
+
+    This class encapsulates the SQL statement and its parameters, providing
+    a clean interface for parameter binding and SQL statement formatting.
+    """
+
+    dialect: str
+    """The SQL dialect to use for parsing (e.g., 'postgres', 'mysql'). Defaults to 'postgres' if None."""
+    sql: str
+    """The raw SQL statement."""
+    parameters: Optional[StatementParameterType] = None
+    """The parameters for the SQL statement."""
+    kwargs: Optional[dict[str, Any]] = None
+    """Keyword arguments passed for parameter binding."""
+
+    _merged_parameters: Optional[Union[StatementParameterType, dict[str, Any]]] = None
+
+    def __post_init__(self) -> None:
+        """Merge parameters and kwargs after initialization."""
+        merged_params = self.parameters
+
+        if self.kwargs:
+            if merged_params is None:
+                merged_params = self.kwargs
+            elif isinstance(merged_params, dict):
+                # Merge kwargs into parameters dict, kwargs take precedence
+                merged_params = {**merged_params, **self.kwargs}
+            else:
+                # If parameters is sequence or scalar, kwargs replace it
+                # Consider adding a warning here if this behavior is surprising
+                merged_params = self.kwargs
+
+        self._merged_parameters = merged_params
+
+    def process(self) -> "tuple[str, Optional[Union[tuple[Any, ...], list[Any], dict[str, Any]]]]":
+        """Process the SQL statement and merged parameters for execution.
+
+        Returns:
+            A tuple containing the processed SQL string and the processed parameters
+            ready for database driver execution.
+
+        Raises:
+            SQLParsingError: If the SQL statement contains parameter placeholders, but no parameters were provided.
+
+        Returns:
+            A tuple containing the processed SQL string and the processed parameters
+            ready for database driver execution.
+        """
+        if self._merged_parameters is None:
+            # Validate that the SQL doesn't expect parameters if none were provided
+            # Parse ONLY if we need to validate
+            try:  # Add try/except in case parsing fails even here
+                expression = self._parse_sql()
+            except SQLParsingError:
+                # If parsing fails, we can't validate, but maybe that's okay if no params were passed?
+                # Log a warning? For now, let the original error propagate if needed.
+                # Or, maybe assume it's okay if _merged_parameters is None?
+                # Let's re-raise for now, as unparsable SQL is usually bad.
+                logger.warning("SQL statement is unparsable: %s", self.sql)
+                return self.sql, None
+            if list(expression.find_all(exp.Parameter)):
+                msg = "SQL statement contains parameter placeholders, but no parameters were provided."
+                raise SQLParsingError(msg)
+            return self.sql, None
+
+        if isinstance(self._merged_parameters, dict):
+            # Pass only the dict, parsing happens inside
+            return self._process_dict_params(self._merged_parameters)
+
+        if isinstance(self._merged_parameters, (tuple, list)):
+            # Pass only the sequence, parsing happens inside if needed for validation
+            return self._process_sequence_params(self._merged_parameters)
+
+        # Assume it's a single scalar value otherwise
+        # Pass only the value, parsing happens inside for validation
+        return self._process_scalar_param(self._merged_parameters)
+
+    def _parse_sql(self) -> exp.Expression:
+        """Parse the SQL using sqlglot.
+
+        Raises:
+            SQLParsingError: If the SQL statement cannot be parsed.
+
+        Returns:
+            The parsed SQL expression.
+        """
+        parse_dialect = self.dialect or "postgres"
+        try:
+            read_dialect = parse_dialect or None
+            return sqlglot.parse_one(self.sql, read=read_dialect)
+        except Exception as e:
+            # Ensure the original sqlglot error message is included
+            error_detail = str(e)
+            msg = f"Failed to parse SQL with dialect '{parse_dialect or 'auto-detected'}': {error_detail}\nSQL: {self.sql}"
+            raise SQLParsingError(msg) from e
+
+    def _process_dict_params(
+        self,
+        parameter_dict: dict[str, Any],
+    ) -> "tuple[str, Optional[Union[tuple[Any, ...], list[Any], dict[str, Any]]]]":
+        """Processes dictionary parameters based on dialect capabilities.
+
+        Raises:
+            ParameterStyleMismatchError: If the SQL statement contains unnamed placeholders (e.g., '?') in the SQL query.
+            SQLParsingError: If the SQL statement contains named parameters, but no parameters were provided.
+
+        Returns:
+            A tuple containing the processed SQL string and the processed parameters
+            ready for database driver execution.
+        """
+        # Attempt to parse with sqlglot first (for other dialects like postgres, mysql)
+        named_sql_params: Optional[list[exp.Parameter]] = None
+        unnamed_sql_params: Optional[list[exp.Parameter]] = None
+        sqlglot_parsed_ok = False
+        # --- Dialect-Specific Bypasses for Native Handling ---
+        if self.dialect == "sqlite":  # Handles :name natively
+            return self.sql, parameter_dict
+
+        # Add bypass for postgres handled by specific adapters (e.g., asyncpg)
+        if self.dialect == "postgres":
+            # The adapter (e.g., asyncpg) will handle :name -> $n conversion.
+            # SQLStatement just validates parameters against the original SQL here.
+            # Perform validation using regex if sqlglot parsing fails, otherwise use sqlglot.
+            try:
+                expression = self._parse_sql()
+                sql_params = list(expression.find_all(exp.Parameter))
+                named_sql_params = [p for p in sql_params if p.name]
+                unnamed_sql_params = [p for p in sql_params if not p.name]
+
+                if unnamed_sql_params:
+                    msg = "Cannot use dictionary parameters with unnamed placeholders (e.g., '?') found by sqlglot for postgres."
+                    raise ParameterStyleMismatchError(msg)
+
+                # Validate keys using sqlglot results
+                required_keys = {p.name for p in named_sql_params}
+                provided_keys = set(parameter_dict.keys())
+                missing_keys = required_keys - provided_keys
+                if missing_keys:
+                    msg = (
+                        f"Named parameters found in SQL (via sqlglot) but not provided: {missing_keys}. SQL: {self.sql}"
+                    )
+                    raise SQLParsingError(msg)  # noqa: TRY301
+                # Allow extra keys
+
+            except SQLParsingError as e:
+                logger.debug("SQLglot parsing failed for postgres dict params, attempting regex validation: %s", e)
+                # Regex validation fallback (without conversion)
+                postgres_found_params_regex: list[str] = []
+                for match in PARAM_REGEX.finditer(self.sql):
+                    if match.group("dquote") or match.group("squote") or match.group("comment"):
+                        continue
+                    if match.group("var_name"):
+                        var_name = match.group("var_name")
+                        postgres_found_params_regex.append(var_name)
+                        if var_name not in parameter_dict:
+                            msg = f"Named parameter ':{var_name}' found in SQL (via regex) but not provided. SQL: {self.sql}"
+                            raise SQLParsingError(msg)  # noqa: B904
+
+                if not postgres_found_params_regex and parameter_dict:
+                    msg = f"Dictionary parameters provided, but no named placeholders (:name) found via regex. SQL: {self.sql}"
+                    raise ParameterStyleMismatchError(msg)  # noqa: B904
+                # Allow extra keys with regex check too
+
+            # Return the *original* SQL and the processed dict for the adapter to handle
+            return self.sql, parameter_dict
+
+        if self.dialect == "duckdb":  # Handles $name natively (and :name via driver? Check driver docs)
+            # Bypass sqlglot/regex checks. Trust user SQL ($name or ?) + dict for DuckDB driver.
+            # We lose :name -> $name conversion *if* sqlglot parsing fails, but avoid errors on valid $name SQL.
+            return self.sql, parameter_dict
+        # --- End Bypasses ---
+
+        try:
+            expression = self._parse_sql()
+            sql_params = list(expression.find_all(exp.Parameter))
+            named_sql_params = [p for p in sql_params if p.name]
+            unnamed_sql_params = [p for p in sql_params if not p.name]
+            sqlglot_parsed_ok = True
+            logger.debug("SQLglot parsed dict params successfully for: %s", self.sql)
+        except SQLParsingError as e:
+            logger.debug("SQLglot parsing failed for dict params, attempting regex fallback: %s", e)
+            # Proceed using regex fallback below
+
+        # Check for unnamed placeholders if parsing worked
+        if sqlglot_parsed_ok and unnamed_sql_params:
+            msg = "Cannot use dictionary parameters with unnamed placeholders (e.g., '?') found by sqlglot."
+            raise ParameterStyleMismatchError(msg)
+
+        # Determine if we need to use regex fallback
+        # Use fallback if: parsing failed OR (parsing worked BUT found no named params when a dict was provided)
+        use_regex_fallback = not sqlglot_parsed_ok or (not named_sql_params and parameter_dict)
+
+        if use_regex_fallback:
+            # Regex fallback logic for :name -> self.param_style conversion
+            # ... (regex fallback code as implemented previously) ...
+            logger.debug("Using regex fallback for dict param processing: %s", self.sql)
+            # --- Regex Fallback Logic ---
+            regex_processed_sql_parts: list[str] = []
+            ordered_params = []
+            last_end = 0
+            regex_found_params: list[str] = []
+
+            for match in PARAM_REGEX.finditer(self.sql):
+                # Skip matches that are comments or quoted strings
+                if match.group("dquote") or match.group("squote") or match.group("comment"):
+                    continue
+
+                if match.group("var_name"):
+                    var_name = match.group("var_name")
+                    regex_found_params.append(var_name)
+                    # Get start and end from the match object for the :var_name part
+                    # The var_name group itself doesn't include the leading :, so adjust start.
+                    start = match.start("var_name") - 1
+                    end = match.end("var_name")
+
+                    if var_name not in parameter_dict:
+                        msg = (
+                            f"Named parameter ':{var_name}' found in SQL (via regex) but not provided. SQL: {self.sql}"
+                        )
+                        raise SQLParsingError(msg)
+
+                    regex_processed_sql_parts.extend((self.sql[last_end:start], self.param_style))  # Use target style
+                    ordered_params.append(parameter_dict[var_name])
+                    last_end = end
+
+            regex_processed_sql_parts.append(self.sql[last_end:])
+
+            # Validation with regex results
+            if not regex_found_params and parameter_dict:
+                msg = f"Dictionary parameters provided, but no named placeholders (e.g., :name) found via regex in the SQL query for dialect '{self.dialect}'. SQL: {self.sql}"
+                raise ParameterStyleMismatchError(msg)
+
+            provided_keys = set(parameter_dict.keys())
+            missing_keys = set(regex_found_params) - provided_keys  # Should be caught above, but double check
+            if missing_keys:
+                msg = f"Named parameters found in SQL (via regex) but not provided: {missing_keys}. SQL: {self.sql}"
+                raise SQLParsingError(msg)
+
+            extra_keys = provided_keys - set(regex_found_params)
+            if extra_keys:
+                # Allow extra keys
+                pass
+
+            return "".join(regex_processed_sql_parts), tuple(ordered_params)
+
+        # Sqlglot Logic (if parsing worked and found params)
+        # ... (sqlglot logic as implemented previously, including :name -> %s conversion) ...
+        logger.debug("Using sqlglot results for dict param processing: %s", self.sql)
+
+        # Ensure named_sql_params is iterable, default to empty list if None (shouldn't happen ideally)
+        active_named_params = named_sql_params or []
+
+        if not active_named_params and not parameter_dict:
+            # No SQL params found by sqlglot, no provided params dict -> OK
+            return self.sql, ()
+
+        # Validation with sqlglot results
+        required_keys = {p.name for p in active_named_params}  # Use active_named_params
+        provided_keys = set(parameter_dict.keys())
+
+        missing_keys = required_keys - provided_keys
+        if missing_keys:
+            msg = f"Named parameters found in SQL (via sqlglot) but not provided: {missing_keys}. SQL: {self.sql}"
+            raise SQLParsingError(msg)
+
+        extra_keys = provided_keys - required_keys
+        if extra_keys:
+            pass  # Allow extra keys
+
+        # Note: DuckDB handled by bypass above if sqlglot fails.
+        # This block handles successful sqlglot parse for other dialects.
+        # We don't need the specific DuckDB $name conversion here anymore,
+        # as the bypass handles the native $name case.
+        # The general logic converts :name -> self.param_style for dialects like postgres.
+        # if self.dialect == "duckdb": ... (Removed specific block here)
+
+        # For other dialects requiring positional conversion (using sqlglot param info):
+        sqlglot_processed_parts: list[str] = []
+        ordered_params = []
+        last_end = 0
+        for param in active_named_params:  # Use active_named_params
+            start = param.this.this.start
+            end = param.this.this.end
+            sqlglot_processed_parts.extend((self.sql[last_end:start], self.param_style))
+            ordered_params.append(parameter_dict[param.name])
+            last_end = end
+        sqlglot_processed_parts.append(self.sql[last_end:])
+        return "".join(sqlglot_processed_parts), tuple(ordered_params)
+
+    def _process_sequence_params(
+        self, params: Union[tuple[Any, ...], list[Any]]
+    ) -> "tuple[str, Optional[Union[tuple[Any, ...], list[Any], dict[str, Any]]]]":
+        """Processes a sequence of parameters.
+
+        Returns:
+            A tuple containing the processed SQL string and the processed parameters
+            ready for database driver execution.
+        """
+        return self.sql, params
+
+    def _process_scalar_param(
+        self, param_value: Any
+    ) -> "tuple[str, Optional[Union[tuple[Any, ...], list[Any], dict[str, Any]]]]":
+        """Processes a single scalar parameter value.
+
+        Returns:
+            A tuple containing the processed SQL string and the processed parameters
+            ready for database driver execution.
+        """
+        return self.sql, (param_value,)
+
+    @cached_property
+    def param_style(self) -> str:
+        """Get the parameter style based on the dialect.
+
+        Returns:
+            The parameter style placeholder for the dialect.
+        """
+        dialect = self.dialect
+
+        # Map dialects to parameter styles for placeholder replacement
+        # Note: Used when converting named params (:name) for dialects needing positional.
+        # Dialects supporting named params natively (SQLite, DuckDB) are handled via bypasses.
+        dialect_to_param_style = {
+            "postgres": "%s",
+            "mysql": "%s",
+            "oracle": ":1",
+            "mssql": "?",
+            "bigquery": "?",
+            "snowflake": "?",
+            "cockroach": "%s",
+            "db2": "?",
+        }
+        # Default to '?' for unknown/unhandled dialects or when dialect=None is forced
+        return dialect_to_param_style.get(dialect, "?")

sqlspec/typing.py

@@ -7,8 +7,10 @@ from typing_extensions import TypeAlias, TypeGuard
 from sqlspec._typing import (
     LITESTAR_INSTALLED,
     MSGSPEC_INSTALLED,
+    PYARROW_INSTALLED,
     PYDANTIC_INSTALLED,
     UNSET,
+    ArrowTable,
     BaseModel,
     DataclassProtocol,
     DTOData,
@@ -77,7 +79,7 @@ Represents:
 - :class:`DTOData`[:type:`list[ModelT]`]
 """
 
-StatementParameterType: TypeAlias = "Union[dict[str, Any], list[Any], tuple[Any, ...], None]"
+StatementParameterType: TypeAlias = "Union[Any, dict[str, Any], list[Any], tuple[Any, ...], None]"
 """Type alias for parameter types.
 
 Represents:
@@ -486,9 +488,11 @@ def schema_dump(  # noqa: PLR0911
 __all__ = (
     "LITESTAR_INSTALLED",
     "MSGSPEC_INSTALLED",
+    "PYARROW_INSTALLED",
     "PYDANTIC_INSTALLED",
     "PYDANTIC_USE_FAILFAST",
     "UNSET",
+    "ArrowTable",
     "BaseModel",
     "DataclassProtocol",
     "Empty",
@@ -539,3 +543,8 @@ if TYPE_CHECKING:
         from sqlspec._typing import UNSET, Struct, UnsetType, convert
     else:
         from msgspec import UNSET, Struct, UnsetType, convert  # noqa: TC004
+
+    if not PYARROW_INSTALLED:
+        from sqlspec._typing import ArrowTable
+    else:
+        from pyarrow import Table as ArrowTable  # noqa: TC004

{sqlspec-0.8.0.dist-info → sqlspec-0.9.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlspec
-Version: 0.8.0
+Version: 0.9.0
 Summary: SQL Experiments in Python
 Author-email: Cody Fincher <cody@litestar.dev>
 Maintainer-email: Litestar Developers <hello@litestar.dev>
@@ -42,6 +42,8 @@ Provides-Extra: orjson
 Requires-Dist: orjson; extra == 'orjson'
 Provides-Extra: performance
 Requires-Dist: sqlglot[rs]; extra == 'performance'
+Provides-Extra: psqlpy
+Requires-Dist: psqlpy; extra == 'psqlpy'
 Provides-Extra: psycopg
 Requires-Dist: psycopg[binary,pool]; extra == 'psycopg'
 Provides-Extra: pydantic
@@ -102,6 +104,7 @@ This list is not final. If you have a driver you'd like to see added, please ope
 | [`asyncpg`](https://magicstack.github.io/asyncpg/current/)                                                    | PostgreSQL | Async   | ✅         |
 | [`psycopg`](https://www.psycopg.org/)                                                                         | PostgreSQL | Sync    | ✅         |
 | [`psycopg`](https://www.psycopg.org/)                                                                         | PostgreSQL | Async   | ✅         |
+| [`psqlpy`](https://psqlpy-python.github.io/)                                                                  | PostgreSQL | Async   | ✅        |
 | [`aiosqlite`](https://github.com/omnilib/aiosqlite)                                                           | SQLite     | Async   | ✅         |
 | `sqlite3`                                                                                                    | SQLite     | Sync    | ✅         |
 | [`oracledb`](https://oracle.github.io/python-oracledb/)                                                      | Oracle     | Async   | ✅         |

sqlspec-0.9.0.dist-info/RECORD

@@ -0,0 +1,61 @@
+sqlspec/__init__.py,sha256=dsOivB7SmZhOcWkZQT12L4LHC6fQhWBk2s_3j85KkgQ,316
+sqlspec/__metadata__.py,sha256=hNP3wXvtk8fQVPKGjRLpZ9mP-gaPJqzrmgm3UqpDIXQ,460
+sqlspec/_serialization.py,sha256=tSwWwFImlYviC6ARdXRz0Bp4QXbCdc8cKGgZr33OglY,2657
+sqlspec/_typing.py,sha256=6ukndnNu_XWKf2OW-HP1x1L7YmqohMwjg2HF4Hq3xdU,7111
+sqlspec/base.py,sha256=vYXMVrdxEhaRfeAD4MVz9izY_mbCg5G3rbNchJ7vp0Q,24539
+sqlspec/exceptions.py,sha256=EyS7B9qyyTo78CdkC5iQDYFW9eXILDA6xiSS4ABr0Ws,4033
+sqlspec/filters.py,sha256=Gqwt4VQ7e8ffphkuR-jBfqW4m0OWGGUPiYWyEQ0Xn7M,3620
+sqlspec/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sqlspec/statement.py,sha256=lbnF_flv4sWPPiZtHX-53d72eCFcceBYB4BgQQYjnCU,17451
+sqlspec/typing.py,sha256=AI-72LFQcwwPoW5oEdEFkNHzxnWQv6I7lxcZRoZd88U,15428
+sqlspec/adapters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sqlspec/adapters/adbc/__init__.py,sha256=_mIoHMCXYWLCqGtnN8YEylhkNt3goTAvZgsT1dfEL6g,155
+sqlspec/adapters/adbc/config.py,sha256=e2lrNsr8VN6R1ZBY16qusNj_W7npy7jp730NXCnhbBI,9866
+sqlspec/adapters/adbc/driver.py,sha256=lP9YEf5sUmeWRBULVZurfiRvE1sMuYdGzvCibzQPALw,16255
+sqlspec/adapters/aiosqlite/__init__.py,sha256=TQME6tGSPswTkZBjW2oH39lbxpzSwwWG5SQfgFpSe00,185
+sqlspec/adapters/aiosqlite/config.py,sha256=EjDJq9-Jn6MKnqlpL4ZwXYxaCKD0wE5GxrSYa2Ck1bA,4788
+sqlspec/adapters/aiosqlite/driver.py,sha256=D6kTpRxcfD_NSH7ThcVq2VbYZz0iriCh_CMjPQBl_Z8,11466
+sqlspec/adapters/asyncmy/__init__.py,sha256=w0hjokFrsBgYS0EnIv8Dorb7jz8M3ZBZYKMUXCUYEQg,247
+sqlspec/adapters/asyncmy/config.py,sha256=5ILV46FWjc9Cy46aMuhinpfc70b_708h9ubHj9HRCmE,9412
+sqlspec/adapters/asyncmy/driver.py,sha256=RICHrYxv2jOUk0m4bex0k2YVc5GMnSnOdrMIp4p4fNo,8507
+sqlspec/adapters/asyncpg/__init__.py,sha256=iR-vJYxImcw5hLaDgMqPLLRxW_vOYylEpemSg5G4dP4,261
+sqlspec/adapters/asyncpg/config.py,sha256=DH6ZLkL4iHmRbW80VFQK1kzWIFRyGkFAZdtF3_f13AQ,9987
+sqlspec/adapters/asyncpg/driver.py,sha256=G6CSo3k1EzmPTZr2cCnTchR7J_O-1_uNC5eKylFMysY,18557
+sqlspec/adapters/duckdb/__init__.py,sha256=b_4QWZC0emTsbuBjcDZrxoEc83hGuBMx7Wwha3fFTAE,167
+sqlspec/adapters/duckdb/config.py,sha256=GJTzKp1cEFhKSe94n5wOXvrT4Sz3Md8mKRxmCBnfvsM,15731
+sqlspec/adapters/duckdb/driver.py,sha256=e91Iu84FbZ7NefqxkhmWZcwICav0lxJpAxxD08sFqUk,10160
+sqlspec/adapters/oracledb/__init__.py,sha256=g54_WLVzZhvD1sLC2uV0nfUs6WnYUJv2vqvvG34L7v0,398
+sqlspec/adapters/oracledb/driver.py,sha256=1YCj0pyaIMB-WXi_2w0ywRR0DlAlz5Q6k4gjGkY2yDE,23081
+sqlspec/adapters/oracledb/config/__init__.py,sha256=emx5jWXqw3ifoW-m_tNI7sTz_duq2vRkubc0J2QqEQ4,306
+sqlspec/adapters/oracledb/config/_asyncio.py,sha256=hu4o5q_d1O7svR_XrylWcmMrvmBzOp0T1m_Ybrbbr_o,7293
+sqlspec/adapters/oracledb/config/_common.py,sha256=UJZL2DQQZM3uOn1E1A_gnsB8nX3-yCDXGd66PDI29_s,5691
+sqlspec/adapters/oracledb/config/_sync.py,sha256=wvmC8bX2FhSD3W-k4RUBXnMP6cvEThsO6-vA-q5flUY,7016
+sqlspec/adapters/psqlpy/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sqlspec/adapters/psqlpy/config.py,sha256=SFa40Fp0HyrAAT49nNoH9gYovzk0iEhm6qMmqS9OgDI,10590
+sqlspec/adapters/psqlpy/driver.py,sha256=8DnLXFwIUkGtlu-xpj2O4lAaERIIRVVbNgkL6GQ7Qgk,12844
+sqlspec/adapters/psycopg/__init__.py,sha256=_aCZRfDiC4lXM5UdkYEQEHZq-bqY1nyS_sioTM91Ul0,408
+sqlspec/adapters/psycopg/driver.py,sha256=4hQfw_hHuzZJYz1gKVECRAAdchop-ZIVWg9fZjY-NUM,21296
+sqlspec/adapters/psycopg/config/__init__.py,sha256=TIFGht0TdHKC7NTJwaJPpG-6-BRRGzWfc2Bu756R-A4,310
+sqlspec/adapters/psycopg/config/_async.py,sha256=6YpxNLxHwvI7r7ZBKKjWnd0xbEG1i4HLOOimiiDUr6w,6631
+sqlspec/adapters/psycopg/config/_common.py,sha256=UqqvqPE9zlSO9G_Gh6fI190cHfCDG98S0GaznGAHpdU,2181
+sqlspec/adapters/psycopg/config/_sync.py,sha256=QIybrGVkuu45GlAcYBzpcsRq7VW6EnHff4fcNATAgsw,6443
+sqlspec/adapters/sqlite/__init__.py,sha256=cGsMyN4_ZWApbhtwmYG18PYEBRiO-NdOU6eecBxTwRQ,167
+sqlspec/adapters/sqlite/config.py,sha256=m2TV-3jcjxIeMSCTsvvrTm50L6uE3007WVPluvqIX3Q,4447
+sqlspec/adapters/sqlite/driver.py,sha256=quh0Bazho05QVRWxy_Jww02I6HKLFg8Q0jUWMtfBjEU,11293
+sqlspec/extensions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sqlspec/extensions/litestar/__init__.py,sha256=vJf0co-AUM75c7ZLil_TUCYilVNDtmVsdeVLbm9_xn8,512
+sqlspec/extensions/litestar/_utils.py,sha256=UgwFxqLnjDw9S8G0H24DP2GsbMGas81W1lfhfTY68m8,1969
+sqlspec/extensions/litestar/config.py,sha256=zq_mlwNubDhRAtAivi2d5S5ippJ1A5xhw19XC6yPC60,4443
+sqlspec/extensions/litestar/handlers.py,sha256=6FNqIEWHUltnNuhcp8QNktK0j6-UB4isMpzoP7qCc3g,7932
+sqlspec/extensions/litestar/plugin.py,sha256=TOXz5Np17DbNaPhPp09-88reDHE29kmMjmRe4W5_-zE,4904
+sqlspec/utils/__init__.py,sha256=nVIUuMaHhhC1vXydoSBvnc-xTArqwWJaAtpjHhiM84Q,159
+sqlspec/utils/deprecation.py,sha256=4pwGxoQYI3dAc3L1lh4tszZG6e2jp5m4e0ICk8SJx5M,3886
+sqlspec/utils/fixtures.py,sha256=ni51rAuen6S1wuSi1kUwn6Qh25B-XrewPEsjV8G4gQ0,2029
+sqlspec/utils/module_loader.py,sha256=tmMy9JcTTQETcwT8Wt8adCIuqr4zinQnPbCiBJ6JTSQ,2703
+sqlspec/utils/sync_tools.py,sha256=xxHZ-5rnTrPEUNr7gxQUVvJd0NGJeO_MgisR8X7sI3c,10425
+sqlspec/utils/text.py,sha256=Ya-fWBcfkQRhguNs7MNFIYtAUiArBo62w8sRPHavMWM,1476
+sqlspec-0.9.0.dist-info/METADATA,sha256=zKfhk4Zk5WwoRzWlGqFTERFpN5kDOaFW77k7gU52tBo,9616
+sqlspec-0.9.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+sqlspec-0.9.0.dist-info/licenses/LICENSE,sha256=MdujfZ6l5HuLz4mElxlu049itenOR3gnhN1_Nd3nVcM,1078
+sqlspec-0.9.0.dist-info/licenses/NOTICE,sha256=Lyir8ozXWov7CyYS4huVaOCNrtgL17P-bNV-5daLntQ,1634
+sqlspec-0.9.0.dist-info/RECORD,,