sqlspec 0.25.0__py3-none-any.whl → 0.26.0__py3-none-any.whl

sqlspec/adapters/oracledb/driver.py

@@ -1,5 +1,6 @@
 """Oracle Driver"""
 
+import contextlib
 import logging
 from typing import TYPE_CHECKING, Any, Optional
 
@@ -7,11 +8,19 @@ import oracledb
 from oracledb import AsyncCursor, Cursor
 
 from sqlspec.adapters.oracledb._types import OracleAsyncConnection, OracleSyncConnection
+from sqlspec.adapters.oracledb.data_dictionary import OracleAsyncDataDictionary, OracleSyncDataDictionary
+from sqlspec.adapters.oracledb.type_converter import OracleTypeConverter
 from sqlspec.core.cache import get_cache_config
 from sqlspec.core.parameters import ParameterStyle, ParameterStyleConfig
 from sqlspec.core.statement import StatementConfig
-from sqlspec.driver import AsyncDriverAdapterBase, SyncDriverAdapterBase
+from sqlspec.driver import (
+    AsyncDataDictionaryBase,
+    AsyncDriverAdapterBase,
+    SyncDataDictionaryBase,
+    SyncDriverAdapterBase,
+)
 from sqlspec.exceptions import SQLParsingError, SQLSpecError
+from sqlspec.utils.serializers import to_json
 
 if TYPE_CHECKING:
     from contextlib import AbstractAsyncContextManager, AbstractContextManager
@@ -22,6 +31,11 @@ if TYPE_CHECKING:
 
 logger = logging.getLogger(__name__)
 
