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

sqlspec/adapters/psqlpy/driver.py

@@ -4,15 +4,14 @@ Provides parameter style conversion, type coercion, error handling,
 and transaction management.
 """
 
-import datetime
 import decimal
 import re
-import uuid
 from typing import TYPE_CHECKING, Any, Final, Optional
 
 import psqlpy
 import psqlpy.exceptions
 
+from sqlspec.adapters.psqlpy.type_converter import PostgreSQLTypeConverter
 from sqlspec.core.cache import get_cache_config
 from sqlspec.core.parameters import ParameterStyle, ParameterStyleConfig
 from sqlspec.core.statement import SQL, StatementConfig
@@ -26,11 +25,14 @@ if TYPE_CHECKING:
     from sqlspec.adapters.psqlpy._types import PsqlpyConnection
     from sqlspec.core.result import SQLResult
     from sqlspec.driver import ExecutionResult
+    from sqlspec.driver._async import AsyncDataDictionaryBase
 
 __all__ = ("PsqlpyCursor", "PsqlpyDriver", "PsqlpyExceptionHandler", "psqlpy_statement_config")
 
 logger = get_logger("adapters.psqlpy")
 
+_type_converter = PostgreSQLTypeConverter()
+
 psqlpy_statement_config = StatementConfig(
     dialect="postgres",
     parameter_config=ParameterStyleConfig(
@@ -38,7 +40,7 @@ psqlpy_statement_config = StatementConfig(
         supported_parameter_styles={ParameterStyle.NUMERIC, ParameterStyle.NAMED_DOLLAR, ParameterStyle.QMARK},
         default_execution_parameter_style=ParameterStyle.NUMERIC,
         supported_execution_parameter_styles={ParameterStyle.NUMERIC},
-        type_coercion_map={tuple: list, decimal.Decimal: float},
+        type_coercion_map={tuple: list, decimal.Decimal: float, str: _type_converter.convert_if_detected},
         has_native_list_expansion=False,
         needs_static_script_compilation=False,
         allow_mixed_parameter_styles=False,
@@ -52,173 +54,6 @@ psqlpy_statement_config = StatementConfig(
 
 PSQLPY_STATUS_REGEX: Final[re.Pattern[str]] = re.compile(r"^([A-Z]+)(?:\s+(\d+))?\s+(\d+)$", re.IGNORECASE)
 
-SPECIAL_TYPE_REGEX: Final[re.Pattern[str]] = re.compile(
-    r"^(?:"
-    r"(?P<uuid>[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})|"
-    r"(?P<ipv4>(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)(?:/(?:3[0-2]|[12]?[0-9]))?)|"
-    r"(?P<ipv6>(?:(?:[0-9a-f]{1,4}:){7}[0-9a-f]{1,4}|(?:[0-9a-f]{1,4}:){1,7}:|:(?::[0-9a-f]{1,4}){1,7}|(?:[0-9a-f]{1,4}:){1,6}:[0-9a-f]{1,4}|::(?:ffff:)?(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?))(?:/(?:12[0-8]|1[01][0-9]|[1-9]?[0-9]))?)|"
-    r"(?P<mac>(?:[0-9a-f]{2}[:-]){5}[0-9a-f]{2}|[0-9a-f]{12})|"
-    r"(?P<iso_datetime>\d{4}-\d{2}-\d{2}[T\s]\d{2}:\d{2}:\d{2}(?:\.\d{1,6})?(?:Z|[+-]\d{2}:?\d{2})?)|"
-    r"(?P<iso_date>\d{4}-\d{2}-\d{2})|"
-    r"(?P<iso_time>\d{2}:\d{2}:\d{2}(?:\.\d{1,6})?(?:Z|[+-]\d{2}:?\d{2})?)|"
-    r"(?P<interval>(?:(?:\d+\s+(?:year|month|day|hour|minute|second)s?\s*)+)|(?:P(?:\d+Y)?(?:\d+M)?(?:\d+D)?(?:T(?:\d+H)?(?:\d+M)?(?:\d+(?:\.\d+)?S)?)?))|"
-    r"(?P<json>\{[\s\S]*\}|\[[\s\S]*\])|"
-    r"(?P<pg_array>\{(?:[^{}]+|\{[^{}]*\})*\})"
-    r")$",
-    re.IGNORECASE,
-)
-
-
-def _detect_postgresql_type(value: str) -> Optional[str]:
-    """Detect PostgreSQL data type from string value.
-
-    Args:
-        value: String value to analyze
-
-    Returns:
-        Type name if detected, None otherwise.
-    """
-    match = SPECIAL_TYPE_REGEX.match(value)
-    if not match:
-        return None
-
-    for group_name in [
-        "uuid",
-        "ipv4",
-        "ipv6",
-        "mac",
-        "iso_datetime",
-        "iso_date",
-        "iso_time",
-        "interval",
-        "json",
-        "pg_array",
-    ]:
-        if match.group(group_name):
-            return group_name
-
-    return None
-
-
-def _convert_uuid(value: str) -> Any:
-    """Convert UUID string to UUID object.
-
-    Args:
-        value: UUID string to convert
-
-    Returns:
-        UUID object or original value if conversion fails
-    """
-    try:
-        clean_uuid = value.replace("-", "").lower()
-        uuid_length = 32
-        if len(clean_uuid) == uuid_length:
-            formatted = f"{clean_uuid[:8]}-{clean_uuid[8:12]}-{clean_uuid[12:16]}-{clean_uuid[16:20]}-{clean_uuid[20:]}"
-            return uuid.UUID(formatted)
-        return uuid.UUID(value)
-    except (ValueError, AttributeError):
-        return value
-
-
-def _convert_iso_datetime(value: str) -> Any:
-    """Convert ISO datetime string to datetime object.
-
-    Args:
-        value: ISO datetime string to convert
-
-    Returns:
-        datetime object or original value if conversion fails
-    """
-    try:
-        normalized = value.replace("Z", "+00:00")
-        return datetime.datetime.fromisoformat(normalized)
-    except ValueError:
-        return value
-
-
-def _convert_iso_date(value: str) -> Any:
-    """Convert ISO date string to date object.
-
-    Args:
-        value: ISO date string to convert
-
-    Returns:
-        date object or original value if conversion fails
-    """
-    try:
-        return datetime.date.fromisoformat(value)
-    except ValueError:
-        return value
-
-
-def _validate_json(value: str) -> str:
-    """Validate JSON string format.
-
-    Args:
-        value: JSON string to validate
-
-    Returns:
-        Original string value
-    """
-    from sqlspec.utils.serializers import from_json
-
-    try:
-        from_json(value)
-    except (ValueError, TypeError):
-        return value
-    return value
-
-
-def _passthrough(value: str) -> str:
-    """Pass value through unchanged.
-
-    Args:
-        value: String value to pass through
-
-    Returns:
-        Original value unchanged
-    """
-    return value
-
-
-_PSQLPY_TYPE_CONVERTERS: dict[str, Any] = {
-    "uuid": _convert_uuid,
-    "iso_datetime": _convert_iso_datetime,
-    "iso_date": _convert_iso_date,
-    "iso_time": _passthrough,
-    "json": _validate_json,
-    "pg_array": _passthrough,
-    "ipv4": _passthrough,
-    "ipv6": _passthrough,
-    "mac": _passthrough,
-    "interval": _passthrough,
-}
-
-
-def _convert_psqlpy_parameters(value: Any) -> Any:
-    """Convert parameters for psqlpy compatibility.
-
-    Args:
-        value: Parameter value to convert
-
-    Returns:
-        Converted value suitable for psqlpy execution
-    """
-    if isinstance(value, str):
-        detected_type = _detect_postgresql_type(value)
-
-        if detected_type:
-            converter = _PSQLPY_TYPE_CONVERTERS.get(detected_type)
-            if converter:
-                return converter(value)
-
-        return value
-
-    if isinstance(value, (dict, list, tuple, uuid.UUID, datetime.datetime, datetime.date)):
-        return value
-
-    return value
-
 
 class PsqlpyCursor:
     """Context manager for psqlpy cursor management."""
@@ -238,7 +73,7 @@ class PsqlpyCursor:
         self._in_use = True
         return self.connection
 
-    async def __aexit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
+    async def __aexit__(self, *_: Any) -> None:
         """Exit cursor context.
 
         Args:
