sqlspec 0.62.0__py3-none-any.whl → 0.62.2__py3-none-any.whl

sqlspec/adapters/asyncmy/adk/store.py

@@ -7,6 +7,7 @@ from typing import TYPE_CHECKING, Any, Final, Literal, cast
 import asyncmy
 from typing_extensions import NotRequired
 
+from sqlspec.adapters.asyncmy.core import resolve_rowcount
 from sqlspec.config import ADKConfig
 from sqlspec.extensions.adk import BaseAsyncADKStore, StoredEvent, StoredSession, normalize_session_list_options
 from sqlspec.extensions.adk.memory.store import BaseAsyncADKMemoryStore
@@ -309,7 +310,7 @@ class AsyncmyADKStore(BaseAsyncADKStore["AsyncmyConfig"]):
             async with self._config.provide_connection() as conn, conn.cursor() as cursor:
                 await cursor.execute(sql, tuple(params))
                 await conn.commit()
-                return cursor.rowcount if cursor.rowcount and cursor.rowcount > 0 else 0
+                return resolve_rowcount(cursor)
         except asyncmy.errors.ProgrammingError as exc:  # pyright: ignore[reportAttributeAccessIssue]
             if _is_mysql_table_missing(exc):
                 return 0
@@ -327,7 +328,7 @@ class AsyncmyADKStore(BaseAsyncADKStore["AsyncmyConfig"]):
             async with self._config.provide_connection() as conn, conn.cursor() as cursor:
                 await cursor.execute(sql, tuple(params))
                 await conn.commit()
-                return cursor.rowcount if cursor.rowcount and cursor.rowcount > 0 else 0
+                return resolve_rowcount(cursor)
         except asyncmy.errors.ProgrammingError as exc:  # pyright: ignore[reportAttributeAccessIssue]
             if _is_mysql_table_missing(exc):
                 return 0
@@ -345,7 +346,7 @@ class AsyncmyADKStore(BaseAsyncADKStore["AsyncmyConfig"]):
             async with self._config.provide_connection() as conn, conn.cursor() as cursor:
                 await cursor.execute(sql, tuple(params))
                 await conn.commit()
-                return cursor.rowcount if cursor.rowcount and cursor.rowcount > 0 else 0
+                return resolve_rowcount(cursor)
         except asyncmy.errors.ProgrammingError as exc:  # pyright: ignore[reportAttributeAccessIssue]
             if _is_mysql_table_missing(exc):
                 return 0
@@ -545,7 +546,7 @@ class AsyncmyADKMemoryStore(BaseAsyncADKMemoryStore["AsyncmyConfig"]):
                             entry["inserted_at"],
                         )
                     await cursor.execute(sql, params)
-                    inserted_count += cursor.rowcount
+                    inserted_count += resolve_rowcount(cursor)
             await conn.commit()
         return inserted_count
 
@@ -608,7 +609,7 @@ class AsyncmyADKMemoryStore(BaseAsyncADKMemoryStore["AsyncmyConfig"]):
         async with self._config.provide_connection() as conn, conn.cursor() as cursor:
             await cursor.execute(sql, (session_id,))
             await conn.commit()
