sqlspec 0.8.0__py3-none-any.whl → 0.9.1__py3-none-any.whl

sqlspec/adapters/psqlpy/driver.py

@@ -0,0 +1,481 @@
+# ruff: noqa: PLR0915, PLR0914, PLR0912, C901
+"""Psqlpy Driver Implementation."""
+
+import logging
+import re
+from typing import TYPE_CHECKING, Any, Optional, Union, cast, overload
+
+from psqlpy.exceptions import RustPSQLDriverPyBaseError
+
+from sqlspec.base import AsyncDriverAdapterProtocol, T
+from sqlspec.exceptions import SQLParsingError
+from sqlspec.statement import PARAM_REGEX, SQLStatement
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+    from psqlpy import Connection, QueryResult
+
+    from sqlspec.typing import ModelDTOT, StatementParameterType
+
+__all__ = ("PsqlpyDriver",)
+
+
+# Regex to find '?' placeholders, skipping those inside quotes or SQL comments
+QMARK_REGEX = re.compile(
+    r"""(?P<dquote>"[^"]*") | # Double-quoted strings
+         (?P<squote>\'[^\']*\') | # Single-quoted strings
+         (?P<comment>--[^\n]*|/\*.*?\*/) | # SQL comments (single/multi-line)
+         (?P<qmark>\?) # The question mark placeholder
+      """,
+    re.VERBOSE | re.DOTALL,
+)
+logger = logging.getLogger("sqlspec")
+
+
+class PsqlpyDriver(AsyncDriverAdapterProtocol["Connection"]):
+    """Psqlpy Postgres Driver Adapter."""
+
+    connection: "Connection"
+    dialect: str = "postgres"
+
+    def __init__(self, connection: "Connection") -> None:
+        self.connection = connection
+
+    def _process_sql_params(
+        self,
+        sql: str,
+        parameters: "Optional[StatementParameterType]" = None,
+        /,
+        **kwargs: Any,
+    ) -> "tuple[str, Optional[Union[tuple[Any, ...], list[Any], dict[str, Any]]]]":
+        """Process SQL and parameters for psqlpy.
+
+        psqlpy uses $1, $2 style parameters natively.
+        This method converts '?' (tuple/list) and ':name' (dict) styles to $n.
+        It relies on SQLStatement for initial parameter validation and merging.
+
+        Args:
+            sql: The SQL to process.
+            parameters: The parameters to process.
+            kwargs: Additional keyword arguments.
+
+        Raises:
+            SQLParsingError: If the SQL is invalid.
+
+        Returns:
+            A tuple of the processed SQL and parameters.
+        """
+        stmt = SQLStatement(sql=sql, parameters=parameters, dialect=self.dialect, kwargs=kwargs or None)
+        sql, parameters = stmt.process()
+
+        # Case 1: Parameters are a dictionary
+        if isinstance(parameters, dict):
+            processed_sql_parts: list[str] = []
+            ordered_params = []
+            last_end = 0
+            param_index = 1
+            found_params_regex: list[str] = []
+
+            for match in PARAM_REGEX.finditer(sql):
+                if match.group("dquote") or match.group("squote") or match.group("comment"):
+                    continue
+
+                if match.group("var_name"):  # Finds :var_name
+                    var_name = match.group("var_name")
+                    found_params_regex.append(var_name)
+                    start = match.start("var_name") - 1
+                    end = match.end("var_name")
+
+                    if var_name not in parameters:
+                        msg = f"Named parameter ':{var_name}' missing from parameters. SQL: {sql}"
+                        raise SQLParsingError(msg)
+
+                    processed_sql_parts.extend((sql[last_end:start], f"${param_index}"))
+                    ordered_params.append(parameters[var_name])
+                    last_end = end
+                    param_index += 1
+
+            processed_sql_parts.append(sql[last_end:])
+            final_sql = "".join(processed_sql_parts)
+
+            if not found_params_regex and parameters:
+                logger.warning(
+                    "Dict params provided (%s), but no :name placeholders found. SQL: %s",
+                    list(parameters.keys()),
+                    sql,
+                )
+                return sql, ()
+
+            provided_keys = set(parameters.keys())
+            found_keys = set(found_params_regex)
+            unused_keys = provided_keys - found_keys
+            if unused_keys:
+                logger.warning("Unused parameters provided: %s. SQL: %s", unused_keys, sql)
+
+            return final_sql, tuple(ordered_params)
+
+        # Case 2: Parameters are a sequence/scalar
+        if isinstance(parameters, (list, tuple)):
+            sequence_processed_parts: list[str] = []
+            param_index = 1
+            last_end = 0
+            qmark_found = False
+
+            for match in QMARK_REGEX.finditer(sql):
+                if match.group("dquote") or match.group("squote") or match.group("comment"):
+                    continue
+
+                if match.group("qmark"):
+                    qmark_found = True
+                    start = match.start("qmark")
+                    end = match.end("qmark")
+                    sequence_processed_parts.extend((sql[last_end:start], f"${param_index}"))
+                    last_end = end
+                    param_index += 1
+
+            sequence_processed_parts.append(sql[last_end:])
+            final_sql = "".join(sequence_processed_parts)
+
+            if parameters and not qmark_found:
+                logger.warning("Sequence parameters provided, but no '?' placeholders found. SQL: %s", sql)
+                return sql, parameters
+
+            expected_params = param_index - 1
+            actual_params = len(parameters)
+            if expected_params != actual_params:
+                msg = f"Parameter count mismatch: Expected {expected_params}, got {actual_params}. SQL: {final_sql}"
+                raise SQLParsingError(msg)
+
+            return final_sql, parameters
+
+        # Case 3: Parameters are None
+        if PARAM_REGEX.search(sql) or QMARK_REGEX.search(sql):
+            # Perform a simpler check if any placeholders might exist if no params are given
+            for match in PARAM_REGEX.finditer(sql):
+                if not (match.group("dquote") or match.group("squote") or match.group("comment")) and match.group(
+                    "var_name"
+                ):
+                    msg = f"SQL contains named parameters (:name) but no parameters provided. SQL: {sql}"
+                    raise SQLParsingError(msg)
+            for match in QMARK_REGEX.finditer(sql):
+                if not (match.group("dquote") or match.group("squote") or match.group("comment")) and match.group(
+                    "qmark"
+                ):
+                    msg = f"SQL contains positional parameters (?) but no parameters provided. SQL: {sql}"
+                    raise SQLParsingError(msg)
+
+        return sql, ()
+
+    # --- Public API Methods --- #
+    @overload
+    async def select(
+        self,
+        sql: str,
+        parameters: "Optional[StatementParameterType]" = None,
+        /,
+        *,
+        connection: "Optional[Connection]" = None,
+        schema_type: None = None,
+        **kwargs: Any,
+    ) -> "Sequence[dict[str, Any]]": ...
+    @overload
+    async def select(
+        self,
+        sql: str,
+        parameters: "Optional[StatementParameterType]" = None,
+        /,
+        *,
+        connection: "Optional[Connection]" = None,
+        schema_type: "type[ModelDTOT]",
+        **kwargs: Any,
+    ) -> "Sequence[ModelDTOT]": ...
+    async def select(
+        self,
+        sql: str,
+        parameters: Optional["StatementParameterType"] = None,
+        /,
+        *,
+        connection: Optional["Connection"] = None,
+        schema_type: "Optional[type[ModelDTOT]]" = None,
+        **kwargs: Any,
+    ) -> "Sequence[Union[ModelDTOT, dict[str, Any]]]":
+        connection = self._connection(connection)
+        sql, parameters = self._process_sql_params(sql, parameters, **kwargs)
+        parameters = parameters or []  # psqlpy expects a list/tuple
+
+        results: QueryResult = await connection.fetch(sql, parameters=parameters)
+
+        if schema_type is None:
+            return cast("list[dict[str, Any]]", results.result())
+        return results.as_class(as_class=schema_type)
+
+    @overload
+    async def select_one(
+        self,
+        sql: str,
+        parameters: "Optional[StatementParameterType]" = None,
+        /,
+        *,
+        connection: "Optional[Connection]" = None,
+        schema_type: None = None,
+        **kwargs: Any,
+    ) -> "dict[str, Any]": ...
+    @overload
+    async def select_one(
+        self,
+        sql: str,
+        parameters: "Optional[StatementParameterType]" = None,
+        /,
+        *,
+        connection: "Optional[Connection]" = None,
+        schema_type: "type[ModelDTOT]",
+        **kwargs: Any,
+    ) -> "ModelDTOT": ...
+    async def select_one(
+        self,
+        sql: str,
+        parameters: Optional["StatementParameterType"] = None,
+        /,
+        *,
+        connection: Optional["Connection"] = None,
+        schema_type: "Optional[type[ModelDTOT]]" = None,
+        **kwargs: Any,
+    ) -> "Union[ModelDTOT, dict[str, Any]]":
+        connection = self._connection(connection)
+        sql, parameters = self._process_sql_params(sql, parameters, **kwargs)
+        parameters = parameters or []
+
+        result = await connection.fetch(sql, parameters=parameters)
+
+        if schema_type is None:
+            result = cast("list[dict[str, Any]]", result.result())  # type: ignore[assignment]
+            return cast("dict[str, Any]", result[0])  # type: ignore[index]
+        return result.as_class(as_class=schema_type)[0]
+
+    @overload
+    async def select_one_or_none(
+        self,
+        sql: str,
+        parameters: "Optional[StatementParameterType]" = None,
+        /,
+        *,
+        connection: "Optional[Connection]" = None,
+        schema_type: None = None,
+        **kwargs: Any,
+    ) -> "Optional[dict[str, Any]]": ...
+    @overload
+    async def select_one_or_none(
+        self,
+        sql: str,
+        parameters: "Optional[StatementParameterType]" = None,
+        /,
+        *,
+        connection: "Optional[Connection]" = None,
+        schema_type: "type[ModelDTOT]",
+        **kwargs: Any,
+    ) -> "Optional[ModelDTOT]": ...
+    async def select_one_or_none(
+        self,
+        sql: str,
+        parameters: Optional["StatementParameterType"] = None,
+        /,
+        *,
+        connection: Optional["Connection"] = None,
+        schema_type: "Optional[type[ModelDTOT]]" = None,
+        **kwargs: Any,
+    ) -> "Optional[Union[ModelDTOT, dict[str, Any]]]":
+        connection = self._connection(connection)
+        sql, parameters = self._process_sql_params(sql, parameters, **kwargs)
+        parameters = parameters or []
+
+        result = await connection.fetch(sql, parameters=parameters)
+        if schema_type is None:
+            result = cast("list[dict[str, Any]]", result.result())  # type: ignore[assignment]
+            if len(result) == 0:  # type: ignore[arg-type]
+                return None
+            return cast("dict[str, Any]", result[0])  # type: ignore[index]
+        result = cast("list[ModelDTOT]", result.as_class(as_class=schema_type))  # type: ignore[assignment]
+        if len(result) == 0:  # type: ignore[arg-type]
+            return None
+        return cast("ModelDTOT", result[0])  # type: ignore[index]
+
+    @overload
+    async def select_value(
+        self,
+        sql: str,
+        parameters: "Optional[StatementParameterType]" = None,
+        /,
+        *,
+        connection: "Optional[Connection]" = None,
+        schema_type: None = None,
+        **kwargs: Any,
+    ) -> "Any": ...
+    @overload
+    async def select_value(
+        self,
+        sql: str,
+        parameters: "Optional[StatementParameterType]" = None,
+        /,
+        *,
+        connection: "Optional[Connection]" = None,
+        schema_type: "type[T]",
+        **kwargs: Any,
+    ) -> "T": ...
+    async def select_value(
+        self,
+        sql: str,
+        parameters: "Optional[StatementParameterType]" = None,
+        /,
+        *,
+        connection: "Optional[Connection]" = None,
+        schema_type: "Optional[type[T]]" = None,
+        **kwargs: Any,
+    ) -> "Union[T, Any]":
+        connection = self._connection(connection)
+        sql, parameters = self._process_sql_params(sql, parameters, **kwargs)
+        parameters = parameters or []
+
+        value = await connection.fetch_val(sql, parameters=parameters)
+
+        if schema_type is None:
+            return value
+        return schema_type(value)  # type: ignore[call-arg]
+
+    @overload
+    async def select_value_or_none(
+        self,
+        sql: str,
+        parameters: "Optional[StatementParameterType]" = None,
+        /,
+        *,
+        connection: "Optional[Connection]" = None,
+        schema_type: None = None,
+        **kwargs: Any,
+    ) -> "Optional[Any]": ...
+    @overload
+    async def select_value_or_none(
+        self,
+        sql: str,
+        parameters: "Optional[StatementParameterType]" = None,
+        /,
+        *,
+        connection: "Optional[Connection]" = None,
+        schema_type: "type[T]",
+        **kwargs: Any,
+    ) -> "Optional[T]": ...
+    async def select_value_or_none(
+        self,
+        sql: str,
+        parameters: "Optional[StatementParameterType]" = None,
+        /,
+        *,
+        connection: "Optional[Connection]" = None,
+        schema_type: "Optional[type[T]]" = None,
+        **kwargs: Any,
+    ) -> "Optional[Union[T, Any]]":
+        connection = self._connection(connection)
+        sql, parameters = self._process_sql_params(sql, parameters, **kwargs)
+        parameters = parameters or []
+        try:
+            value = await connection.fetch_val(sql, parameters=parameters)
+        except RustPSQLDriverPyBaseError:
+            return None
+
+        if value is None:
+            return None
+        if schema_type is None:
+            return value
+        return schema_type(value)  # type: ignore[call-arg]
+
+    async def insert_update_delete(
+        self,
+        sql: str,
+        parameters: Optional["StatementParameterType"] = None,
+        /,
+        *,
+        connection: Optional["Connection"] = None,
+        **kwargs: Any,
+    ) -> int:
+        connection = self._connection(connection)
+        sql, parameters = self._process_sql_params(sql, parameters, **kwargs)
+        parameters = parameters or []
+
+        await connection.execute(sql, parameters=parameters)
+        # For INSERT/UPDATE/DELETE, psqlpy returns an empty list but the operation succeeded
+        # if no error was raised
+        return 1
+
+    @overload
+    async def insert_update_delete_returning(
+        self,
+        sql: str,
+        parameters: "Optional[StatementParameterType]" = None,
+        /,
+        *,
+        connection: "Optional[Connection]" = None,
+        schema_type: None = None,
+        **kwargs: Any,
+    ) -> "dict[str, Any]": ...
+    @overload
+    async def insert_update_delete_returning(
+        self,
+        sql: str,
+        parameters: "Optional[StatementParameterType]" = None,
+        /,
+        *,
+        connection: "Optional[Connection]" = None,
+        schema_type: "type[ModelDTOT]",
+        **kwargs: Any,
+    ) -> "ModelDTOT": ...
+    async def insert_update_delete_returning(
+        self,
+        sql: str,
+        parameters: Optional["StatementParameterType"] = None,
+        /,
+        *,
+        connection: Optional["Connection"] = None,
+        schema_type: "Optional[type[ModelDTOT]]" = None,
+        **kwargs: Any,
+    ) -> "Optional[Union[dict[str, Any], ModelDTOT]]":
+        connection = self._connection(connection)
+        sql, parameters = self._process_sql_params(sql, parameters, **kwargs)
+        parameters = parameters or []
+
+        result = await connection.execute(sql, parameters=parameters)
+        if schema_type is None:
+            result = result.result()  # type: ignore[assignment]
+            if len(result) == 0:  # type: ignore[arg-type]
+                return None
+            return cast("dict[str, Any]", result[0])  # type: ignore[index]
+        result = result.as_class(as_class=schema_type)  # type: ignore[assignment]
+        if len(result) == 0:  # type: ignore[arg-type]
+            return None
+        return cast("ModelDTOT", result[0])  # type: ignore[index]
+
+    async def execute_script(
+        self,
+        sql: str,
+        parameters: Optional["StatementParameterType"] = None,
+        /,
+        *,
+        connection: Optional["Connection"] = None,
+        **kwargs: Any,
+    ) -> str:
+        connection = self._connection(connection)
+        sql, parameters = self._process_sql_params(sql, parameters, **kwargs)
+        parameters = parameters or []
+
+        await connection.execute(sql, parameters=parameters)
+        return sql
+
+    def _connection(self, connection: Optional["Connection"] = None) -> "Connection":
+        """Get the connection to use.
+
+        Args:
+            connection: Optional connection to use. If not provided, use the default connection.
+
+        Returns:
+            The connection to use.
+        """
+        return connection or self.connection