@@ -246,7 +81,6 @@ class PsqlpyCursor:
             exc_val: Exception value
             exc_tb: Exception traceback
         """
-        _ = (exc_type, exc_val, exc_tb)
         self._in_use = False
 
     def is_in_use(self) -> bool:
@@ -303,7 +137,7 @@ class PsqlpyDriver(AsyncDriverAdapterBase):
     and transaction management.
     """
 
-    __slots__ = ()
+    __slots__ = ("_data_dictionary",)
     dialect = "postgres"
 
     def __init__(
@@ -322,6 +156,7 @@ class PsqlpyDriver(AsyncDriverAdapterBase):
             )
 
         super().__init__(connection=connection, statement_config=statement_config, driver_features=driver_features)
+        self._data_dictionary: Optional[AsyncDataDictionaryBase] = None
 
     def with_cursor(self, connection: "PsqlpyConnection") -> "PsqlpyCursor":
         """Create context manager for psqlpy cursor.
@@ -404,10 +239,9 @@ class PsqlpyDriver(AsyncDriverAdapterBase):
         formatted_parameters = []
         for param_set in prepared_parameters:
             if isinstance(param_set, (list, tuple)):
-                converted_params = [_convert_psqlpy_parameters(param) for param in param_set]
-                formatted_parameters.append(converted_params)
+                formatted_parameters.append(list(param_set))
             else:
-                formatted_parameters.append([_convert_psqlpy_parameters(param_set)])
+                formatted_parameters.append([param_set])
 
         await cursor.execute_many(sql, formatted_parameters)
 
@@ -427,9 +261,6 @@ class PsqlpyDriver(AsyncDriverAdapterBase):
         """
         sql, prepared_parameters = self._get_compiled_sql(statement, self.statement_config)
 