-            return cursor.rowcount if cursor.rowcount and cursor.rowcount > 0 else 0
+            return resolve_rowcount(cursor)
 
     async def delete_entries_older_than(
         self, days: int, app_name: "str | None" = None, scope: "str | None" = None
@@ -632,7 +633,7 @@ class AsyncmyADKMemoryStore(BaseAsyncADKMemoryStore["AsyncmyConfig"]):
         async with self._config.provide_connection() as conn, conn.cursor() as cursor:
             await cursor.execute(sql, tuple(params))
             await conn.commit()
-            return cursor.rowcount if cursor.rowcount and cursor.rowcount > 0 else 0
+            return resolve_rowcount(cursor)
 
     async def _memory_table_ddl(self) -> str:
         """Get MySQL CREATE TABLE SQL for memory entries."""

sqlspec/adapters/asyncmy/config.py

@@ -325,7 +325,7 @@ class AsyncmyConfig(AsyncDatabaseConfig[AsyncmyConnection, "AsyncmyPool", Asyncm
 
         Future driver_features can be added here if needed.
         """
-        return cast("AsyncmyPool", await asyncmy.create_pool(**_pool_config(self.connection_config)))
+        return await asyncmy.create_pool(**_pool_config(self.connection_config))
 
     async def _ensure_connection(self, connection: "AsyncmyConnection") -> None:
         """Ensure connection callback has been called exactly once for this connection.

sqlspec/adapters/asyncmy/litestar/store.py

@@ -3,6 +3,7 @@
 from datetime import datetime, timedelta, timezone
 from typing import TYPE_CHECKING, Any, Final, cast
 
+from sqlspec.adapters.asyncmy.core import resolve_rowcount
 from sqlspec.exceptions import ImproperConfigurationError
 from sqlspec.extensions.litestar.store import BaseSQLSpecStore
 from sqlspec.utils.logging import get_logger
@@ -227,7 +228,7 @@ class AsyncmyStore(BaseSQLSpecStore["AsyncmyConfig"]):
         async with self._config.provide_connection() as conn, conn.cursor() as cursor:
             await cursor.execute(sql)
             await conn.commit()
-            count: int = cursor.rowcount
+            count = resolve_rowcount(cursor)
             if count > 0:
                 self._log_delete_expired(count)
             return count

sqlspec/adapters/asyncpg/adk/store.py

@@ -599,6 +599,8 @@ class AsyncpgADKMemoryStore(BaseAsyncADKMemoryStore["AsyncpgConfig"]):
             return
 
         async with self._config.provide_session() as driver:
+            if self._enable_bm25:
+                self._config._ensure_pg_textsearch_available()
             await driver.execute_script(await self._memory_table_ddl())
 
     async def insert_memory_entries(self, entries: "list[StoredMemory]", owner_id: "object | None" = None) -> int:
@@ -616,9 +618,9 @@ class AsyncpgADKMemoryStore(BaseAsyncADKMemoryStore["AsyncpgConfig"]):
                     sql = f"""
                     INSERT INTO {self._memory_table}
                     (id, session_id, app_name, user_id, scope, event_id, author,
-                     {self._owner_id_column_name}, timestamp, content_json,
+                     {self._owner_id_column_name}, timestamp, embedding, content_json,
                      content_text, metadata_json, inserted_at)
-                    VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13)
+                    VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10::float8[]::vector, $11, $12, $13, $14)
                     ON CONFLICT (event_id) DO NOTHING
                     """
                     result = await conn.execute(
@@ -632,6 +634,7 @@ class AsyncpgADKMemoryStore(BaseAsyncADKMemoryStore["AsyncpgConfig"]):
                         entry["author"],
                         owner_id,
                         entry["timestamp"],
+                        entry.get("embedding"),
                         entry["content_json"],
                         entry["content_text"],
                         entry["metadata_json"],
@@ -641,8 +644,8 @@ class AsyncpgADKMemoryStore(BaseAsyncADKMemoryStore["AsyncpgConfig"]):
                     sql = f"""
                     INSERT INTO {self._memory_table}
                     (id, session_id, app_name, user_id, scope, event_id, author,
-                     timestamp, content_json, content_text, metadata_json, inserted_at)
-                    VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)
+                     timestamp, embedding, content_json, content_text, metadata_json, inserted_at)
+                    VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9::float8[]::vector, $10, $11, $12, $13)
                     ON CONFLICT (event_id) DO NOTHING
                     """
                     result = await conn.execute(
@@ -655,13 +658,14 @@ class AsyncpgADKMemoryStore(BaseAsyncADKMemoryStore["AsyncpgConfig"]):
                         entry["event_id"],
                         entry["author"],
                         entry["timestamp"],
+                        entry.get("embedding"),
                         entry["content_json"],
                         entry["content_text"],
                         entry["metadata_json"],
                         entry["inserted_at"],
                     )
                 try:
-                    inserted_count += int(result.split(" ")[1])
+                    inserted_count += int(result.rsplit(" ", 1)[-1])
                 except (IndexError, ValueError):
                     continue
 
@@ -706,7 +710,7 @@ class AsyncpgADKMemoryStore(BaseAsyncADKMemoryStore["AsyncpgConfig"]):
             candidate_limit = max(limit_value * 2, 50)
             sql = f"""
             WITH vector_matches AS (
-                SELECT id, RANK() OVER (ORDER BY embedding <=> {p_vec}) AS rank_vec
+                SELECT id, RANK() OVER (ORDER BY embedding <=> {p_vec}::float8[]::vector) AS rank_vec
                 FROM {self._memory_table}
                 WHERE {where_scope} AND embedding IS NOT NULL
                 LIMIT {p_cand}
@@ -732,7 +736,7 @@ class AsyncpgADKMemoryStore(BaseAsyncADKMemoryStore["AsyncpgConfig"]):
             sql = f"""
             SELECT * FROM {self._memory_table}
             WHERE {where_scope} AND embedding IS NOT NULL
-            ORDER BY embedding <=> {p_vec} ASC, timestamp DESC
+            ORDER BY embedding <=> {p_vec}::float8[]::vector ASC, timestamp DESC
             LIMIT {p_lim}
             """
             params = (*scope_params, list(embedding), limit_value)
@@ -759,6 +763,8 @@ class AsyncpgADKMemoryStore(BaseAsyncADKMemoryStore["AsyncpgConfig"]):
             params = (*scope_params, f"%{query}%", limit_value)
 
         async with self._config.provide_connection() as conn:
+            if embedding is not None and self._enable_bm25 and query:
+                self._config._ensure_pg_textsearch_available()
             rows = await conn.fetch(sql, *params)
         return [cast("StoredMemory", dict(row)) for row in rows]
 
@@ -821,7 +827,7 @@ class AsyncpgADKMemoryStore(BaseAsyncADKMemoryStore["AsyncpgConfig"]):
 
         if self._enable_bm25:
             indexes.append(
-                f"CREATE INDEX IF NOT EXISTS idx_{self._memory_table}_bm25 ON {self._memory_table} USING bm25 (content_text);"
+                f"CREATE INDEX IF NOT EXISTS idx_{self._memory_table}_bm25 ON {self._memory_table} USING bm25 (content_text) WITH (text_config='english');"
             )
 
         if self._vector_index_type == "scann":

sqlspec/adapters/asyncpg/config.py

@@ -326,6 +326,8 @@ class AsyncpgConfig(AsyncDatabaseConfig[AsyncpgConnection, "Pool[Record]", Async
         self._alloydb_connector: Any | None = None
         self._pgvector_available: bool | None = None
         self._paradedb_available: bool | None = None
+        self._pg_textsearch_available: bool | None = None
+        self._pg_textsearch_probe_error: Exception | None = None
 
         self._validate_connector_config()
 
@@ -452,17 +454,28 @@ class AsyncpgConfig(AsyncDatabaseConfig[AsyncpgConnection, "Pool[Record]", Async
         if self._pgvector_available is None:
             detected_extensions: set[str] = set()
             extensions = build_postgres_extension_probe_names(self.driver_features)
+            adk_config = self.extension_config.get("adk", {})
+            bm25_enabled = bool(
+                isinstance(adk_config, dict)
+                and adk_config.get("enable_memory", True)
+                and adk_config.get("enable_bm25", False)
+            )
+            if bm25_enabled:
+                extensions.append("pg_textsearch")
             if extensions:
                 try:
                     results = await connection.fetch(
                         "SELECT extname FROM pg_extension WHERE extname = ANY($1::text[])", extensions
                     )
                     detected_extensions = {r["extname"] for r in results}
-                except Exception:
+                except Exception as exc:
                     detected_extensions = set()
+                    if bm25_enabled:
+                        self._pg_textsearch_probe_error = exc
             self.statement_config, self._pgvector_available, self._paradedb_available = (
                 resolve_postgres_extension_state(self.statement_config, self.driver_features, detected_extensions)
             )
+            self._pg_textsearch_available = "pg_textsearch" in detected_extensions if bm25_enabled else False
 
         if self._pgvector_available:
             await register_pgvector_support(connection)
@@ -471,6 +484,12 @@ class AsyncpgConfig(AsyncDatabaseConfig[AsyncpgConnection, "Pool[Record]", Async
         if self._user_connection_hook is not None:
             await self._user_connection_hook(connection)
 
+    def _ensure_pg_textsearch_available(self) -> None:
+        if self._pg_textsearch_available:
+            return
+        msg = "ADK memory enable_bm25 requires the pg_textsearch PostgreSQL extension"
+        raise ImproperConfigurationError(msg) from self._pg_textsearch_probe_error
+
     async def _close_pool(self) -> None:
         """Close the actual async connection pool and cleanup connectors."""
         if self.connection_instance:

sqlspec/adapters/psycopg/adk/store.py

@@ -1240,6 +1240,8 @@ class PsycopgAsyncADKMemoryStore(BaseAsyncADKMemoryStore["PsycopgAsyncConfig"]):
             return
 
         async with self._config.provide_session() as driver:
+            if self._enable_bm25:
+                self._config._ensure_pg_textsearch_available()
             await driver.execute_script(await self._memory_table_ddl())
 
     async def insert_memory_entries(self, entries: "list[StoredMemory]", owner_id: "object | None" = None) -> int:
@@ -1256,10 +1258,10 @@ class PsycopgAsyncADKMemoryStore(BaseAsyncADKMemoryStore["PsycopgAsyncConfig"]):
             query = pg_sql.SQL("""
             INSERT INTO {table} (
                 id, session_id, app_name, user_id, scope, event_id, author,
-                {owner_id_col}, timestamp, content_json, content_text,
+                {owner_id_col}, timestamp, embedding, content_json, content_text,
                 metadata_json, inserted_at
             ) VALUES (
-                %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s
+                %s, %s, %s, %s, %s, %s, %s, %s, %s, %s::float8[]::vector, %s, %s, %s, %s
             )
             ON CONFLICT (event_id) DO NOTHING
             """).format(
@@ -1269,9 +1271,9 @@ class PsycopgAsyncADKMemoryStore(BaseAsyncADKMemoryStore["PsycopgAsyncConfig"]):
             query = pg_sql.SQL("""
             INSERT INTO {table} (
                 id, session_id, app_name, user_id, scope, event_id, author,
-                timestamp, content_json, content_text, metadata_json, inserted_at
+                timestamp, embedding, content_json, content_text, metadata_json, inserted_at
             ) VALUES (
-                %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s
+                %s, %s, %s, %s, %s, %s, %s, %s, %s::float8[]::vector, %s, %s, %s, %s
             )
             ON CONFLICT (event_id) DO NOTHING
             """).format(table=pg_sql.Identifier(self._memory_table))
@@ -1395,7 +1397,7 @@ class PsycopgAsyncADKMemoryStore(BaseAsyncADKMemoryStore["PsycopgAsyncConfig"]):
         sql = pg_sql.SQL(
             """
             WITH vector_matches AS (
-                SELECT id, RANK() OVER (ORDER BY embedding <=> %s) AS rank_vec
+                SELECT id, RANK() OVER (ORDER BY embedding <=> %s::float8[]::vector) AS rank_vec
                 FROM {table}
                 WHERE {where_scope} AND embedding IS NOT NULL
                 LIMIT %s
@@ -1417,6 +1419,7 @@ class PsycopgAsyncADKMemoryStore(BaseAsyncADKMemoryStore["PsycopgAsyncConfig"]):
         ).format(table=pg_sql.Identifier(self._memory_table), where_scope=where_scope)
         params = (list(embedding), *scope_params, candidate_limit, query, *scope_params, candidate_limit, limit)
         async with self._config.provide_connection() as conn, conn.cursor(row_factory=dict_row) as cur:
+            self._config._ensure_pg_textsearch_available()
             await cur.execute(sql, params)
             rows = await cur.fetchall()
         return _rows_to_records(rows)
@@ -1434,7 +1437,7 @@ class PsycopgAsyncADKMemoryStore(BaseAsyncADKMemoryStore["PsycopgAsyncConfig"]):
             """
             SELECT * FROM {table}
             WHERE {where_scope} AND embedding IS NOT NULL
-            ORDER BY embedding <=> %s ASC, timestamp DESC
+            ORDER BY embedding <=> %s::float8[]::vector ASC, timestamp DESC
             LIMIT %s
             """
         ).format(table=pg_sql.Identifier(self._memory_table), where_scope=where_scope)
@@ -1504,6 +1507,8 @@ class PsycopgSyncADKMemoryStore(BaseSyncADKMemoryStore["PsycopgSyncConfig"]):
             return
 
         with self._config.provide_session() as driver:
+            if self._enable_bm25:
+                self._config._ensure_pg_textsearch_available()
             driver.execute_script(self._memory_table_ddl())
 
     def insert_memory_entries(self, entries: "list[StoredMemory]", owner_id: "object | None" = None) -> int:
@@ -1520,10 +1525,10 @@ class PsycopgSyncADKMemoryStore(BaseSyncADKMemoryStore["PsycopgSyncConfig"]):
             query = pg_sql.SQL("""
             INSERT INTO {table} (
                 id, session_id, app_name, user_id, scope, event_id, author,
-                {owner_id_col}, timestamp, content_json, content_text,
+                {owner_id_col}, timestamp, embedding, content_json, content_text,
                 metadata_json, inserted_at
             ) VALUES (
-                %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s
+                %s, %s, %s, %s, %s, %s, %s, %s, %s, %s::float8[]::vector, %s, %s, %s, %s
             )
             ON CONFLICT (event_id) DO NOTHING
             """).format(
@@ -1533,9 +1538,9 @@ class PsycopgSyncADKMemoryStore(BaseSyncADKMemoryStore["PsycopgSyncConfig"]):
             query = pg_sql.SQL("""
             INSERT INTO {table} (
                 id, session_id, app_name, user_id, scope, event_id, author,
-                timestamp, content_json, content_text, metadata_json, inserted_at
+                timestamp, embedding, content_json, content_text, metadata_json, inserted_at
             ) VALUES (
-                %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s
+                %s, %s, %s, %s, %s, %s, %s, %s, %s::float8[]::vector, %s, %s, %s, %s
             )
             ON CONFLICT (event_id) DO NOTHING
             """).format(table=pg_sql.Identifier(self._memory_table))
@@ -1656,7 +1661,7 @@ class PsycopgSyncADKMemoryStore(BaseSyncADKMemoryStore["PsycopgSyncConfig"]):
         sql = pg_sql.SQL(
             """
             WITH vector_matches AS (
-                SELECT id, RANK() OVER (ORDER BY embedding <=> %s) AS rank_vec
+                SELECT id, RANK() OVER (ORDER BY embedding <=> %s::float8[]::vector) AS rank_vec
                 FROM {table}
                 WHERE {where_scope} AND embedding IS NOT NULL
                 LIMIT %s
@@ -1678,6 +1683,7 @@ class PsycopgSyncADKMemoryStore(BaseSyncADKMemoryStore["PsycopgSyncConfig"]):
         ).format(table=pg_sql.Identifier(self._memory_table), where_scope=where_scope)
         params = (list(embedding), *scope_params, candidate_limit, query, *scope_params, candidate_limit, limit)
         with self._config.provide_connection() as conn, conn.cursor(row_factory=dict_row) as cur:
+            self._config._ensure_pg_textsearch_available()
             cur.execute(sql, params)
             rows = cur.fetchall()
         return _rows_to_records(rows)
@@ -1695,7 +1701,7 @@ class PsycopgSyncADKMemoryStore(BaseSyncADKMemoryStore["PsycopgSyncConfig"]):
             """
             SELECT * FROM {table}
             WHERE {where_scope} AND embedding IS NOT NULL
-            ORDER BY embedding <=> %s ASC, timestamp DESC
+            ORDER BY embedding <=> %s::float8[]::vector ASC, timestamp DESC
             LIMIT %s
             """
         ).format(table=pg_sql.Identifier(self._memory_table), where_scope=where_scope)
@@ -1760,6 +1766,7 @@ def _build_insert_params(entry: "StoredMemory") -> "tuple[object, ...]":
         entry["event_id"],
         entry["author"],
         entry["timestamp"],
+        entry.get("embedding"),
         Jsonb(entry["content_json"]),
         entry["content_text"],
         Jsonb(entry["metadata_json"]) if entry["metadata_json"] is not None else None,
@@ -1778,6 +1785,7 @@ def _build_insert_params_with_owner(entry: "StoredMemory", owner_id: "object | N
         entry["author"],
         owner_id,
         entry["timestamp"],
+        entry.get("embedding"),
         Jsonb(entry["content_json"]),
         entry["content_text"],
         Jsonb(entry["metadata_json"]) if entry["metadata_json"] is not None else None,
@@ -1868,7 +1876,7 @@ def _postgres_memory_indexes(
 
     if enable_bm25:
         indexes.append(
-            f"CREATE INDEX IF NOT EXISTS idx_{memory_table}_bm25 ON {memory_table} USING bm25 (content_text);"
+            f"CREATE INDEX IF NOT EXISTS idx_{memory_table}_bm25 ON {memory_table} USING bm25 (content_text) WITH (text_config='english');"
         )
 
     if vector_index_type == "scann":

sqlspec/adapters/psycopg/config.py

@@ -312,6 +312,8 @@ class PsycopgSyncConfig(SyncDatabaseConfig[PsycopgSyncConnection, ConnectionPool
         features_dict.setdefault("alloydb_ip_type", "PRIVATE")
         self._pgvector_available: bool | None = None
         self._paradedb_available: bool | None = None
+        self._pg_textsearch_available: bool | None = None
+        self._pg_textsearch_probe_error: Exception | None = None
         self._alloydb_connector: Any | None = None
 
         super().__init__(
@@ -428,6 +430,14 @@ class PsycopgSyncConfig(SyncDatabaseConfig[PsycopgSyncConnection, ConnectionPool
         if self._pgvector_available is None:
             detected_extensions: set[str] = set()
             extensions = build_postgres_extension_probe_names(self.driver_features)
+            adk_config = self.extension_config.get("adk", {})
+            bm25_enabled = bool(
+                isinstance(adk_config, dict)
+                and adk_config.get("enable_memory", True)
+                and adk_config.get("enable_bm25", False)
+            )
+            if bm25_enabled:
+                extensions.append("pg_textsearch")
             if extensions:
                 try:
                     cursor = conn.execute(
@@ -435,11 +445,14 @@ class PsycopgSyncConfig(SyncDatabaseConfig[PsycopgSyncConnection, ConnectionPool
                     )
                     results = cursor.fetchall()
                     detected_extensions = {r[0] for r in results}  # type: ignore[index]
-                except Exception:
+                except Exception as exc:
                     detected_extensions = set()
+                    if bm25_enabled:
+                        self._pg_textsearch_probe_error = exc
             self.statement_config, self._pgvector_available, self._paradedb_available = (
                 resolve_postgres_extension_state(self.statement_config, self.driver_features, detected_extensions)
             )
+            self._pg_textsearch_available = "pg_textsearch" in detected_extensions if bm25_enabled else False
 
         if self._pgvector_available:
             register_pgvector_sync(conn)
@@ -452,6 +465,12 @@ class PsycopgSyncConfig(SyncDatabaseConfig[PsycopgSyncConnection, ConnectionPool
         if self._user_connection_hook is not None:
             self._user_connection_hook(conn)
 
+    def _ensure_pg_textsearch_available(self) -> None:
+        if self._pg_textsearch_available:
+            return
+        msg = "ADK memory enable_bm25 requires the pg_textsearch PostgreSQL extension"
+        raise ImproperConfigurationError(msg) from self._pg_textsearch_probe_error
+
     def _close_pool(self) -> None:
         """Close the actual connection pool and cleanup connectors."""
         try:
@@ -638,6 +657,8 @@ class PsycopgAsyncConfig(AsyncDatabaseConfig[PsycopgAsyncConnection, AsyncConnec
         )
         self._pgvector_available: bool | None = None
         self._paradedb_available: bool | None = None
+        self._pg_textsearch_available: bool | None = None
+        self._pg_textsearch_probe_error: Exception | None = None
 
         super().__init__(
             connection_config=connection_config,
@@ -700,6 +721,14 @@ class PsycopgAsyncConfig(AsyncDatabaseConfig[PsycopgAsyncConnection, AsyncConnec
         if self._pgvector_available is None:
             detected_extensions: set[str] = set()
             extensions = build_postgres_extension_probe_names(self.driver_features)
+            adk_config = self.extension_config.get("adk", {})
+            bm25_enabled = bool(
+                isinstance(adk_config, dict)
+                and adk_config.get("enable_memory", True)
+                and adk_config.get("enable_bm25", False)
+            )
+            if bm25_enabled:
+                extensions.append("pg_textsearch")
             if extensions:
                 try:
                     cursor = await conn.execute(
@@ -707,11 +736,14 @@ class PsycopgAsyncConfig(AsyncDatabaseConfig[PsycopgAsyncConnection, AsyncConnec
                     )
                     results = await cursor.fetchall()
                     detected_extensions = {r[0] for r in results}  # type: ignore[index]
-                except Exception:
+                except Exception as exc:
                     detected_extensions = set()
+                    if bm25_enabled:
+                        self._pg_textsearch_probe_error = exc
             self.statement_config, self._pgvector_available, self._paradedb_available = (
                 resolve_postgres_extension_state(self.statement_config, self.driver_features, detected_extensions)
             )
+            self._pg_textsearch_available = "pg_textsearch" in detected_extensions if bm25_enabled else False
 
         if self._pgvector_available:
             await register_pgvector_async(conn)
@@ -724,6 +756,12 @@ class PsycopgAsyncConfig(AsyncDatabaseConfig[PsycopgAsyncConnection, AsyncConnec
         if self._user_connection_hook is not None:
             await self._user_connection_hook(conn)
 
+    def _ensure_pg_textsearch_available(self) -> None:
+        if self._pg_textsearch_available:
+            return
+        msg = "ADK memory enable_bm25 requires the pg_textsearch PostgreSQL extension"
+        raise ImproperConfigurationError(msg) from self._pg_textsearch_probe_error
+
     async def _close_pool(self) -> None:
         """Close the actual async connection pool."""
         if not self.connection_instance:

sqlspec/builder/_ddl.py

@@ -688,7 +688,7 @@ class _SingleObjectDropBuilder(DDLBuilder, _IfExistsDDLMixin, _CascadeRestrictDD
         self._require(self._name, f"{self._object_label} name must be set for DROP {self._drop_kind}.")
         return exp.Drop(
             kind=self._drop_kind,
-            this=self._build_drop_this(),
+            tables=[self._build_drop_this()],
             exists=self._if_exists,
             cascade=self._cascade,
             **self._drop_expression_args(),
@@ -1464,10 +1464,10 @@ class AlterTable(DDLBuilder, _IfExistsDDLMixin):
             return build_column_expression(op.column_definition)
 
         if op_type == "DROP COLUMN":
-            return exp.Drop(this=exp.to_identifier(op.column_name), kind="COLUMN", exists=True)
+            return exp.Drop(tables=[exp.to_identifier(op.column_name)], kind="COLUMN", exists=True)
 
         if op_type == "DROP COLUMN CASCADE":
-            return exp.Drop(this=exp.to_identifier(op.column_name), kind="COLUMN", cascade=True, exists=True)
+            return exp.Drop(tables=[exp.to_identifier(op.column_name)], kind="COLUMN", cascade=True, exists=True)
 
         if op_type == "ALTER COLUMN TYPE":
             if not op.new_type:
@@ -1488,10 +1488,12 @@ class AlterTable(DDLBuilder, _IfExistsDDLMixin):
             return exp.AddConstraint(expressions=[constraint_expr])
 
         if op_type == "DROP CONSTRAINT":
-            return exp.Drop(this=exp.to_identifier(op.constraint_name), kind="CONSTRAINT", exists=True)
+            return exp.Drop(tables=[exp.to_identifier(op.constraint_name)], kind="CONSTRAINT", exists=True)
 
         if op_type == "DROP CONSTRAINT CASCADE":
-            return exp.Drop(this=exp.to_identifier(op.constraint_name), kind="CONSTRAINT", cascade=True, exists=True)
+            return exp.Drop(
+                tables=[exp.to_identifier(op.constraint_name)], kind="CONSTRAINT", cascade=True, exists=True
+            )
 
         if op_type == "ALTER COLUMN SET NOT NULL":
             return exp.AlterColumn(this=exp.to_identifier(op.column_name), allow_null=False)

sqlspec/config.py

@@ -739,7 +739,7 @@ class ADKConfig(TypedDict):
     """Dimensionality of embedding vectors (e.g. 768 for gemini-embedding-001 with MRL). Default: 768."""
 
     enable_bm25: NotRequired[bool]
-    """Enable native pg_textsearch BM25 full-text indexing on AlloyDB / PostgreSQL 17+. Default: False."""
+    """Enable native BM25 full-text indexing. Requires the pg_textsearch extension. Default: False."""
 
     scann_num_leaves: NotRequired[int]
     """Number of partition leaves (clusters) for ScaNN tree quantization. Default: 100."""
@@ -1524,8 +1524,8 @@ class DatabaseConfigProtocol(ABC, Generic[ConnectionT, PoolT, DriverT]):
         self.extension_config = extension_config or {}
         self.migration_config = migration_config or {}
         self._init_observability(observability_config)
-        self._initialize_migration_components()
         self.statement_config = statement_config or build_default_statement_config(default_dialect)
+        self._initialize_migration_components()
         self._storage_capabilities = None
         self.driver_features = seed_runtime_driver_features(driver_features, self.storage_capabilities())
         self._attach_lifecycle_hooks()

sqlspec/extensions/adk/migrations/0001_create_adk_tables.py

@@ -8,8 +8,8 @@ Creates the canonical ADK tables:
 - adk_internal_metadata
 - adk_memory (when memory is enabled)
 
-On PostgreSQL the migration installs the ``vector`` extension before the first
-memory statement that declares a ``VECTOR`` column.
+On PostgreSQL the migration installs required extensions before the first
+memory statement that uses them.
 """
 
 import inspect
@@ -38,9 +38,11 @@ __all__ = ("down", "up")
 logger = get_logger("sqlspec.migrations.adk.create")
 
 CREATE_VECTOR_EXTENSION = "CREATE EXTENSION IF NOT EXISTS vector"
+CREATE_PG_TEXTSEARCH_EXTENSION = "CREATE EXTENSION IF NOT EXISTS pg_textsearch"
 
 _POSTGRES_DIALECTS = frozenset({"postgres", "postgresql", "pgvector", "paradedb"})
 _VECTOR_COLUMN_PATTERN = re.compile(r"\bVECTOR\s*\(", re.IGNORECASE)
+_BM25_INDEX_PATTERN = re.compile(r"\bUSING\s+bm25\s*\(", re.IGNORECASE)
 
 
 async def up(context: "MigrationContext | None" = None) -> "list[str]":
@@ -70,7 +72,7 @@ async def up(context: "MigrationContext | None" = None) -> "list[str]":
             if inspect.isawaitable(memory_sql):
                 memory_sql = await memory_sql
             memory_statements = list(memory_sql) if isinstance(memory_sql, list) else [memory_sql]
-            statements.extend(_with_vector_extension(memory_statements, context))
+            statements.extend(_with_postgres_extensions(memory_statements, context))
             log_with_context(
                 logger, logging.DEBUG, "adk.migration.create.memory.create", table_name=memory_store.memory_table
             )
@@ -98,15 +100,24 @@ async def down(context: "MigrationContext | None" = None) -> "list[str]":
     return statements
 
 
-def _with_vector_extension(statements: "list[str]", context: "MigrationContext") -> "list[str]":
-    """Prepend the PostgreSQL vector extension before the first vector statement."""
+def _with_postgres_extensions(statements: "list[str]", context: "MigrationContext") -> "list[str]":
+    """Prepend required PostgreSQL extensions before their first use."""
     dialect = (context.dialect or "").lower()
     if dialect not in _POSTGRES_DIALECTS:
         return statements
-    for index, statement in enumerate(statements):
-        if _VECTOR_COLUMN_PATTERN.search(statement):
-            return [*statements[:index], CREATE_VECTOR_EXTENSION, *statements[index:]]
-    return statements
+
+    result: list[str] = []
+    vector_enabled = False
+    pg_textsearch_enabled = False
+    for statement in statements:
+        if not vector_enabled and _VECTOR_COLUMN_PATTERN.search(statement):
+            result.append(CREATE_VECTOR_EXTENSION)
+            vector_enabled = True
+        if not pg_textsearch_enabled and _BM25_INDEX_PATTERN.search(statement):
+            result.append(CREATE_PG_TEXTSEARCH_EXTENSION)
+            pg_textsearch_enabled = True
+        result.append(statement)
+    return result
 
 
 def _raise_missing_config() -> NoReturn:

sqlspec/extensions/litestar/plugin.py

@@ -833,12 +833,21 @@ class SQLSpecPlugin(InitPluginProtocol, CLIPlugin):
         Args:
             name: A ``session_key``, ``connection_key``, or ``pool_key``.
 
+        Raises:
+            KeyError: If ``name`` is not a known dependency key.
+
         Returns:
             The matching plugin state.
         """
-        if any(state.annotation is None for state in self._plugin_configs):
-            self._raise_plugin_not_registered()
-        return self._get_plugin_state(name)
+        if isinstance(name, str) and any(
+            name in {state.connection_key, state.pool_key, state.session_key} for state in self._plugin_configs
+        ):
+            if any(state.annotation is None for state in self._plugin_configs):
+                self._raise_plugin_not_registered()
+            return self._get_plugin_state(name)
+        self._raise_config_not_found(name)
+        msg = "unreachable"
+        raise AssertionError(msg)
 
     def _get_plugin_state(
         self, key: "str | DatabaseConfigProtocol[Any, Any, Any] | type[DatabaseConfigProtocol[Any, Any, Any]]"

{sqlspec-0.62.0.dist-info → sqlspec-0.62.2.dist-info}/METADATA

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

{sqlspec-0.62.0.dist-info → sqlspec-0.62.2.dist-info}/RECORD

@@ -4,7 +4,7 @@ sqlspec/__metadata__.py,sha256=IUw6MCTy1oeUJ1jAVYbuJLkOWbiAWorZ5W-E-SAD9N4,395
 sqlspec/_typing.py,sha256=OLBKW7FSh22fPAr4BiLmFBovxi0MSVvA-KJzWE7RDDE,21809
 sqlspec/base.py,sha256=-yJlxdfDpZ-SHMTav87zqs39pu6zsKsLXBJYp8MsmPY,30257
 sqlspec/cli.py,sha256=2cD6ZYoXGA5RyGD_KtIulfbSp3YtK3RNNW3pqEDZ0I8,42427
-sqlspec/config.py,sha256=uPGzMq3RAYpHC674TsbWdlcYytU-c3IfsJ6DogwfPbc,81605
+sqlspec/config.py,sha256=m5MWkorlbju3AiQ1ruIvXcDv_dkqJgsBwzQ2IJEyURs,81601
 sqlspec/exceptions.py,sha256=kbk9JjaWlBIQ6xeZIJHlhKMDd1RSOPSzqgAZ4dTk9xs,15128
 sqlspec/loader.py,sha256=SMTEa6MFg6EqnKuENNQDOPizKGXD2YuaE4COjE_3MFk,36208
 sqlspec/protocols.py,sha256=zfFH3w343I3qn11Fvo20jmghmTCd3GQWW-kpx8RQN9c,33942
@@ -66,24 +66,24 @@ sqlspec/adapters/arrow_odbc/litestar/__init__.py,sha256=8X-ptnPzniv1GvGOYSUHLKil
 sqlspec/adapters/arrow_odbc/litestar/store.py,sha256=XJ_g9w3-pRdVK-eh8MBCkDbFe2gGZzdwt5mKzsBV01U,11508
 sqlspec/adapters/asyncmy/__init__.py,sha256=EgFaxoi1bDhcJIo2ApXG2rsJ1q5ELvMv4PeV3A27OPA,671
 sqlspec/adapters/asyncmy/_typing.py,sha256=B-sge2R-b8LwFUNfgtfHT68qMGOwcA2n6B7gppHY55Q,5215
-sqlspec/adapters/asyncmy/config.py,sha256=0cF9xapSn8O602WJuiPomRbujSExN3zGp4YzH4V4DA4,16512
+sqlspec/adapters/asyncmy/config.py,sha256=F2rY_QWIgKFJgTDHm2AhfAsfZpjGFJVbWoAdwgaJboc,16491
 sqlspec/adapters/asyncmy/core.py,sha256=DD9cIVq79qaqnrdXyrsYZ5EEwIkj6TkqeUUmfkSawoA,23019
 sqlspec/adapters/asyncmy/data_dictionary.py,sha256=8Xc9YhdS9JL2JpSscDiSha6q82sbKi7SwDGI2tyPx5k,14278
 sqlspec/adapters/asyncmy/driver.py,sha256=nK6hL5DA7SFvD4NYagpmMCmXNHDfUs2kW599GwfVEho,18344
 sqlspec/adapters/asyncmy/adk/__init__.py,sha256=jD7XeHf01jPsMigmHVHg2rh3Zs_41hzNf4ejzIOP6Fk,239
-sqlspec/adapters/asyncmy/adk/store.py,sha256=dXBsqfvxay-xc8tbsZDJ8lQpRm_oM03ksqJXdJyqBEI,38487
+sqlspec/adapters/asyncmy/adk/store.py,sha256=0tS7lGJLB1cG7IsVZ1aXnbWvH6Op6w8lGjNWlMlILj0,38350
 sqlspec/adapters/asyncmy/events/__init__.py,sha256=lbYNTyDvrtMm9Cg_IP4x-_4CymFl2SU-nkBjc7sz45k,159
 sqlspec/adapters/asyncmy/events/store.py,sha256=zQMzTYuZkX1Tuw_jXnwLM19IPMgOeH90JQdAjX0VeUo,2687
 sqlspec/adapters/asyncmy/litestar/__init__.py,sha256=VNBusWFPvw4BBLHi7gSSY3S94JxjZ7oJoAavTVvcZ28,143
-sqlspec/adapters/asyncmy/litestar/store.py,sha256=uMApWsPTa0ljunTJr0TpsrHwMs6Irrw7S2jSjJPd8I0,10563
+sqlspec/adapters/asyncmy/litestar/store.py,sha256=1xFCxR-8KXCRmzbNflxnTuuOkbwq-RZpq8vXg1kZ17g,10626
 sqlspec/adapters/asyncpg/__init__.py,sha256=mgfrmVs5E1jnKUM76AosWJ2Lceuq0dRw-49xcgAxpxo,751
 sqlspec/adapters/asyncpg/_typing.py,sha256=67ElS_NC8PAI8wMb7tY_-DXo_tdE_HSkexqsDVBJ73A,3727
-sqlspec/adapters/asyncpg/config.py,sha256=v3i12_rOq2ixf7vNYL9hYDHDscTj2h-nWiYbxByEjdY,24893
+sqlspec/adapters/asyncpg/config.py,sha256=80IzVYLKkwcFWH9rhUp5lzzCSM44oLef8NKfGVxkyEQ,25868
 sqlspec/adapters/asyncpg/core.py,sha256=r1oj6HFR3950GeHmA0PrsnvkgQ2iYNtc9BhTKX4imnI,19522
 sqlspec/adapters/asyncpg/data_dictionary.py,sha256=Wdg-moMyVJHUUaIpuUhwCaFMN8pJmKiW5sTsQ6PDpck,17926
 sqlspec/adapters/asyncpg/driver.py,sha256=xmXl2LH2MS44yUj9Thp1opjbNhDZR0Dj_aNYRiG-ICk,30903
 sqlspec/adapters/asyncpg/adk/__init__.py,sha256=p1ZELfzC21x4zE9vl4How2_-UIdxkWt0HVhrISWl0iQ,213
-sqlspec/adapters/asyncpg/adk/store.py,sha256=BmHqk8l3hUgXqFGmr9WbIBXUIswGPMxjriinA8Lf_04,36483
+sqlspec/adapters/asyncpg/adk/store.py,sha256=-3-PuWfRPAA-SnSeyg7XTQCWQT5B5zzyr2e0IMsMiQ4,36947
 sqlspec/adapters/asyncpg/events/__init__.py,sha256=YOlB9kRztWLqMeW87AGQKBTLIYNM2puuKy_EwWKvJX8,301
 sqlspec/adapters/asyncpg/events/_hub.py,sha256=flKFiiSvpVT9sR11wA99X00mvmAE7dr5me3tCrQgt-M,9834
 sqlspec/adapters/asyncpg/events/backend.py,sha256=fLC8XAJd6LLqjLOMch5PTiGUOrlSUVs8-jqrTZgtPRU,15493
@@ -204,13 +204,13 @@ sqlspec/adapters/psqlpy/litestar/__init__.py,sha256=ODTxzJFNmexprYuBZcCxQWsJXPuS
 sqlspec/adapters/psqlpy/litestar/store.py,sha256=gjDTnxUCS4_79Q2dqtwxn9fXiJlCiA89REr2RkgUXrU,8779
 sqlspec/adapters/psycopg/__init__.py,sha256=mYXt-Jl2BD35wnOIodPGFfYRKUQ6AT_X1qoUUhb5S4A,969
 sqlspec/adapters/psycopg/_typing.py,sha256=eGbCUsktUgx7wC92poF8k2j-Fw5AYlJc5szmKvrJOLo,8103
-sqlspec/adapters/psycopg/config.py,sha256=GqFJRSk8P4qw37DbWtK5lKto_mZb_wYOXoNRe-NwadY,35195
+sqlspec/adapters/psycopg/config.py,sha256=tlR1m3oxht4IaMycw5sFBaAW-w01oZ-YvuzbU3W1xnE,37145
 sqlspec/adapters/psycopg/core.py,sha256=J5P-mE1Bv5t0411HJNLrWI9LWVVVUnxM1hrusN3wz9E,24902
 sqlspec/adapters/psycopg/data_dictionary.py,sha256=xtEhbOk49iZgkncskH8tE0sX1-YfZxHgg08dB_ovheA,30658
 sqlspec/adapters/psycopg/driver.py,sha256=FoZc_Z8aOmddmEPNtnINa45tNCoCVpA0v0sQ9LsB_WA,58156
 sqlspec/adapters/psycopg/type_converter.py,sha256=C-ynmx47HvpBOd4UalspSEnFMeRE9kZBIkOdhtsz_X4,2980
 sqlspec/adapters/psycopg/adk/__init__.py,sha256=WYeffXiBnWiCXLGKkP03zsWEz_BtfU8S79P2nd5ePXA,381
-sqlspec/adapters/psycopg/adk/store.py,sha256=IZmATs6GdHee3p-4_PzNvmuprJ9wIxBW9yakkdIr3mI,80420
+sqlspec/adapters/psycopg/adk/store.py,sha256=VJWWc1yRiigdysto2IbB0zHPJuBSw2y-M7Bh6JDNq5c,81025
 sqlspec/adapters/psycopg/events/__init__.py,sha256=bJTqdKRaUZeDqn13rIS4zPKVm79fbkoch-8dceYgVYc,623
 sqlspec/adapters/psycopg/events/_hub.py,sha256=YssMbQ1_UCe4P_OhVF4wkYyXyeftBFegJ77sGWyL-yM,21051
 sqlspec/adapters/psycopg/events/backend.py,sha256=c6RJGGPVl0QVxz5kZndjgzyu4kctrHxzlrJo1Gv6e6o,28692
@@ -274,7 +274,7 @@ sqlspec/adapters/sqlite/litestar/store.py,sha256=d8Uk2YdbbkpIWKhLmVWue16fXVRfALx
 sqlspec/builder/__init__.py,sha256=S-yrPxGah-kKg0OtDE05qkB8nIRsVlNmtsP5dEchKW8,4380
 sqlspec/builder/_base.py,sha256=JPhbA_NyHsvB1cCvkyX4qYmfYKIR5-Hb3Xt3h4y3ACA,39774
 sqlspec/builder/_column.py,sha256=_Do3Xt7wkk2uEmdNKIIx3uMgEjdeXhGMmQbMbIefQ1Y,16312
-sqlspec/builder/_ddl.py,sha256=ll33voSWitHYFKt7pgrlZc3_p2hpIpUimkdEEryemCA,58056
+sqlspec/builder/_ddl.py,sha256=bNpLdHYo9z_N5U518dR2ua2Se8sFgD2pR8a8OAFQk_M,58106
 sqlspec/builder/_delete.py,sha256=--KFsRs1XUA3TE1PZNd5YQgmyCJGaA4GvEGgiUho80U,2614
 sqlspec/builder/_dml.py,sha256=1uQJ9jcXXHTQcfe00voNmEIxLvoaRAjZgScLZF_jO4w,15373
 sqlspec/builder/_explain.py,sha256=S7wDHWeraZDft_hJZm6ajgJiwIzRo6E5-yIXThhTsH4,18813
@@ -556,7 +556,7 @@ sqlspec/extensions/adk/memory/_types.py,sha256=2WRAEmug7D0upyakhx5QpbgOEH2dMAoSX
 sqlspec/extensions/adk/memory/converters.py,sha256=zxH4rY6dEsP0Hw05DjyA6Y3iUGBHl0N9vFLktOKeEo8,7930
 sqlspec/extensions/adk/memory/service.py,sha256=QvbRIJlKFnd8MqS6Clq1zvLswFlg39sjQ75TyladkJM,11429
 sqlspec/extensions/adk/memory/store.py,sha256=m86r-gZf8A7Y6XRjr5llGh0Fcwh8_22UDGH6fsCdbrE,16135
-sqlspec/extensions/adk/migrations/0001_create_adk_tables.py,sha256=dE-NmbcN8GIN5-T49Ezopi1Sh-824b1W1KyClYWzwI8,6338
+sqlspec/extensions/adk/migrations/0001_create_adk_tables.py,sha256=EBC8fxJJlC320r6fiOrVQ9o2x-zrZFlcjgZz3PKiEPk,6760
 sqlspec/extensions/adk/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sqlspec/extensions/events/__init__.py,sha256=ZD77SUD7t_g4zpI3RmeL2SGT9cwtx6sDkhmdcIbUoWM,1808
 sqlspec/extensions/events/_buffer.py,sha256=H7Lj4g_AafICFptFVSGquapH5uWrENk27f6wCB559Y0,1404
@@ -583,7 +583,7 @@ sqlspec/extensions/litestar/channels.py,sha256=W-EKVEmXOPrdrcsNh1a-FzIWGcdEE6V24
 sqlspec/extensions/litestar/cli.py,sha256=6ZHIWNT0RPzgr3LOKVAIEk9hUcyJTMUKgnpjkBrdliA,3476
 sqlspec/extensions/litestar/config.py,sha256=EvHRJjAdGuJkbRj0Ke7QsU6eXef_okLLPm0-atD4uXM,3597
 sqlspec/extensions/litestar/handlers.py,sha256=VTtBoCfl8zxtEe9N1_aZrFA4ILrEbP_2FjFuFg-9FF4,11162
-sqlspec/extensions/litestar/plugin.py,sha256=4-dQc_x85_Eoi_buSZ7oqFVeIlkfRy9ND8K0uz1YbPg,46142
+sqlspec/extensions/litestar/plugin.py,sha256=t_e1MHDOx-8Hzn9s7Ua7elcWh68Ove8GVED0xaN6a_8,46506
 sqlspec/extensions/litestar/providers.py,sha256=ofpZf9EJbXVmVyqKkAM2ef1HM_4bEzpAT7EvK1Ejf7k,41361
 sqlspec/extensions/litestar/store.py,sha256=4b9QC4s7R7Xh_6WDbrGKyES__XZuIhtpWw_6uUTDHBg,9996
 sqlspec/extensions/litestar/migrations/0001_create_session_table.py,sha256=60HehSre1tXoHaOBx_75Hha-7smWP61RYrRVBYnIo8w,4206
@@ -665,8 +665,8 @@ sqlspec/utils/serializers/__init__.py,sha256=X99t8YMHVGmKwrqPxumnSXu4JMJL8SpKoU7
 sqlspec/utils/serializers/_json.py,sha256=5PBan5kHoDAGqbOqT33SdEK17VZzNjzZKneWI_BnDzY,18136
 sqlspec/utils/serializers/_numpy.py,sha256=_LllCtVn_gyLrRG2naHM7Unjtpot86BPTvGPlZuAGRw,1742
 sqlspec/utils/serializers/_schema.py,sha256=kN8lW8GJa08yMi_qN_x8A7XpO7V6aAaoYqKq72rxaCk,11416
-sqlspec-0.62.0.dist-info/METADATA,sha256=MPSGT5xHiXgsoJ-CnU7o0C7bS6LEiP49OqoqZQTYgr8,9066
-sqlspec-0.62.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
-sqlspec-0.62.0.dist-info/entry_points.txt,sha256=T_1g2gTpkUsl6YC-KSCoNS5r7CPG2kn6wyp1WyMvpqU,404
-sqlspec-0.62.0.dist-info/licenses/LICENSE,sha256=MdujfZ6l5HuLz4mElxlu049itenOR3gnhN1_Nd3nVcM,1078
-sqlspec-0.62.0.dist-info/RECORD,,
+sqlspec-0.62.2.dist-info/METADATA,sha256=pdDXwLK4BTqODd8EBgo8AAaRs7cRPDUh4sRvnZYACyY,9066
+sqlspec-0.62.2.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+sqlspec-0.62.2.dist-info/entry_points.txt,sha256=T_1g2gTpkUsl6YC-KSCoNS5r7CPG2kn6wyp1WyMvpqU,404
+sqlspec-0.62.2.dist-info/licenses/LICENSE,sha256=MdujfZ6l5HuLz4mElxlu049itenOR3gnhN1_Nd3nVcM,1078
+sqlspec-0.62.2.dist-info/RECORD,,