sqlspec/adapters/psycopg/__init__.py

@@ -1,11 +1,16 @@
-from sqlspec.adapters.psycopg.config import PsycopgAsync, PsycopgAsyncPool, PsycopgSync, PsycopgSyncPool
+from sqlspec.adapters.psycopg.config import (
+    PsycopgAsyncConfig,
+    PsycopgAsyncPoolConfig,
+    PsycopgSyncConfig,
+    PsycopgSyncPoolConfig,
+)
 from sqlspec.adapters.psycopg.driver import PsycopgAsyncDriver, PsycopgSyncDriver
 
 __all__ = (
-    "PsycopgAsync",
+    "PsycopgAsyncConfig",
     "PsycopgAsyncDriver",
-    "PsycopgAsyncPool",
-    "PsycopgSync",
+    "PsycopgAsyncPoolConfig",
+    "PsycopgSyncConfig",
     "PsycopgSyncDriver",
-    "PsycopgSyncPool",
+    "PsycopgSyncPoolConfig",
 )

sqlspec/adapters/psycopg/config/__init__.py

@@ -1,9 +1,9 @@
-from sqlspec.adapters.psycopg.config._async import PsycopgAsync, PsycopgAsyncPool
-from sqlspec.adapters.psycopg.config._sync import PsycopgSync, PsycopgSyncPool
+from sqlspec.adapters.psycopg.config._async import PsycopgAsyncConfig, PsycopgAsyncPoolConfig
+from sqlspec.adapters.psycopg.config._sync import PsycopgSyncConfig, PsycopgSyncPoolConfig
 
 __all__ = (
-    "PsycopgAsync",
-    "PsycopgAsyncPool",
-    "PsycopgSync",
-    "PsycopgSyncPool",
+    "PsycopgAsyncConfig",
+    "PsycopgAsyncPoolConfig",
+    "PsycopgSyncConfig",
+    "PsycopgSyncPoolConfig",
 )