-        if prepared_parameters:
-            prepared_parameters = [_convert_psqlpy_parameters(param) for param in prepared_parameters]
-
         if statement.returns_rows():
             query_result = await cursor.fetch(sql, prepared_parameters or [])
             dict_rows: list[dict[str, Any]] = query_result.result() if query_result else []
@@ -511,3 +342,16 @@ class PsqlpyDriver(AsyncDriverAdapterBase):
         except psqlpy.exceptions.DatabaseError as e:
             msg = f"Failed to commit psqlpy 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:
+            from sqlspec.adapters.psqlpy.data_dictionary import PsqlpyAsyncDataDictionary
+
+            self._data_dictionary = PsqlpyAsyncDataDictionary()
+        return self._data_dictionary

sqlspec/adapters/psqlpy/type_converter.py

@@ -0,0 +1,73 @@
+"""PostgreSQL-specific type conversion for psqlpy adapter.
+
+Provides specialized type handling for PostgreSQL databases, including
+PostgreSQL-specific types like intervals and arrays while preserving
+backward compatibility.
+"""
+
+import re
+from typing import Any, Final, Optional
+
+from sqlspec.core.type_conversion import BaseTypeConverter
+
+# PostgreSQL-specific regex patterns for types not covered by base BaseTypeConverter
+PG_SPECIFIC_REGEX: Final[re.Pattern[str]] = re.compile(
+    r"^(?:"
+    r"(?P<interval>(?:(?:\d+\s+(?:year|month|day|hour|minute|second)s?\s*)+)|(?:P(?:\d+Y)?(?:\d+M)?(?:\d+D)?(?:T(?:\d+H)?(?:\d+M)?(?:\d+(?:\.\d+)?S)?)?))|"
+    r"(?P<pg_array>\{(?:[^{}]+|\{[^{}]*\})*\})"
+    r")$",
+    re.IGNORECASE,
+)
+
+
+class PostgreSQLTypeConverter(BaseTypeConverter):
+    """PostgreSQL-specific type converter with interval and array support.
+
+    Extends the base BaseTypeConverter with PostgreSQL-specific functionality
+    while maintaining backward compatibility for interval and array types.
+    """
+
+    __slots__ = ()
+
+    def detect_type(self, value: str) -> Optional[str]:
+        """Detect types including PostgreSQL-specific types.
+
+        Args:
+            value: String value to analyze.
+
+        Returns:
+            Type name if detected, None otherwise.
+        """
+        # First try generic types (UUID, JSON, datetime, etc.)
+        detected_type = super().detect_type(value)
+        if detected_type:
+            return detected_type
+
+        # Then check PostgreSQL-specific types
+        match = PG_SPECIFIC_REGEX.match(value)
+        if match:
+            for group_name in ["interval", "pg_array"]:
+                if match.group(group_name):
+                    return group_name
+
+        return None
+
+    def convert_value(self, value: str, detected_type: str) -> Any:
+        """Convert value with PostgreSQL-specific handling.
+
+        Args:
+            value: String value to convert.
+            detected_type: Detected type name.
+
+        Returns:
+            Converted value or original string for PostgreSQL-specific types.
+        """
+        # For PostgreSQL-specific types, preserve as strings for backward compatibility
+        if detected_type in ("interval", "pg_array"):
+            return value  # Pass through as strings - psqlpy will handle casting
+
+        # Use base converter for standard types
+        return super().convert_value(value, detected_type)
+
+
+__all__ = ("PG_SPECIFIC_REGEX", "PostgreSQLTypeConverter")

sqlspec/adapters/psycopg/config.py