+# Oracle-specific constants
+LARGE_STRING_THRESHOLD = 3000  # Threshold for large string parameters to avoid ORA-01704
+
+_type_converter = OracleTypeConverter()
+
 __all__ = (
     "OracleAsyncDriver",
     "OracleAsyncExceptionHandler",
@@ -36,11 +50,11 @@ oracledb_statement_config = StatementConfig(
     parameter_config=ParameterStyleConfig(
         default_parameter_style=ParameterStyle.POSITIONAL_COLON,
         supported_parameter_styles={ParameterStyle.NAMED_COLON, ParameterStyle.POSITIONAL_COLON, ParameterStyle.QMARK},
-        default_execution_parameter_style=ParameterStyle.POSITIONAL_COLON,
+        default_execution_parameter_style=ParameterStyle.NAMED_COLON,
         supported_execution_parameter_styles={ParameterStyle.NAMED_COLON, ParameterStyle.POSITIONAL_COLON},
-        type_coercion_map={},
+        type_coercion_map={dict: to_json, list: to_json},
         has_native_list_expansion=False,
-        needs_static_script_compilation=True,
+        needs_static_script_compilation=False,
         preserve_parameter_format=True,
     ),
     enable_parsing=True,
@@ -63,8 +77,7 @@ class OracleSyncCursor:
         self.cursor = self.connection.cursor()
         return self.cursor
 
-    def __exit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
-        _ = (exc_type, exc_val, exc_tb)  # Mark as intentionally unused
+    def __exit__(self, *_: Any) -> None:
         if self.cursor is not None:
             self.cursor.close()
 
@@ -85,7 +98,10 @@ class OracleAsyncCursor:
     async def __aexit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
         _ = (exc_type, exc_val, exc_tb)  # Mark as intentionally unused
         if self.cursor is not None:
-            self.cursor.close()  # Synchronous method - do not await
+            with contextlib.suppress(Exception):
+                # Oracle async cursors have a synchronous close method
+                # but we need to ensure proper cleanup in the event loop context
+                self.cursor.close()
 
 
 class OracleSyncExceptionHandler:
@@ -189,7 +205,7 @@ class OracleSyncDriver(SyncDriverAdapterBase):
     error handling, and transaction management.
     """
 
-    __slots__ = ()
+    __slots__ = ("_data_dictionary",)
     dialect = "oracle"
 
     def __init__(
@@ -208,6 +224,7 @@ class OracleSyncDriver(SyncDriverAdapterBase):
             )
 
         super().__init__(connection=connection, statement_config=statement_config, driver_features=driver_features)
+        self._data_dictionary: Optional[SyncDataDictionaryBase] = None
 
     def with_cursor(self, connection: OracleSyncConnection) -> OracleSyncCursor:
         """Create context manager for Oracle cursor.
@@ -309,6 +326,13 @@ class OracleSyncDriver(SyncDriverAdapterBase):
             Execution result containing data for SELECT statements or row count for others
         """
         sql, prepared_parameters = self._get_compiled_sql(statement, self.statement_config)
+
+        # Oracle-specific: Use setinputsizes for large string parameters to avoid ORA-01704
+        if prepared_parameters and isinstance(prepared_parameters, dict):
+            for param_name, param_value in prepared_parameters.items():
+                if isinstance(param_value, str) and len(param_value) > LARGE_STRING_THRESHOLD:
+                    cursor.setinputsizes(**{param_name: len(param_value)})
+
         cursor.execute(sql, prepared_parameters or {})
 
         # SELECT result processing for Oracle
@@ -359,6 +383,17 @@ class OracleSyncDriver(SyncDriverAdapterBase):
             msg = f"Failed to commit Oracle transaction: {e}"
             raise SQLSpecError(msg) from e
 
+    @property
+    def data_dictionary(self) -> "SyncDataDictionaryBase":
+        """Get the data dictionary for this driver.
+
+        Returns:
+            Data dictionary instance for metadata queries
+        """
+        if self._data_dictionary is None:
+            self._data_dictionary = OracleSyncDataDictionary()
+        return self._data_dictionary
+
 
 class OracleAsyncDriver(AsyncDriverAdapterBase):
     """Asynchronous Oracle Database driver.
@@ -367,7 +402,7 @@ class OracleAsyncDriver(AsyncDriverAdapterBase):
     error handling, and transaction management for async operations.
     """
 
-    __slots__ = ()
+    __slots__ = ("_data_dictionary",)
     dialect = "oracle"
 
     def __init__(
@@ -386,6 +421,7 @@ class OracleAsyncDriver(AsyncDriverAdapterBase):
             )
 
         super().__init__(connection=connection, statement_config=statement_config, driver_features=driver_features)
+        self._data_dictionary: Optional[AsyncDataDictionaryBase] = None
 
     def with_cursor(self, connection: OracleAsyncConnection) -> OracleAsyncCursor:
         """Create context manager for Oracle cursor.
@@ -482,6 +518,13 @@ class OracleAsyncDriver(AsyncDriverAdapterBase):
             Execution result containing data for SELECT statements or row count for others
         """
         sql, prepared_parameters = self._get_compiled_sql(statement, self.statement_config)
+
+        # Oracle-specific: Use setinputsizes for large string parameters to avoid ORA-01704
+        if prepared_parameters and isinstance(prepared_parameters, dict):
+            for param_name, param_value in prepared_parameters.items():
+                if isinstance(param_value, str) and len(param_value) > LARGE_STRING_THRESHOLD:
+                    cursor.setinputsizes(**{param_name: len(param_value)})
+
         await cursor.execute(sql, prepared_parameters or {})
 
         # SELECT result processing for Oracle
@@ -531,3 +574,14 @@ class OracleAsyncDriver(AsyncDriverAdapterBase):
         except oracledb.Error as e:
             msg = f"Failed to commit Oracle transaction: {e}"
             raise SQLSpecError(msg) from e
+
+    @property
+    def data_dictionary(self) -> "AsyncDataDictionaryBase":
+        """Get the data dictionary for this driver.
+
+        Returns:
+            Data dictionary instance for metadata queries
+        """
+        if self._data_dictionary is None:
+            self._data_dictionary = OracleAsyncDataDictionary()
+        return self._data_dictionary

sqlspec/adapters/oracledb/migrations.py

@@ -8,7 +8,7 @@ import getpass
 from typing import TYPE_CHECKING, Any, Optional, cast
 
 from sqlspec._sql import sql
-from sqlspec.builder._ddl import CreateTable
+from sqlspec.builder import CreateTable
 from sqlspec.migrations.base import BaseMigrationTracker
 from sqlspec.utils.logging import get_logger
 
@@ -57,22 +57,33 @@ class OracleSyncMigrationTracker(OracleMigrationTrackerMixin, BaseMigrationTrack
     def ensure_tracking_table(self, driver: "SyncDriverAdapterBase") -> None:
         """Create the migration tracking table if it doesn't exist.
 
-        Oracle doesn't support IF NOT EXISTS, so we check for table existence first.
+        Uses a PL/SQL block to make the operation atomic and prevent race conditions.
 
         Args:
             driver: The database driver to use.
         """
-
-        check_sql = (
-            sql.select(sql.count().as_("table_count"))
-            .from_("user_tables")
-            .where(sql.column("table_name") == self.version_table.upper())
-        )
-        result = driver.execute(check_sql)
-
-        if result.data[0]["TABLE_COUNT"] == 0:
-            driver.execute(self._get_create_table_sql())
-            self._safe_commit(driver)
+        create_script = f"""
+        BEGIN
+            EXECUTE IMMEDIATE '
+            CREATE TABLE {self.version_table} (
+                version_num VARCHAR2(32) PRIMARY KEY,
+                description VARCHAR2(2000),
+                applied_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                execution_time_ms INTEGER,
+                checksum VARCHAR2(64),
+                applied_by VARCHAR2(255)
+            )';
+        EXCEPTION
+            WHEN OTHERS THEN
+                IF SQLCODE = -955 THEN
+                    NULL; -- Table already exists
+                ELSE
+                    RAISE;
+                END IF;
+        END;
+        """
+        driver.execute_script(create_script)
+        driver.commit()
 
     def get_current_version(self, driver: "SyncDriverAdapterBase") -> "Optional[str]":
         """Get the latest applied migration version.
@@ -120,7 +131,7 @@ class OracleSyncMigrationTracker(OracleMigrationTrackerMixin, BaseMigrationTrack
 
         record_sql = self._get_record_migration_sql(version, description, execution_time_ms, checksum, applied_by)
         driver.execute(record_sql)
-        self._safe_commit(driver)
+        driver.commit()
 
     def remove_migration(self, driver: "SyncDriverAdapterBase", version: str) -> None:
         """Remove a migration record.
@@ -131,26 +142,7 @@ class OracleSyncMigrationTracker(OracleMigrationTrackerMixin, BaseMigrationTrack
         """
         remove_sql = self._get_remove_migration_sql(version)
         driver.execute(remove_sql)
-        self._safe_commit(driver)
-
-    def _safe_commit(self, driver: "SyncDriverAdapterBase") -> None:
-        """Safely commit a transaction only if autocommit is disabled.
-
-        Args:
-            driver: The database driver to use.
-        """
-        try:
-            # Check driver features first (preferred approach)
-            if driver.driver_features.get("autocommit", False):
-                return
-
-            # Fallback to connection-level autocommit check
-            if driver.connection and driver.connection.autocommit:
-                return
-
-            driver.commit()
-        except Exception:
-            logger.debug("Failed to commit transaction, likely due to autocommit being enabled")
+        driver.commit()
 
 
 class OracleAsyncMigrationTracker(OracleMigrationTrackerMixin, BaseMigrationTracker["AsyncDriverAdapterBase"]):
@@ -161,22 +153,33 @@ class OracleAsyncMigrationTracker(OracleMigrationTrackerMixin, BaseMigrationTrac
     async def ensure_tracking_table(self, driver: "AsyncDriverAdapterBase") -> None:
         """Create the migration tracking table if it doesn't exist.
 
-        Oracle doesn't support IF NOT EXISTS, so we check for table existence first.
+        Uses a PL/SQL block to make the operation atomic and prevent race conditions.
 
         Args:
             driver: The database driver to use.
         """
-
-        check_sql = (
-            sql.select(sql.count().as_("table_count"))
-            .from_("user_tables")
-            .where(sql.column("table_name") == self.version_table.upper())
-        )
-        result = await driver.execute(check_sql)
-
-        if result.data[0]["TABLE_COUNT"] == 0:
-            await driver.execute(self._get_create_table_sql())
-            await self._safe_commit_async(driver)
+        create_script = f"""
+        BEGIN
+            EXECUTE IMMEDIATE '
+            CREATE TABLE {self.version_table} (
+                version_num VARCHAR2(32) PRIMARY KEY,
+                description VARCHAR2(2000),
+                applied_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                execution_time_ms INTEGER,
+                checksum VARCHAR2(64),
+                applied_by VARCHAR2(255)
+            )';
+        EXCEPTION
+            WHEN OTHERS THEN
+                IF SQLCODE = -955 THEN
+                    NULL; -- Table already exists
+                ELSE
+                    RAISE;
+                END IF;
+        END;
+        """
+        await driver.execute_script(create_script)
+        await driver.commit()
 
     async def get_current_version(self, driver: "AsyncDriverAdapterBase") -> "Optional[str]":
         """Get the latest applied migration version.
@@ -224,7 +227,7 @@ class OracleAsyncMigrationTracker(OracleMigrationTrackerMixin, BaseMigrationTrac
 
         record_sql = self._get_record_migration_sql(version, description, execution_time_ms, checksum, applied_by)
         await driver.execute(record_sql)
-        await self._safe_commit_async(driver)
+        await driver.commit()
 
     async def remove_migration(self, driver: "AsyncDriverAdapterBase", version: str) -> None:
         """Remove a migration record.
@@ -235,23 +238,4 @@ class OracleAsyncMigrationTracker(OracleMigrationTrackerMixin, BaseMigrationTrac
         """
         remove_sql = self._get_remove_migration_sql(version)
         await driver.execute(remove_sql)
-        await self._safe_commit_async(driver)
-
-    async def _safe_commit_async(self, driver: "AsyncDriverAdapterBase") -> None:
-        """Safely commit a transaction only if autocommit is disabled.
-
-        Args:
-            driver: The database driver to use.
-        """
-        try:
-            # Check driver features first (preferred approach)
-            if driver.driver_features.get("autocommit", False):
-                return
-
-            # Fallback to connection-level autocommit check
-            if driver.connection and driver.connection.autocommit:
-                return
-
-            await driver.commit()
-        except Exception:
-            logger.debug("Failed to commit transaction, likely due to autocommit being enabled")
+        await driver.commit()

sqlspec/adapters/oracledb/type_converter.py

@@ -0,0 +1,132 @@
+"""Oracle-specific type conversion with LOB optimization.
+
+Provides specialized type handling for Oracle databases, including
+efficient LOB (Large Object) processing and JSON storage detection.
+"""
+
+import re
+from datetime import datetime
+from typing import Any, Final
+
+from sqlspec.core.type_conversion import BaseTypeConverter
+from sqlspec.utils.sync_tools import ensure_async_
+
+# Oracle-specific JSON storage detection
+ORACLE_JSON_STORAGE_REGEX: Final[re.Pattern[str]] = re.compile(
+    r"^(?:"
+    r"(?P<json_type>JSON)|"
+    r"(?P<blob_oson>BLOB.*OSON)|"
+    r"(?P<blob_json>BLOB.*JSON)|"
+    r"(?P<clob_json>CLOB.*JSON)"
+    r")$",
+    re.IGNORECASE,
+)
+
+
+class OracleTypeConverter(BaseTypeConverter):
+    """Oracle-specific type conversion with LOB optimization.
+
+    Extends the base TypeDetector with Oracle-specific functionality
+    including streaming LOB support and JSON storage type detection.
+    """
+
+    __slots__ = ()
+
+    async def process_lob(self, value: Any) -> Any:
+        """Process Oracle LOB objects efficiently.
+
+        Args:
+            value: Potential LOB object or regular value.
+
+        Returns:
+            LOB content if value is a LOB, original value otherwise.
+        """
+        if not hasattr(value, "read"):
+            return value
+
+        # Use ensure_async_ for unified sync/async handling
+        read_func = ensure_async_(value.read)
+        return await read_func()
+
+    def detect_json_storage_type(self, column_info: dict[str, Any]) -> bool:
+        """Detect if column stores JSON data.
+
+        Args:
+            column_info: Database column metadata.
+
+        Returns:
+            True if column is configured for JSON storage.
+        """
+        type_name = column_info.get("type_name", "").upper()
+        return bool(ORACLE_JSON_STORAGE_REGEX.match(type_name))
+
+    def format_datetime_for_oracle(self, dt: datetime) -> str:
+        """Format datetime for Oracle TO_DATE function.
+
+        Args:
+            dt: datetime object to format.
+
+        Returns:
+            Oracle TO_DATE SQL expression.
+        """
+        return f"TO_DATE('{dt.strftime('%Y-%m-%d %H:%M:%S')}', 'YYYY-MM-DD HH24:MI:SS')"
+
+    def handle_large_lob(self, lob_obj: Any, chunk_size: int = 1024 * 1024) -> bytes:
+        """Handle large LOB objects with streaming.
+
+        Args:
+            lob_obj: Oracle LOB object.
+            chunk_size: Size of chunks to read at a time.
+
+        Returns:
+            Complete LOB content as bytes.
+        """
+        if not hasattr(lob_obj, "read"):
+            return lob_obj if isinstance(lob_obj, bytes) else str(lob_obj).encode("utf-8")
+
+        chunks = []
+        while True:
+            chunk = lob_obj.read(chunk_size)
+            if not chunk:
+                break
+            chunks.append(chunk)
+
+        if not chunks:
+            return b""
+
+        return b"".join(chunks) if isinstance(chunks[0], bytes) else "".join(chunks).encode("utf-8")
+
+    def convert_oracle_value(self, value: Any, column_info: dict[str, Any]) -> Any:
+        """Convert Oracle-specific value with column context.
+
+        Args:
+            value: Value to convert.
+            column_info: Column metadata for context.
+
+        Returns:
+            Converted value appropriate for the column type.
+        """
+        # Handle LOB objects
+        if hasattr(value, "read"):
+            if self.detect_json_storage_type(column_info):
+                # For JSON storage types, decode the LOB content
+                content = self.handle_large_lob(value)
+                content_str = content.decode("utf-8") if isinstance(content, bytes) else content
+                # Try to parse as JSON
+                detected_type = self.detect_type(content_str)
+                if detected_type == "json":
+                    return self.convert_value(content_str, detected_type)
+                return content_str
+            # For other LOB types, return raw content
+            return self.handle_large_lob(value)
+
+        # Use base type detection for non-LOB values
+        if isinstance(value, str):
+            detected_type = self.detect_type(value)
+            if detected_type:
+                return self.convert_value(value, detected_type)
+
+        return value
+
+
+__all__ = ("ORACLE_JSON_STORAGE_REGEX", "OracleTypeConverter")

sqlspec/adapters/psqlpy/config.py

@@ -90,6 +90,7 @@ class PsqlpyConfig(AsyncDatabaseConfig[PsqlpyConnection, ConnectionPool, PsqlpyD
         migration_config: Optional[dict[str, Any]] = None,
         statement_config: Optional[StatementConfig] = None,
         driver_features: Optional[dict[str, Any]] = None,
+        bind_key: Optional[str] = None,
     ) -> None:
         """Initialize Psqlpy configuration.
 
@@ -99,6 +100,7 @@ class PsqlpyConfig(AsyncDatabaseConfig[PsqlpyConnection, ConnectionPool, PsqlpyD
             migration_config: Migration configuration
             statement_config: SQL statement configuration
             driver_features: Driver feature configuration
+            bind_key: Optional unique identifier for this configuration
         """
         processed_pool_config: dict[str, Any] = dict(pool_config) if pool_config else {}
         if "extra" in processed_pool_config:
@@ -110,6 +112,7 @@ class PsqlpyConfig(AsyncDatabaseConfig[PsqlpyConnection, ConnectionPool, PsqlpyD
             migration_config=migration_config,
             statement_config=statement_config or psqlpy_statement_config,
             driver_features=driver_features or {},
+            bind_key=bind_key,
         )
 
     def _get_pool_config_dict(self) -> dict[str, Any]:

sqlspec/adapters/psqlpy/data_dictionary.py

@@ -0,0 +1,133 @@
+"""PostgreSQL-specific data dictionary for metadata queries via psqlpy."""
+
+import re
+from typing import TYPE_CHECKING, Callable, Optional, cast
+
+from sqlspec.driver import AsyncDataDictionaryBase, AsyncDriverAdapterBase, VersionInfo
+from sqlspec.utils.logging import get_logger
+
+if TYPE_CHECKING:
+    from sqlspec.adapters.psqlpy.driver import PsqlpyDriver
+
+logger = get_logger("adapters.psqlpy.data_dictionary")
+
+# Compiled regex patterns
+POSTGRES_VERSION_PATTERN = re.compile(r"PostgreSQL (\d+)\.(\d+)(?:\.(\d+))?")
+
+__all__ = ("PsqlpyAsyncDataDictionary",)
+
+
+class PsqlpyAsyncDataDictionary(AsyncDataDictionaryBase):
+    """PostgreSQL-specific async data dictionary via psqlpy."""
+
+    async def get_version(self, driver: AsyncDriverAdapterBase) -> "Optional[VersionInfo]":
+        """Get PostgreSQL database version information.
+
+        Args:
+            driver: Async database driver instance
+
+        Returns:
+            PostgreSQL version information or None if detection fails
+        """
+        version_str = await cast("PsqlpyDriver", driver).select_value("SELECT version()")
+        if not version_str:
+            logger.warning("No PostgreSQL version information found")
+            return None
+
+        # Parse version like "PostgreSQL 15.3 on x86_64-pc-linux-gnu..."
+        version_match = POSTGRES_VERSION_PATTERN.search(str(version_str))
+        if not version_match:
+            logger.warning("Could not parse PostgreSQL version: %s", version_str)
+            return None
+
+        major = int(version_match.group(1))
+        minor = int(version_match.group(2))
+        patch = int(version_match.group(3)) if version_match.group(3) else 0
+
+        version_info = VersionInfo(major, minor, patch)
+        logger.debug("Detected PostgreSQL version: %s", version_info)
+        return version_info
+
+    async def get_feature_flag(self, driver: AsyncDriverAdapterBase, feature: str) -> bool:
+        """Check if PostgreSQL database supports a specific feature.
+
+        Args:
+            driver: Async database driver instance
+            feature: Feature name to check
+
+        Returns:
+            True if feature is supported, False otherwise
+        """
+        version_info = await self.get_version(driver)
+        if not version_info:
+            return False
+
+        feature_checks: dict[str, Callable[[VersionInfo], bool]] = {
+            "supports_json": lambda v: v >= VersionInfo(9, 2, 0),
+            "supports_jsonb": lambda v: v >= VersionInfo(9, 4, 0),
+            "supports_uuid": lambda _: True,  # UUID extension widely available
+            "supports_arrays": lambda _: True,  # PostgreSQL has excellent array support
+            "supports_returning": lambda v: v >= VersionInfo(8, 2, 0),
+            "supports_upsert": lambda v: v >= VersionInfo(9, 5, 0),  # ON CONFLICT
+            "supports_window_functions": lambda v: v >= VersionInfo(8, 4, 0),
+            "supports_cte": lambda v: v >= VersionInfo(8, 4, 0),
+            "supports_transactions": lambda _: True,
+            "supports_prepared_statements": lambda _: True,
+            "supports_schemas": lambda _: True,
+            "supports_partitioning": lambda v: v >= VersionInfo(10, 0, 0),
+        }
+
+        if feature in feature_checks:
+            return bool(feature_checks[feature](version_info))
+
+        return False
+
+    async def get_optimal_type(self, driver: AsyncDriverAdapterBase, type_category: str) -> str:
+        """Get optimal PostgreSQL type for a category.
+
+        Args:
+            driver: Async database driver instance
+            type_category: Type category
+
+        Returns:
+            PostgreSQL-specific type name
+        """
+        version_info = await self.get_version(driver)
+
+        if type_category == "json":
+            if version_info and version_info >= VersionInfo(9, 4, 0):
+                return "JSONB"  # Prefer JSONB over JSON
+            if version_info and version_info >= VersionInfo(9, 2, 0):
+                return "JSON"
+            return "TEXT"
+
+        type_map = {
+            "uuid": "UUID",
+            "boolean": "BOOLEAN",
+            "timestamp": "TIMESTAMP WITH TIME ZONE",
+            "text": "TEXT",
+            "blob": "BYTEA",
+            "array": "ARRAY",
+        }
+        return type_map.get(type_category, "TEXT")
+
+    def list_available_features(self) -> "list[str]":
+        """List available PostgreSQL feature flags.
+
+        Returns:
+            List of supported feature names
+        """
+        return [
+            "supports_json",
+            "supports_jsonb",
+            "supports_uuid",
+            "supports_arrays",
+            "supports_returning",
+            "supports_upsert",
+            "supports_window_functions",
+            "supports_cte",
+            "supports_transactions",
+            "supports_prepared_statements",
+            "supports_schemas",
+            "supports_partitioning",
+        ]