sqlspec 0.27.0__py3-none-any.whl → 0.28.0__py3-none-any.whl

sqlspec/adapters/oracledb/litestar/store.py

@@ -50,12 +50,13 @@ class OracleAsyncStore(BaseSQLSpecStore["OracleAsyncConfig"]):
     Notes:
         Configuration is read from config.extension_config["litestar"]:
         - session_table: Session table name (default: "litestar_session")
-        - in_memory: Enable INMEMORY clause (default: False, Oracle-specific)
+        - in_memory: Enable INMEMORY PRIORITY HIGH clause (default: False, Oracle-specific)
 
-        When in_memory=True, the table is created with INMEMORY clause for
-        faster read operations. This requires Oracle Database 12.1.0.2+ with the
-        Database In-Memory option licensed. If In-Memory is not available, the
-        table creation will fail with ORA-00439 or ORA-62142.
+        When in_memory=True, the table is created with INMEMORY PRIORITY HIGH clause for
+        faster read operations. PRIORITY HIGH ensures the table is populated into the
+        In-Memory column store at database startup for immediate performance benefits.
+        This requires Oracle Database 12.1.0.2+ with the Database In-Memory option licensed.
+        If In-Memory is not available, the table creation will fail with ORA-00439 or ORA-62142.
     """
 
     __slots__ = ("_in_memory",)
@@ -73,11 +74,8 @@ class OracleAsyncStore(BaseSQLSpecStore["OracleAsyncConfig"]):
         """
         super().__init__(config)
 
-        if hasattr(config, "extension_config") and config.extension_config:
-            litestar_config = config.extension_config.get("litestar", {})
-            self._in_memory: bool = bool(litestar_config.get("in_memory", False))
-        else:
-            self._in_memory = False
+        litestar_config = config.extension_config.get("litestar", {})
+        self._in_memory = bool(litestar_config.get("in_memory", False))
 
     def _get_create_table_sql(self) -> str:
         """Get Oracle CREATE TABLE SQL with optimized schema.
@@ -91,9 +89,10 @@ class OracleAsyncStore(BaseSQLSpecStore["OracleAsyncConfig"]):
             - BLOB type for data storage (Oracle native binary type)
             - Audit columns (created_at, updated_at) help with debugging
             - Table name is internally controlled, not user input (S608 suppressed)
-            - INMEMORY clause added when in_memory=True for faster reads
+            - INMEMORY PRIORITY HIGH clause added when in_memory=True for faster reads
+            - HIGH priority ensures table population at database startup
         """
-        inmemory_clause = "INMEMORY" if self._in_memory else ""
+        inmemory_clause = "INMEMORY PRIORITY HIGH" if self._in_memory else ""
         return f"""
         BEGIN
             EXECUTE IMMEDIATE 'CREATE TABLE {self._table_name} (
@@ -419,12 +418,13 @@ class OracleSyncStore(BaseSQLSpecStore["OracleSyncConfig"]):
     Notes:
         Configuration is read from config.extension_config["litestar"]:
         - session_table: Session table name (default: "litestar_session")
-        - in_memory: Enable INMEMORY clause (default: False, Oracle-specific)
+        - in_memory: Enable INMEMORY PRIORITY HIGH clause (default: False, Oracle-specific)
 
-        When in_memory=True, the table is created with INMEMORY clause for
-        faster read operations. This requires Oracle Database 12.1.0.2+ with the
-        Database In-Memory option licensed. If In-Memory is not available, the
-        table creation will fail with ORA-00439 or ORA-62142.
+        When in_memory=True, the table is created with INMEMORY PRIORITY HIGH clause for
+        faster read operations. PRIORITY HIGH ensures the table is populated into the
+        In-Memory column store at database startup for immediate performance benefits.
+        This requires Oracle Database 12.1.0.2+ with the Database In-Memory option licensed.
+        If In-Memory is not available, the table creation will fail with ORA-00439 or ORA-62142.
     """
 
     __slots__ = ("_in_memory",)
@@ -442,11 +442,8 @@ class OracleSyncStore(BaseSQLSpecStore["OracleSyncConfig"]):
         """
         super().__init__(config)
 
-        if hasattr(config, "extension_config") and config.extension_config:
-            litestar_config = config.extension_config.get("litestar", {})
-            self._in_memory: bool = bool(litestar_config.get("in_memory", False))
-        else:
-            self._in_memory = False
+        litestar_config = config.extension_config.get("litestar", {})
+        self._in_memory = bool(litestar_config.get("in_memory", False))
 
     def _get_create_table_sql(self) -> str:
         """Get Oracle CREATE TABLE SQL with optimized schema.