@@ -88,6 +88,7 @@ class PsycopgSyncConfig(SyncDatabaseConfig[PsycopgSyncConnection, ConnectionPool
         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 Psycopg synchronous configuration.
 
@@ -97,6 +98,7 @@ class PsycopgSyncConfig(SyncDatabaseConfig[PsycopgSyncConnection, ConnectionPool
             migration_config: Migration configuration
             statement_config: Default SQL statement configuration
             driver_features: Optional 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:
@@ -109,6 +111,7 @@ class PsycopgSyncConfig(SyncDatabaseConfig[PsycopgSyncConnection, ConnectionPool
             migration_config=migration_config,
             statement_config=statement_config or psycopg_statement_config,
             driver_features=driver_features or {},
+            bind_key=bind_key,
         )
 
     def _create_pool(self) -> "ConnectionPool":
@@ -173,8 +176,7 @@ class PsycopgSyncConfig(SyncDatabaseConfig[PsycopgSyncConnection, ConnectionPool
         logger.info("Closing Psycopg connection pool", extra={"adapter": "psycopg"})
 
         try:
-            if hasattr(self.pool_instance, "_closed"):
-                self.pool_instance._closed = True
+            self.pool_instance._closed = True  # pyright: ignore[reportPrivateUsage]
 
             self.pool_instance.close()
             logger.info("Psycopg connection pool closed successfully", extra={"adapter": "psycopg"})
@@ -271,6 +273,7 @@ class PsycopgAsyncConfig(AsyncDatabaseConfig[PsycopgAsyncConnection, AsyncConnec
         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 Psycopg asynchronous configuration.
 
@@ -280,6 +283,7 @@ class PsycopgAsyncConfig(AsyncDatabaseConfig[PsycopgAsyncConnection, AsyncConnec
             migration_config: Migration configuration
             statement_config: Default SQL statement configuration
             driver_features: Optional 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:
@@ -292,6 +296,7 @@ class PsycopgAsyncConfig(AsyncDatabaseConfig[PsycopgAsyncConnection, AsyncConnec
             migration_config=migration_config,
             statement_config=statement_config or psycopg_statement_config,
             driver_features=driver_features or {},
+            bind_key=bind_key,
         )
 
     async def _create_pool(self) -> "AsyncConnectionPool":
@@ -350,8 +355,7 @@ class PsycopgAsyncConfig(AsyncDatabaseConfig[PsycopgAsyncConnection, AsyncConnec
             return
 
         try:
-            if hasattr(self.pool_instance, "_closed"):
-                self.pool_instance._closed = True
+            self.pool_instance._closed = True  # pyright: ignore[reportPrivateUsage]
 
             await self.pool_instance.close()
         finally:

sqlspec/adapters/psycopg/data_dictionary.py

@@ -0,0 +1,257 @@
+"""PostgreSQL-specific data dictionary for metadata queries via psycopg."""
+
+import re
+from typing import TYPE_CHECKING, Optional, cast
+
+from sqlspec.driver import (
+    AsyncDataDictionaryBase,
+    AsyncDriverAdapterBase,
+    SyncDataDictionaryBase,
+    SyncDriverAdapterBase,
+    VersionInfo,
+)
+from sqlspec.utils.logging import get_logger
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from sqlspec.adapters.psycopg.driver import PsycopgAsyncDriver, PsycopgSyncDriver
+
+logger = get_logger("adapters.psycopg.data_dictionary")
+
+# Compiled regex patterns
+POSTGRES_VERSION_PATTERN = re.compile(r"PostgreSQL (\d+)\.(\d+)(?:\.(\d+))?")
+
+__all__ = ("PostgresAsyncDataDictionary", "PostgresSyncDataDictionary")
+
+
+class PostgresSyncDataDictionary(SyncDataDictionaryBase):
+    """PostgreSQL-specific sync data dictionary."""
+
+    def get_version(self, driver: SyncDriverAdapterBase) -> "Optional[VersionInfo]":
+        """Get PostgreSQL database version information.
+
+        Args:
+            driver: Sync database driver instance
+
+        Returns:
+            PostgreSQL version information or None if detection fails
+        """
+        version_str = cast("PsycopgSyncDriver", 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
+
+    def get_feature_flag(self, driver: SyncDriverAdapterBase, feature: str) -> bool:
+        """Check if PostgreSQL database supports a specific feature.
+
+        Args:
+            driver: Sync database driver instance
+            feature: Feature name to check
+
+        Returns:
+            True if feature is supported, False otherwise
+        """
+        version_info = 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
+
+    def get_optimal_type(self, driver: SyncDriverAdapterBase, type_category: str) -> str:
+        """Get optimal PostgreSQL type for a category.
+
+        Args:
+            driver: Sync database driver instance
+            type_category: Type category
+
+        Returns:
+            PostgreSQL-specific type name
+        """
+        version_info = 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",
+        ]
+
+
+class PostgresAsyncDataDictionary(AsyncDataDictionaryBase):
+    """PostgreSQL-specific async data dictionary."""
+
+    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("PsycopgAsyncDriver", 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",
+        ]