chore: remove hasattr usages

Author: cofin

AGENTS.md

@@ -155,6 +155,15 @@ class MyAdapterDriver(SyncDriverBase):
     - Add integration tests under `tests/integration/test_adapters/<adapter>/test_driver.py::test_*statement_stack*` that cover native path, sequential fallback, and continue-on-error.
     - Guard base behavior (empty stacks, large stacks, transaction boundaries) via `tests/integration/test_stack_edge_cases.py`.
 
+### ADK Memory Store Pattern
+
+- `SQLSpecMemoryService` delegates storage to adapter-backed memory stores (`BaseAsyncADKMemoryStore` / `BaseSyncADKMemoryStore`).
+- All ADK settings live in `extension_config["adk"]`; memory flags are `enable_memory`, `include_memory_migration`, `memory_table`, `memory_use_fts`, and `memory_max_results`.
+- Search strategy is driver-determined: `memory_use_fts=True` enables adapter FTS when available, otherwise fall back to `LIKE`/`ILIKE` with warning on failure.
+- Deduplication is keyed by `event_id` with idempotent inserts (ignore duplicates, return inserted count).
+- Multi-tenancy uses the shared `owner_id_column` DDL; stores parse the column name to bind filter parameters.
+- TTL cleanup is explicit via store helpers or CLI (`delete_entries_older_than`, `sqlspec adk memory cleanup`).
+
 ### Driver Parameter Profile Registry
 
 - All adapter parameter defaults live in `DriverParameterProfile` entries inside `sqlspec/core/parameters.py`.

docs/guides/adapters/oracledb.md

@@ -905,7 +905,8 @@ For comprehensive examples and migration guides, see:
 - Set `extension_config={"events": {"backend": "advanced_queue"}}` to enable native
   Advanced Queuing support. Event publishing uses `connection.queue()` and
   inherits the AQ options from `extension_config["events"]`
-  (`aq_queue`, `aq_wait_seconds`, `aq_visibility`).
+  (`aq_queue`, `aq_wait_seconds`, `aq_visibility`). Use `AQMSG_VISIBLE` or
+  `AQMSG_INVISIBLE` (string or int constant) for visibility control.
 - AQ requires DBA-provisioned queues plus enqueue/dequeue privileges. When the
   driver detects missing privileges it logs a warning and falls back to the
   durable queue backend automatically.

docs/guides/events/database-event-channels.md

@@ -72,7 +72,7 @@ Optional ``extension_config["events"]`` keys:
 
 - ``aq_queue``: AQ queue name (default ``SQLSPEC_EVENTS_QUEUE``)
 - ``aq_wait_seconds``: dequeue wait timeout (default 5 seconds)
-- ``aq_visibility``: visibility constant (e.g., ``AQMSG_VISIBLE``)
+- ``aq_visibility``: visibility constant (``AQMSG_VISIBLE`` or ``AQMSG_INVISIBLE``) or the integer value.
 
 If AQ is not configured or the Python driver lacks the feature, SQLSpec logs a warning
 and transparently falls back to the table-backed queue backend.

docs/guides/extensions/adk.md