@@ -460,9 +457,10 @@ class OracleSyncStore(BaseSQLSpecStore["OracleSyncConfig"]):
             - BLOB type for data storage (Oracle native binary type)
             - Audit columns (created_at, updated_at) help with debugging
             - Table name is internally controlled, not user input (S608 suppressed)
-            - INMEMORY clause added when in_memory=True for faster reads
+            - INMEMORY PRIORITY HIGH clause added when in_memory=True for faster reads
+            - HIGH priority ensures table population at database startup
         """
-        inmemory_clause = "INMEMORY" if self._in_memory else ""
+        inmemory_clause = "INMEMORY PRIORITY HIGH" if self._in_memory else ""
         return f"""
         BEGIN
             EXECUTE IMMEDIATE 'CREATE TABLE {self._table_name} (

sqlspec/adapters/psqlpy/adk/store.py

@@ -81,7 +81,7 @@ class PsqlpyADKStore(BaseAsyncADKStore["PsqlpyConfig"]):
         """
         super().__init__(config)
 
-    def _get_create_sessions_table_sql(self) -> str:
+    async def _get_create_sessions_table_sql(self) -> str:
         """Get PostgreSQL CREATE TABLE SQL for sessions.
 
         Returns:
@@ -122,7 +122,7 @@ class PsqlpyADKStore(BaseAsyncADKStore["PsqlpyConfig"]):
             WHERE state != '{{}}'::jsonb;
         """
 
-    def _get_create_events_table_sql(self) -> str:
+    async def _get_create_events_table_sql(self) -> str:
         """Get PostgreSQL CREATE TABLE SQL for events.
 
         Returns:
@@ -180,22 +180,13 @@ class PsqlpyADKStore(BaseAsyncADKStore["PsqlpyConfig"]):
         """Create both sessions and events tables if they don't exist.
 
         Notes:
-            Psqlpy doesn't support multiple statements in a single execute.
-            Splits SQL statements and executes them separately.
+            Uses driver.execute_script() which handles multiple statements.
             Creates sessions table first, then events table (FK dependency).
         """