sqlspec/adapters/psycopg/config/_async.py

@@ -16,18 +16,18 @@ if TYPE_CHECKING:
 
 
 __all__ = (
-    "PsycopgAsync",
-    "PsycopgAsyncPool",
+    "PsycopgAsyncConfig",
+    "PsycopgAsyncPoolConfig",
 )
 
 
 @dataclass
-class PsycopgAsyncPool(PsycopgGenericPoolConfig[AsyncConnection, AsyncConnectionPool]):
+class PsycopgAsyncPoolConfig(PsycopgGenericPoolConfig[AsyncConnection, AsyncConnectionPool]):
     """Async Psycopg Pool Config"""
 
 
 @dataclass
-class PsycopgAsync(AsyncDatabaseConfig[AsyncConnection, AsyncConnectionPool, PsycopgAsyncDriver]):
+class PsycopgAsyncConfig(AsyncDatabaseConfig[AsyncConnection, AsyncConnectionPool, PsycopgAsyncDriver]):
     """Async Psycopg database Configuration.
 
     This class provides the base configuration for Psycopg database connections, extending
@@ -37,7 +37,7 @@ class PsycopgAsync(AsyncDatabaseConfig[AsyncConnection, AsyncConnectionPool, Psy
     with both synchronous and asynchronous connections.([2](https://www.psycopg.org/psycopg3/docs/api/connections.html))
     """
 