@@ -225,6 +225,12 @@ config = AsyncpgConfig(connection_config={"dsn": "postgresql://..."},
 - Schedule periodic cleanup with adapter-provided pruning helpers or ad-hoc SQL that removes stale rows.
 - Back up tables like any other transactional data; events can grow quickly, so consider partitioning or TTL policies in PostgreSQL (`CREATE POLICY ... USING (create_time > now() - interval '90 days')`).
 
+## Future Enhancements
+
+- Vector/embedding search hooks for adapter-specific similarity queries.
+- Vertex AI Memory Bank and RAG bridge helpers for hybrid deployments.
+- Background TTL pruning workflows for high-volume memory tables.
+
 ## Additional Resources
 
 - API reference: `docs/extensions/adk/`

sqlspec/adapters/adbc/adk/store.py

@@ -1,5 +1,6 @@
 """ADBC ADK store for Google Agent Development Kit session/event storage."""
 
+from datetime import datetime, timezone
 from typing import TYPE_CHECKING, Any, Final
 
 from sqlspec.extensions.adk import BaseSyncADKStore, EventRecord, SessionRecord
@@ -747,8 +748,6 @@ def create_event(
 
         timestamp = kwargs.get("timestamp")
         if timestamp is None:
-            from datetime import datetime, timezone
-
             timestamp = datetime.now(timezone.utc)
 
         with self._config.provide_connection() as conn:

sqlspec/adapters/aiosqlite/driver.py

@@ -2,12 +2,14 @@
 
 import asyncio
 import contextlib
+import random
 from datetime import date, datetime
 from decimal import Decimal
 from typing import TYPE_CHECKING, Any, cast
 
 import aiosqlite
 
+from sqlspec.adapters.aiosqlite.data_dictionary import AiosqliteAsyncDataDictionary
 from sqlspec.core import (
     ArrowResult,
     DriverParameterProfile,
@@ -99,7 +101,7 @@ async def __aexit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
         if issubclass(exc_type, aiosqlite.Error):
             self._map_sqlite_exception(exc_val)
 
-    def _map_sqlite_exception(self, e: Any) -> None:
+    def _map_sqlite_exception(self, e: BaseException) -> None:
         """Map SQLite exception to SQLSpec exception.
 
         Args:
@@ -108,17 +110,18 @@ def _map_sqlite_exception(self, e: Any) -> None:
         Raises:
             Specific SQLSpec exception based on error code
         """
+        exc: BaseException = e
         if has_sqlite_error(e):
             error_code = e.sqlite_errorcode
             error_name = e.sqlite_errorname
         else:
             error_code = None
             error_name = None
-        error_msg = str(e).lower()
+        error_msg = str(exc).lower()
 
         if "locked" in error_msg:
-            msg = f"AIOSQLite database locked: {e}. Consider enabling WAL mode or reducing concurrency."
-            raise SQLSpecError(msg) from e
+            msg = f"AIOSQLite database locked: {exc}. Consider enabling WAL mode or reducing concurrency."
+            raise SQLSpecError(msg) from exc
 
         if not error_code:
             if "unique constraint" in error_msg:
@@ -358,8 +361,6 @@ async def begin(self) -> None:
             if not self.connection.in_transaction:
                 await self.connection.execute("BEGIN IMMEDIATE")
         except aiosqlite.Error as e:
-            import random
-
             max_retries = 3
             for attempt in range(max_retries):
                 delay = 0.01 * (2**attempt) + random.uniform(0, 0.01)  # noqa: S311
@@ -411,8 +412,6 @@ def data_dictionary(self) -> "AsyncDataDictionaryBase":
             Data dictionary instance for metadata queries
         """
         if self._data_dictionary is None:
-            from sqlspec.adapters.aiosqlite.data_dictionary import AiosqliteAsyncDataDictionary
-
             self._data_dictionary = AiosqliteAsyncDataDictionary()
         return self._data_dictionary
 

sqlspec/adapters/asyncmy/adk/memory_store.py

@@ -1,6 +1,7 @@
 """AsyncMy ADK memory store for Google Agent Development Kit memory storage."""
 
 import json
+import re
 from typing import TYPE_CHECKING, Any, Final
 
 import asyncmy
@@ -28,8 +29,6 @@ def _parse_owner_id_column_for_mysql(column_ddl: str) -> "tuple[str, str]":
     Returns:
         Tuple of (column_definition, foreign_key_constraint).
     """
-    import re
-
     references_match = re.search(r"\s+REFERENCES\s+(.+)", column_ddl, re.IGNORECASE)
     if not references_match:
         return (column_ddl.strip(), "")

sqlspec/adapters/asyncmy/adk/store.py

@@ -1,6 +1,7 @@
 """AsyncMy ADK store for Google Agent Development Kit session/event storage."""
 
 import json
+import re
 from typing import TYPE_CHECKING, Any, Final
 
 import asyncmy
@@ -92,8 +93,6 @@ def _parse_owner_id_column_for_mysql(self, column_ddl: str) -> "tuple[str, str]"
             Input: "tenant_id BIGINT NOT NULL REFERENCES tenants(id) ON DELETE CASCADE"
             Output: ("tenant_id BIGINT NOT NULL", "FOREIGN KEY (tenant_id) REFERENCES tenants(id) ON DELETE CASCADE")
         """
-        import re
-
         references_match = re.search(r"\s+REFERENCES\s+(.+)", column_ddl, re.IGNORECASE)
 
         if not references_match:

sqlspec/adapters/asyncmy/driver.py

@@ -10,6 +10,7 @@
 from asyncmy.constants import FIELD_TYPE as ASYNC_MY_FIELD_TYPE  # pyright: ignore
 from asyncmy.cursors import Cursor, DictCursor  # pyright: ignore
 
+from sqlspec.adapters.asyncmy.data_dictionary import MySQLAsyncDataDictionary
 from sqlspec.core import (
     ArrowResult,
     DriverParameterProfile,
@@ -33,7 +34,14 @@
 )
 from sqlspec.utils.logging import get_logger
 from sqlspec.utils.serializers import from_json, to_json
-from sqlspec.utils.type_guards import has_cursor_metadata, has_rowcount, has_sqlstate, has_type_code, supports_json_type
+from sqlspec.utils.type_guards import (
+    has_cursor_metadata,
+    has_lastrowid,
+    has_rowcount,
+    has_sqlstate,
+    has_type_code,
+    supports_json_type,
+)
 
 if TYPE_CHECKING:
     from collections.abc import Callable
@@ -444,11 +452,8 @@ async def _execute_statement(self, cursor: Any, statement: "SQL") -> "ExecutionR
 
         affected_rows = cursor.rowcount if cursor.rowcount is not None else -1
         last_id = None
-        if has_rowcount(cursor) and cursor.rowcount and cursor.rowcount > 0:
-            try:
-                last_id = cursor.lastrowid
-            except AttributeError:
-                last_id = None
+        if has_rowcount(cursor) and cursor.rowcount and cursor.rowcount > 0 and has_lastrowid(cursor):
+            last_id = cursor.lastrowid
         return self.create_execution_result(cursor, rowcount_override=affected_rows, last_inserted_id=last_id)
 
     async def select_to_storage(
@@ -579,8 +584,6 @@ def data_dictionary(self) -> "AsyncDataDictionaryBase":
             Data dictionary instance for metadata queries
         """
         if self._data_dictionary is None:
-            from sqlspec.adapters.asyncmy.data_dictionary import MySQLAsyncDataDictionary
-
             self._data_dictionary = MySQLAsyncDataDictionary()
         return self._data_dictionary
 

sqlspec/adapters/asyncpg/driver.py

@@ -3,10 +3,12 @@
 import datetime
 import re
 from collections import OrderedDict
+from io import BytesIO
 from typing import TYPE_CHECKING, Any, Final, NamedTuple, cast
 
 import asyncpg
 
+from sqlspec.adapters.asyncpg.data_dictionary import PostgresAsyncDataDictionary
 from sqlspec.core import (
     DriverParameterProfile,
     ParameterStyle,
@@ -262,11 +264,8 @@ async def _handle_copy_operation(self, cursor: "AsyncpgConnection", statement: "
             statement: SQL statement with COPY operation
         """
 
-        try:
-            metadata_obj = statement.metadata
-        except AttributeError:
-            metadata_obj = {}
-        metadata: dict[str, Any] = dict(metadata_obj) if metadata_obj else {}
+        execution_args = statement.statement_config.execution_args
+        metadata: dict[str, Any] = dict(execution_args) if execution_args else {}
         sql_text = statement.sql
         sql_upper = sql_text.upper()
         copy_data = metadata.get("postgres_copy_data")
@@ -283,8 +282,6 @@ async def _handle_copy_operation(self, cursor: "AsyncpgConnection", statement: "
             else:
                 data_str = str(copy_data)
 
-            from io import BytesIO
-
             data_io = BytesIO(data_str.encode("utf-8"))
             await cursor.copy_from_query(sql_text, output=data_io)
             return
@@ -626,8 +623,6 @@ def data_dictionary(self) -> "AsyncDataDictionaryBase":
             Data dictionary instance for metadata queries
         """
         if self._data_dictionary is None:
-            from sqlspec.adapters.asyncpg.data_dictionary import PostgresAsyncDataDictionary
-
             self._data_dictionary = PostgresAsyncDataDictionary()
         return self._data_dictionary