-        async with self._config.provide_connection() as conn:  # pyright: ignore[reportAttributeAccessIssue]
-            sessions_sql = self._get_create_sessions_table_sql()
-            for statement in sessions_sql.split(";"):
-                statement = statement.strip()
-                if statement:
-                    await conn.execute(statement, [])
-
-            events_sql = self._get_create_events_table_sql()
-            for statement in events_sql.split(";"):
-                statement = statement.strip()
-                if statement:
-                    await conn.execute(statement, [])
+        async with self._config.provide_session() as driver:
+            await driver.execute_script(await self._get_create_sessions_table_sql())
+            await driver.execute_script(await self._get_create_events_table_sql())
+
         logger.debug("Created ADK tables: %s, %s", self._session_table, self._events_table)
 
     async def create_session(
@@ -313,30 +304,40 @@ class PsqlpyADKStore(BaseAsyncADKStore["PsqlpyConfig"]):
         async with self._config.provide_connection() as conn:  # pyright: ignore[reportAttributeAccessIssue]
             await conn.execute(sql, [session_id])
 
-    async def list_sessions(self, app_name: str, user_id: str) -> "list[SessionRecord]":
-        """List all sessions for a user in an app.
+    async def list_sessions(self, app_name: str, user_id: str | None = None) -> "list[SessionRecord]":
+        """List sessions for an app, optionally filtered by user.
 
         Args:
             app_name: Application name.
-            user_id: User identifier.
+            user_id: User identifier. If None, lists all sessions for the app.
 
         Returns:
             List of session records ordered by update_time DESC.
 
         Notes:
-            Uses composite index on (app_name, user_id).
+            Uses composite index on (app_name, user_id) when user_id is provided.
             Returns empty list if table doesn't exist.
         """
-        sql = f"""
-        SELECT id, app_name, user_id, state, create_time, update_time
-        FROM {self._session_table}
-        WHERE app_name = $1 AND user_id = $2
-        ORDER BY update_time DESC
-        """
+        if user_id is None:
+            sql = f"""
+            SELECT id, app_name, user_id, state, create_time, update_time
+            FROM {self._session_table}
+            WHERE app_name = $1
+            ORDER BY update_time DESC
+            """
+            params = [app_name]
+        else:
+            sql = f"""
+            SELECT id, app_name, user_id, state, create_time, update_time
+            FROM {self._session_table}
+            WHERE app_name = $1 AND user_id = $2
+            ORDER BY update_time DESC
+            """
+            params = [app_name, user_id]
 
         try:
             async with self._config.provide_connection() as conn:  # pyright: ignore[reportAttributeAccessIssue]
-                result = await conn.fetch(sql, [app_name, user_id])
+                result = await conn.fetch(sql, params)
                 rows: list[dict[str, Any]] = result.result() if result else []
 
                 return [

sqlspec/adapters/psqlpy/data_dictionary.py

@@ -116,7 +116,7 @@ class PsqlpyAsyncDataDictionary(AsyncDataDictionaryBase):
     async def get_columns(
         self, driver: AsyncDriverAdapterBase, table: str, schema: "str | None" = None
     ) -> "list[dict[str, Any]]":
-        """Get column information for a table using information_schema.
+        """Get column information for a table using pg_catalog.
 
         Args:
             driver: Psqlpy async driver instance
@@ -129,25 +129,32 @@ class PsqlpyAsyncDataDictionary(AsyncDataDictionaryBase):
                 - data_type: PostgreSQL data type
                 - is_nullable: Whether column allows NULL (YES/NO)
                 - column_default: Default value if any
+
+        Notes:
+            Uses pg_catalog instead of information_schema to avoid psqlpy's
+            inability to handle the PostgreSQL 'name' type returned by information_schema.
         """
         psqlpy_driver = cast("PsqlpyDriver", driver)
 
-        if schema:
-            sql = f"""
-                SELECT column_name, data_type, is_nullable, column_default
-                FROM information_schema.columns
-                WHERE table_name = '{table}' AND table_schema = '{schema}'
-                ORDER BY ordinal_position
-            """
-        else:
-            sql = f"""
-                SELECT column_name, data_type, is_nullable, column_default
-                FROM information_schema.columns
-                WHERE table_name = '{table}' AND table_schema = 'public'
-                ORDER BY ordinal_position
-            """
-
-        result = await psqlpy_driver.execute(sql)
+        schema_name = schema or "public"
+        sql = """
+            SELECT
+                a.attname::text AS column_name,
+                pg_catalog.format_type(a.atttypid, a.atttypmod) AS data_type,
+                CASE WHEN a.attnotnull THEN 'NO' ELSE 'YES' END AS is_nullable,
+                pg_catalog.pg_get_expr(d.adbin, d.adrelid)::text AS column_default
+            FROM pg_catalog.pg_attribute a
+            JOIN pg_catalog.pg_class c ON a.attrelid = c.oid
+            JOIN pg_catalog.pg_namespace n ON c.relnamespace = n.oid
+            LEFT JOIN pg_catalog.pg_attrdef d ON a.attrelid = d.adrelid AND a.attnum = d.adnum
+            WHERE c.relname = $1
+                AND n.nspname = $2
+                AND a.attnum > 0
+                AND NOT a.attisdropped
+            ORDER BY a.attnum
+        """
+
+        result = await psqlpy_driver.execute(sql, (table, schema_name))
         return result.data or []
 
     def list_available_features(self) -> "list[str]":

sqlspec/adapters/psqlpy/driver.py

@@ -8,9 +8,9 @@ import decimal
 import re
 from typing import TYPE_CHECKING, Any, Final
 
-import psqlpy
 import psqlpy.exceptions
 
+from sqlspec.adapters.psqlpy.data_dictionary import PsqlpyAsyncDataDictionary
 from sqlspec.adapters.psqlpy.type_converter import PostgreSQLTypeConverter
 from sqlspec.core.cache import get_cache_config
 from sqlspec.core.parameters import ParameterStyle, ParameterStyleConfig
@@ -269,17 +269,16 @@ class PsqlpyDriver(AsyncDriverAdapterBase):
 
         Returns:
             ExecutionResult with script execution metadata
+
+        Notes:
+            Uses execute() with empty parameters for each statement instead of execute_batch().
+            execute_batch() uses simple query protocol which can break subsequent queries
+            that rely on extended protocol (e.g., information_schema queries with name type).
         """
         sql, prepared_parameters = self._get_compiled_sql(statement, self.statement_config)
         statement_config = statement.statement_config
-
-        if not prepared_parameters:
-            await cursor.execute_batch(sql)
-            statements = self.split_script_statements(sql, statement_config, strip_trailing_semicolon=True)
-            return self.create_execution_result(
-                cursor, statement_count=len(statements), successful_statements=len(statements), is_script_result=True
-            )
         statements = self.split_script_statements(sql, statement_config, strip_trailing_semicolon=True)
+
         successful_count = 0
         last_result = None
 
@@ -421,7 +420,5 @@ class PsqlpyDriver(AsyncDriverAdapterBase):
             Data dictionary instance for metadata queries
         """
         if self._data_dictionary is None:
-            from sqlspec.adapters.psqlpy.data_dictionary import PsqlpyAsyncDataDictionary
-
             self._data_dictionary = PsqlpyAsyncDataDictionary()
         return self._data_dictionary

sqlspec/adapters/psycopg/adk/store.py

@@ -1,6 +1,6 @@
 """Psycopg ADK store for Google Agent Development Kit session/event storage."""
 
-from typing import TYPE_CHECKING, Any, cast
+from typing import TYPE_CHECKING, Any
 
 from psycopg import errors
 from psycopg import sql as pg_sql
@@ -12,8 +12,6 @@ from sqlspec.utils.logging import get_logger
 if TYPE_CHECKING:
     from datetime import datetime
 
-    from psycopg.abc import Query
-
     from sqlspec.adapters.psycopg.config import PsycopgAsyncConfig, PsycopgSyncConfig
 
 logger = get_logger("adapters.psycopg.adk.store")
@@ -84,7 +82,7 @@ class PsycopgAsyncADKStore(BaseAsyncADKStore["PsycopgAsyncConfig"]):
         """
         super().__init__(config)
 
-    def _get_create_sessions_table_sql(self) -> str:
+    async def _get_create_sessions_table_sql(self) -> str:
         """Get PostgreSQL CREATE TABLE SQL for sessions.
 
         Returns:
@@ -125,7 +123,7 @@ class PsycopgAsyncADKStore(BaseAsyncADKStore["PsycopgAsyncConfig"]):
             WHERE state != '{{}}'::jsonb;
         """
 
-    def _get_create_events_table_sql(self) -> str:
+    async def _get_create_events_table_sql(self) -> str:
         """Get PostgreSQL CREATE TABLE SQL for events.
 
         Returns:
@@ -181,9 +179,9 @@ class PsycopgAsyncADKStore(BaseAsyncADKStore["PsycopgAsyncConfig"]):
 
     async def create_tables(self) -> None:
         """Create both sessions and events tables if they don't exist."""
-        async with self._config.provide_connection() as conn, conn.cursor() as cur:
-            await cur.execute(cast("Query", self._get_create_sessions_table_sql()))
-            await cur.execute(cast("Query", self._get_create_events_table_sql()))
+        async with self._config.provide_session() as driver:
+            await driver.execute_script(await self._get_create_sessions_table_sql())
+            await driver.execute_script(await self._get_create_events_table_sql())
         logger.debug("Created ADK tables: %s, %s", self._session_table, self._events_table)
 
     async def create_session(
@@ -300,29 +298,39 @@ class PsycopgAsyncADKStore(BaseAsyncADKStore["PsycopgAsyncConfig"]):
         async with self._config.provide_connection() as conn, conn.cursor() as cur:
             await cur.execute(query, (session_id,))
 
-    async def list_sessions(self, app_name: str, user_id: str) -> "list[SessionRecord]":
-        """List all sessions for a user in an app.
+    async def list_sessions(self, app_name: str, user_id: str | None = None) -> "list[SessionRecord]":
+        """List sessions for an app, optionally filtered by user.
 
         Args:
             app_name: Application name.
-            user_id: User identifier.
+            user_id: User identifier. If None, lists all sessions for the app.
 
         Returns:
             List of session records ordered by update_time DESC.
 
         Notes:
-            Uses composite index on (app_name, user_id).
+            Uses composite index on (app_name, user_id) when user_id is provided.
         """
-        query = pg_sql.SQL("""
-        SELECT id, app_name, user_id, state, create_time, update_time
-        FROM {table}
-        WHERE app_name = %s AND user_id = %s
-        ORDER BY update_time DESC
-        """).format(table=pg_sql.Identifier(self._session_table))
+        if user_id is None:
+            query = pg_sql.SQL("""
+            SELECT id, app_name, user_id, state, create_time, update_time
+            FROM {table}
+            WHERE app_name = %s
+            ORDER BY update_time DESC
+            """).format(table=pg_sql.Identifier(self._session_table))
+            params: tuple[str, ...] = (app_name,)
+        else:
+            query = pg_sql.SQL("""
+            SELECT id, app_name, user_id, state, create_time, update_time
+            FROM {table}
+            WHERE app_name = %s AND user_id = %s
+            ORDER BY update_time DESC
+            """).format(table=pg_sql.Identifier(self._session_table))
+            params = (app_name, user_id)
 
         try:
             async with self._config.provide_connection() as conn, conn.cursor() as cur:
-                await cur.execute(query, (app_name, user_id))
+                await cur.execute(query, params)
                 rows = await cur.fetchall()
 
                 return [
@@ -626,9 +634,9 @@ class PsycopgSyncADKStore(BaseSyncADKStore["PsycopgSyncConfig"]):
 
     def create_tables(self) -> None:
         """Create both sessions and events tables if they don't exist."""
-        with self._config.provide_connection() as conn, conn.cursor() as cur:
-            cur.execute(cast("Query", self._get_create_sessions_table_sql()))
-            cur.execute(cast("Query", self._get_create_events_table_sql()))
+        with self._config.provide_session() as driver:
+            driver.execute_script(self._get_create_sessions_table_sql())
+            driver.execute_script(self._get_create_events_table_sql())
         logger.debug("Created ADK tables: %s, %s", self._session_table, self._events_table)
 
     def create_session(
@@ -745,29 +753,39 @@ class PsycopgSyncADKStore(BaseSyncADKStore["PsycopgSyncConfig"]):
         with self._config.provide_connection() as conn, conn.cursor() as cur:
             cur.execute(query, (session_id,))
 
-    def list_sessions(self, app_name: str, user_id: str) -> "list[SessionRecord]":
-        """List all sessions for a user in an app.
+    def list_sessions(self, app_name: str, user_id: str | None = None) -> "list[SessionRecord]":
+        """List sessions for an app, optionally filtered by user.
 
         Args:
             app_name: Application name.
-            user_id: User identifier.
+            user_id: User identifier. If None, lists all sessions for the app.
 
         Returns:
             List of session records ordered by update_time DESC.
 
         Notes:
-            Uses composite index on (app_name, user_id).
+            Uses composite index on (app_name, user_id) when user_id is provided.
         """
-        query = pg_sql.SQL("""
-        SELECT id, app_name, user_id, state, create_time, update_time
-        FROM {table}
-        WHERE app_name = %s AND user_id = %s
-        ORDER BY update_time DESC
-        """).format(table=pg_sql.Identifier(self._session_table))
+        if user_id is None:
+            query = pg_sql.SQL("""
+            SELECT id, app_name, user_id, state, create_time, update_time
+            FROM {table}
+            WHERE app_name = %s
+            ORDER BY update_time DESC
+            """).format(table=pg_sql.Identifier(self._session_table))
+            params: tuple[str, ...] = (app_name,)
+        else:
+            query = pg_sql.SQL("""
+            SELECT id, app_name, user_id, state, create_time, update_time
+            FROM {table}
+            WHERE app_name = %s AND user_id = %s
+            ORDER BY update_time DESC
+            """).format(table=pg_sql.Identifier(self._session_table))
+            params = (app_name, user_id)
 
         try:
             with self._config.provide_connection() as conn, conn.cursor() as cur:
-                cur.execute(query, (app_name, user_id))
+                cur.execute(query, params)
                 rows = cur.fetchall()
 
                 return [

sqlspec/adapters/psycopg/data_dictionary.py

@@ -122,7 +122,7 @@ class PostgresSyncDataDictionary(SyncDataDictionaryBase):
     def get_columns(
         self, driver: SyncDriverAdapterBase, table: str, schema: "str | None" = None
     ) -> "list[dict[str, Any]]":
-        """Get column information for a table using information_schema.
+        """Get column information for a table using pg_catalog.
 
         Args:
             driver: Psycopg sync driver instance
@@ -135,25 +135,32 @@ class PostgresSyncDataDictionary(SyncDataDictionaryBase):
                 - data_type: PostgreSQL data type
                 - is_nullable: Whether column allows NULL (YES/NO)
                 - column_default: Default value if any
+
+        Notes:
+            Uses pg_catalog instead of information_schema to avoid potential
+            issues with PostgreSQL 'name' type in some drivers.
         """
         psycopg_driver = cast("PsycopgSyncDriver", driver)
 
-        if schema:
-            sql = f"""
-                SELECT column_name, data_type, is_nullable, column_default
-                FROM information_schema.columns
-                WHERE table_name = '{table}' AND table_schema = '{schema}'
-                ORDER BY ordinal_position
-            """
-        else:
-            sql = f"""
-                SELECT column_name, data_type, is_nullable, column_default
-                FROM information_schema.columns
-                WHERE table_name = '{table}' AND table_schema = 'public'
-                ORDER BY ordinal_position
-            """
-
-        result = psycopg_driver.execute(sql)
+        schema_name = schema or "public"
+        sql = """
+            SELECT
+                a.attname::text AS column_name,
+                pg_catalog.format_type(a.atttypid, a.atttypmod) AS data_type,
+                CASE WHEN a.attnotnull THEN 'NO' ELSE 'YES' END AS is_nullable,
+                pg_catalog.pg_get_expr(d.adbin, d.adrelid)::text AS column_default
+            FROM pg_catalog.pg_attribute a
+            JOIN pg_catalog.pg_class c ON a.attrelid = c.oid
+            JOIN pg_catalog.pg_namespace n ON c.relnamespace = n.oid
+            LEFT JOIN pg_catalog.pg_attrdef d ON a.attrelid = d.adrelid AND a.attnum = d.adnum
+            WHERE c.relname = %s
+                AND n.nspname = %s
+                AND a.attnum > 0
+                AND NOT a.attisdropped
+            ORDER BY a.attnum
+        """
+
+        result = psycopg_driver.execute(sql, (table, schema_name))
         return result.data or []
 
     def list_available_features(self) -> "list[str]":
@@ -275,7 +282,7 @@ class PostgresAsyncDataDictionary(AsyncDataDictionaryBase):
     async def get_columns(
         self, driver: AsyncDriverAdapterBase, table: str, schema: "str | None" = None
     ) -> "list[dict[str, Any]]":
-        """Get column information for a table using information_schema.
+        """Get column information for a table using pg_catalog.
 
         Args:
             driver: Psycopg async driver instance
@@ -288,25 +295,32 @@ class PostgresAsyncDataDictionary(AsyncDataDictionaryBase):
                 - data_type: PostgreSQL data type
                 - is_nullable: Whether column allows NULL (YES/NO)
                 - column_default: Default value if any
+
+        Notes:
+            Uses pg_catalog instead of information_schema to avoid potential
+            issues with PostgreSQL 'name' type in some drivers.
         """
         psycopg_driver = cast("PsycopgAsyncDriver", driver)
 
-        if schema:
-            sql = f"""
-                SELECT column_name, data_type, is_nullable, column_default
-                FROM information_schema.columns
-                WHERE table_name = '{table}' AND table_schema = '{schema}'
-                ORDER BY ordinal_position
-            """
-        else:
-            sql = f"""
-                SELECT column_name, data_type, is_nullable, column_default
-                FROM information_schema.columns
-                WHERE table_name = '{table}' AND table_schema = 'public'
-                ORDER BY ordinal_position
-            """
-
-        result = await psycopg_driver.execute(sql)
+        schema_name = schema or "public"
+        sql = """
+            SELECT
+                a.attname::text AS column_name,
+                pg_catalog.format_type(a.atttypid, a.atttypmod) AS data_type,
+                CASE WHEN a.attnotnull THEN 'NO' ELSE 'YES' END AS is_nullable,
+                pg_catalog.pg_get_expr(d.adbin, d.adrelid)::text AS column_default
+            FROM pg_catalog.pg_attribute a
+            JOIN pg_catalog.pg_class c ON a.attrelid = c.oid
+            JOIN pg_catalog.pg_namespace n ON c.relnamespace = n.oid
+            LEFT JOIN pg_catalog.pg_attrdef d ON a.attrelid = d.adrelid AND a.attnum = d.adnum
+            WHERE c.relname = %s
+                AND n.nspname = %s
+                AND a.attnum > 0
+                AND NOT a.attisdropped
+            ORDER BY a.attnum
+        """
+
+        result = await psycopg_driver.execute(sql, (table, schema_name))
         return result.data or []
 
     def list_available_features(self) -> "list[str]":