-    pool_config: "Optional[PsycopgAsyncPool]" = None
+    pool_config: "Optional[PsycopgAsyncPoolConfig]" = None
     """Psycopg Pool configuration"""
     pool_instance: "Optional[AsyncConnectionPool]" = None
     """Optional pool to use"""
@@ -71,7 +71,7 @@ class PsycopgAsync(AsyncDatabaseConfig[AsyncConnection, AsyncConnectionPool, Psy
                 self.pool_config,
                 exclude_empty=True,
                 convert_nested=False,
-                exclude=pool_only_params.union({"pool_instance", "connection_type", "driver_type"}),
+                exclude=pool_only_params.union({"pool_instance", "connection_type", "driver_type", "open"}),
             )
         msg = "You must provide a 'pool_config' for this adapter."
         raise ImproperConfigurationError(msg)
@@ -94,7 +94,7 @@ class PsycopgAsync(AsyncDatabaseConfig[AsyncConnection, AsyncConnectionPool, Psy
         raise ImproperConfigurationError(msg)
 
     async def create_connection(self) -> "AsyncConnection":
-        """Create and return a new psycopg async connection.
+        """Create and return a new psycopg async connection from the pool.
 
         Returns:
             An AsyncConnection instance.
@@ -103,9 +103,8 @@ class PsycopgAsync(AsyncDatabaseConfig[AsyncConnection, AsyncConnectionPool, Psy
             ImproperConfigurationError: If the connection could not be created.
         """
         try:
-            from psycopg import AsyncConnection
-
-            return await AsyncConnection.connect(**self.connection_config_dict)
+            pool = await self.provide_pool()
+            return await pool.getconn()
         except Exception as e:
             msg = f"Could not configure the Psycopg connection. Error: {e!s}"
             raise ImproperConfigurationError(msg) from e
@@ -128,10 +127,11 @@ class PsycopgAsync(AsyncDatabaseConfig[AsyncConnection, AsyncConnectionPool, Psy
             raise ImproperConfigurationError(msg)
 
         pool_config = self.pool_config_dict
-        self.pool_instance = AsyncConnectionPool(**pool_config)
+        self.pool_instance = AsyncConnectionPool(open=False, **pool_config)
         if self.pool_instance is None:  # pyright: ignore[reportUnnecessaryComparison]
             msg = "Could not configure the 'pool_instance'. Please check your configuration."  # type: ignore[unreachable]
             raise ImproperConfigurationError(msg)
+        await self.pool_instance.open()
         return self.pool_instance
 
     def provide_pool(self, *args: "Any", **kwargs: "Any") -> "Awaitable[AsyncConnectionPool]":
@@ -150,7 +150,7 @@ class PsycopgAsync(AsyncDatabaseConfig[AsyncConnection, AsyncConnectionPool, Psy
             AsyncConnection: A database connection from the pool.
         """
         pool = await self.provide_pool(*args, **kwargs)
-        async with pool.connection() as connection:
+        async with pool, pool.connection() as connection:
             yield connection
 
     @asynccontextmanager

sqlspec/adapters/psycopg/config/_sync.py

@@ -16,18 +16,18 @@ if TYPE_CHECKING:
 
 
 __all__ = (
-    "PsycopgSync",
-    "PsycopgSyncPool",
+    "PsycopgSyncConfig",
+    "PsycopgSyncPoolConfig",
 )
 
 
 @dataclass
-class PsycopgSyncPool(PsycopgGenericPoolConfig[Connection, ConnectionPool]):
+class PsycopgSyncPoolConfig(PsycopgGenericPoolConfig[Connection, ConnectionPool]):
     """Sync Psycopg Pool Config"""
 
 
 @dataclass
-class PsycopgSync(SyncDatabaseConfig[Connection, ConnectionPool, PsycopgSyncDriver]):
+class PsycopgSyncConfig(SyncDatabaseConfig[Connection, ConnectionPool, PsycopgSyncDriver]):
     """Sync Psycopg database Configuration.
     This class provides the base configuration for Psycopg database connections, extending
     the generic database configuration with Psycopg-specific settings.([1](https://www.psycopg.org/psycopg3/docs/api/connections.html))
@@ -36,7 +36,7 @@ class PsycopgSync(SyncDatabaseConfig[Connection, ConnectionPool, PsycopgSyncDriv
     with both synchronous and asynchronous connections.([2](https://www.psycopg.org/psycopg3/docs/api/connections.html))
     """
 
-    pool_config: "Optional[PsycopgSyncPool]" = None
+    pool_config: "Optional[PsycopgSyncPoolConfig]" = None
     """Psycopg Pool configuration"""
     pool_instance: "Optional[ConnectionPool]" = None
     """Optional pool to use"""
@@ -70,7 +70,7 @@ class PsycopgSync(SyncDatabaseConfig[Connection, ConnectionPool, PsycopgSyncDriv
                 self.pool_config,
                 exclude_empty=True,
                 convert_nested=False,
-                exclude=pool_only_params.union({"pool_instance", "connection_type", "driver_type"}),
+                exclude=pool_only_params.union({"pool_instance", "connection_type", "driver_type", "open"}),
             )
         msg = "You must provide a 'pool_config' for this adapter."
         raise ImproperConfigurationError(msg)
@@ -87,13 +87,13 @@ class PsycopgSync(SyncDatabaseConfig[Connection, ConnectionPool, PsycopgSyncDriv
                 self.pool_config,
                 exclude_empty=True,
                 convert_nested=False,
-                exclude={"pool_instance", "connection_type", "driver_type"},
+                exclude={"pool_instance", "connection_type", "driver_type", "open"},
             )
         msg = "'pool_config' methods can not be used when a 'pool_instance' is provided."
         raise ImproperConfigurationError(msg)
 
     def create_connection(self) -> "Connection":
-        """Create and return a new psycopg connection.
+        """Create and return a new psycopg connection from the pool.
 
         Returns:
             A Connection instance.
@@ -102,9 +102,8 @@ class PsycopgSync(SyncDatabaseConfig[Connection, ConnectionPool, PsycopgSyncDriv
             ImproperConfigurationError: If the connection could not be created.
         """
         try:
-            from psycopg import connect
-
-            return connect(**self.connection_config_dict)
+            pool = self.provide_pool()
+            return pool.getconn()
         except Exception as e:
             msg = f"Could not configure the Psycopg connection. Error: {e!s}"
             raise ImproperConfigurationError(msg) from e
@@ -127,10 +126,11 @@ class PsycopgSync(SyncDatabaseConfig[Connection, ConnectionPool, PsycopgSyncDriv
             raise ImproperConfigurationError(msg)
 
         pool_config = self.pool_config_dict
-        self.pool_instance = ConnectionPool(**pool_config)
+        self.pool_instance = ConnectionPool(open=False, **pool_config)
         if self.pool_instance is None:  # pyright: ignore[reportUnnecessaryComparison]
             msg = "Could not configure the 'pool_instance'. Please check your configuration."  # type: ignore[unreachable]
             raise ImproperConfigurationError(msg)
+        self.pool_instance.open()
         return self.pool_instance
 
     def provide_pool(self, *args: "Any", **kwargs: "Any") -> "ConnectionPool":
@@ -149,7 +149,7 @@ class PsycopgSync(SyncDatabaseConfig[Connection, ConnectionPool, PsycopgSyncDriv
             Connection: A database connection from the pool.
         """
         pool = self.provide_pool(*args, **kwargs)
-        with pool.connection() as connection:
+        with pool, pool.connection() as connection:
             yield connection
 
     @contextmanager