wcp-library 1.5.7__tar.gz → 1.6.1__tar.gz

{wcp_library-1.5.7 → wcp_library-1.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: wcp-library
-Version: 1.5.7
+Version: 1.6.1
 Summary: Common utilites for internal development at WCP
 Author: Mitch-Petersen
 Author-email: mitch.petersen@wcap.ca

{wcp_library-1.5.7 → wcp_library-1.6.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "wcp-library"
-version = "1.5.7"
+version = "1.6.1"
 description = "Common utilites for internal development at WCP"
 authors = [{name="Mitch-Petersen", email="mitch.petersen@wcap.ca"}]
 readme = "README.md"

{wcp_library-1.5.7 → wcp_library-1.6.1}/wcp_library/sql/__init__.py

@@ -9,20 +9,20 @@ import psycopg
 logger = logging.getLogger(__name__)
 
 
-def retry(f: callable) -> callable:
+def retry(func: callable) -> callable:
     """
     Decorator to retry a function
 
-    :param f: function
+    :param func: function
     :return: function
     """
 
-    @wraps(f)
+    @wraps(func)
     def wrapper(self, *args, **kwargs):
         self._retry_count = 0
         while True:
             try:
-                return f(self, *args, **kwargs)
+                return func(self, *args, **kwargs)
             except (oracledb.OperationalError, oracledb.DatabaseError, psycopg.OperationalError) as e:
                 if isinstance(e, (oracledb.OperationalError, oracledb.DatabaseError, psycopg.OperationalError, psycopg.DatabaseError)):
                     error_obj, = e.args
@@ -38,20 +38,20 @@ def retry(f: callable) -> callable:
     return wrapper
 
 
-def async_retry(f: callable) -> callable:
+def async_retry(func: callable) -> callable:
     """
     Decorator to retry a function
 
-    :param f: function
+    :param func: function
     :return: function
     """
 
-    @wraps(f)
+    @wraps(func)
     async def wrapper(self, *args, **kwargs):
         self._retry_count = 0
         while True:
             try:
-                return await f(self, *args, **kwargs)
+                return await func(self, *args, **kwargs)
             except (oracledb.OperationalError, oracledb.DatabaseError, psycopg.OperationalError) as e:
                 if isinstance(e, (oracledb.OperationalError, oracledb.DatabaseError, psycopg.OperationalError, psycopg.DatabaseError)):
                     error_obj, = e.args

{wcp_library-1.5.7 → wcp_library-1.6.1}/wcp_library/sql/oracle.py

@@ -4,7 +4,7 @@ from typing import Optional
 import numpy as np
 import pandas as pd
 import oracledb
-from oracledb import ConnectionPool, AsyncConnectionPool
+from oracledb import ConnectionPool, AsyncConnectionPool, Connection, AsyncConnection
 
 from wcp_library.sql import retry, async_retry
 
@@ -12,7 +12,7 @@ logger = logging.getLogger(__name__)
 
 
 def _connect_warehouse(username: str, password: str, hostname: str, port: int, database: str, min_connections: int,
-                       max_connections: int) -> ConnectionPool:
+                       max_connections: int, use_pool: bool) -> ConnectionPool | Connection:
     """
     Create Warehouse Connection
 
@@ -23,23 +23,34 @@ def _connect_warehouse(username: str, password: str, hostname: str, port: int, d
     :param database: database
     :param min_connections:
     :param max_connections:
-    :return: session_pool
+    :param use_pool: use connection pool
+    :return: session_pool | connection
     """
 
-    dsn = oracledb.makedsn(hostname, port, sid=database)
-    session_pool = oracledb.create_pool(
-        user=username,
-        password=password,
-        dsn=dsn,
-        min=min_connections,
-        max=max_connections,
-        increment=1,
-    )
-    return session_pool
+    if use_pool:
+        logger.debug(f"Creating connection pool with min size {min_connections} and max size {max_connections}")
+        dsn = oracledb.makedsn(hostname, port, sid=database)
+        session_pool = oracledb.create_pool(
+            user=username,
+            password=password,
+            dsn=dsn,
+            min=min_connections,
+            max=max_connections,
+            increment=1,
+        )
+        return session_pool
+    else:
+        logger.debug("Creating single connection")
+        connection = oracledb.connect(
+            user=username,
+            password=password,
+            dsn=oracledb.makedsn(hostname, port, sid=database)
+        )
+        return connection
 
 
 async def _async_connect_warehouse(username: str, password: str, hostname: str, port: int, database: str,
-                                   min_connections: int, max_connections: int) -> AsyncConnectionPool:
+                                   min_connections: int, max_connections: int, use_pool: bool) -> AsyncConnectionPool | AsyncConnection:
     """
     Create Warehouse Connection
 
@@ -50,19 +61,30 @@ async def _async_connect_warehouse(username: str, password: str, hostname: str,
     :param database: database
     :param min_connections:
     :param max_connections:
-    :return: session_pool
+    :param use_pool: use connection pool
+    :return: session_pool | connection
     """
 
-    dsn = oracledb.makedsn(hostname, port, sid=database)
-    session_pool = oracledb.create_pool_async(
-        user=username,
-        password=password,
-        dsn=dsn,
-        min=min_connections,
-        max=max_connections,
-        increment=1
-    )
-    return session_pool
+    if use_pool:
+        logger.debug(f"Creating async connection pool with min size {min_connections} and max size {max_connections}")
+        dsn = oracledb.makedsn(hostname, port, sid=database)
+        session_pool = oracledb.create_pool_async(
+            user=username,
+            password=password,
+            dsn=dsn,
+            min=min_connections,
+            max=max_connections,
+            increment=1
+        )
+        return session_pool
+    else:
+        logger.debug("Creating single async connection")
+        connection = await oracledb.connect_async(
+            user=username,
+            password=password,
+            dsn=oracledb.makedsn(hostname, port, sid=database)
+        )
+        return connection
 
 
 """~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"""
@@ -75,15 +97,17 @@ class OracleConnection(object):
     :return: None
     """
 
-    def __init__(self, min_connections: int = 2, max_connections: int = 5):
+    def __init__(self, use_pool: bool = False, min_connections: int = 2, max_connections: int = 5):
         self._username: Optional[str] = None
         self._password: Optional[str] = None
         self._hostname: Optional[str] = None
         self._port: Optional[int] = None
         self._database: Optional[str] = None
         self._sid: Optional[str] = None
+        self._connection: Optional[Connection] = None
         self._session_pool: Optional[ConnectionPool] = None
 
+        self.use_pool = use_pool
         self.min_connections = min_connections
         self.max_connections = max_connections
 
@@ -101,8 +125,27 @@ class OracleConnection(object):
 
         sid_or_service = self._database if self._database else self._sid
 
-        self._session_pool = _connect_warehouse(self._username, self._password, self._hostname, self._port,
-                                                sid_or_service, self.min_connections, self.max_connections)
+        connection = _connect_warehouse(self._username, self._password, self._hostname, self._port,
+                                        sid_or_service, self.min_connections, self.max_connections, self.use_pool)
+
+        if self.use_pool:
+            self._session_pool = connection
+        else:
+            self._connection = connection
+
+    def _get_connection(self) -> Connection:
+        """
+        Get the connection, either from the pool or create a new one
+
+        :return: Connection
+        """
+
+        if self.use_pool:
+            return self._session_pool.acquire()
+        else:
+            if not self._connection or not self._connection.is_healthy():
+                self._connect()
+            return self._connection
 
     def set_user(self, credentials_dict: dict) -> None:
         """
@@ -131,7 +174,12 @@ class OracleConnection(object):
         :return: None
         """
 
-        self._session_pool.close()
+        if self.use_pool:
+            self._session_pool.close()
+        else:
+            if self._connection and self._connection.is_healthy():
+                self._connection.close()
+            self._connection = None
 
     @retry
     def execute(self, query: str) -> None:
@@ -142,11 +190,11 @@ class OracleConnection(object):
         :return: None
         """
 
-        connection = self._session_pool.acquire()
-        cursor = connection.cursor()
-        cursor.execute(query)
-        connection.commit()
-        self._session_pool.release(connection)
+        connection = self._get_connection()
+        with connection:
+            cursor = connection.cursor()
+            cursor.execute(query)
+            connection.commit()
 
     @retry
     def safe_execute(self, query: str, packed_values: dict) -> None:
@@ -158,14 +206,14 @@ class OracleConnection(object):
         :return: None
         """
 
-        connection = self._session_pool.acquire()
-        cursor = connection.cursor()
-        cursor.execute(query, packed_values)
-        connection.commit()
-        self._session_pool.release(connection)
+        connection = self._get_connection()
+        with connection:
+            cursor = connection.cursor()
+            cursor.execute(query, packed_values)
+            connection.commit()
 
     @retry
-    def execute_multiple(self, queries: list[list[str, dict]]) -> None:
+    def execute_multiple(self, queries: list[tuple[str, dict]]) -> None:
         """
         Execute multiple queries
 
@@ -173,17 +221,17 @@ class OracleConnection(object):
         :return: None
         """
 
-        connection = self._session_pool.acquire()
-        cursor = connection.cursor()
-        for item in queries:
-            query = item[0]
-            packed_values = item[1]
-            if packed_values:
-                cursor.execute(query, packed_values)
-            else:
-                cursor.execute(query)
-        connection.commit()
-        self._session_pool.release(connection)
+        connection = self._get_connection()
+        with connection:
+            cursor = connection.cursor()
+            for item in queries:
+                query = item[0]
+                packed_values = item[1]
+                if packed_values:
+                    cursor.execute(query, packed_values)
+                else:
+                    cursor.execute(query)
+            connection.commit()
 
     @retry
     def execute_many(self, query: str, dictionary: list[dict]) -> None:
@@ -195,11 +243,11 @@ class OracleConnection(object):
         :return: None
         """
 
-        connection = self._session_pool.acquire()
-        cursor = connection.cursor()
-        cursor.executemany(query, dictionary)
-        connection.commit()
-        self._session_pool.release(connection)
+        connection = self._get_connection()
+        with connection:
+            cursor = connection.cursor()
+            cursor.executemany(query, dictionary)
+            connection.commit()
 
     @retry
     def fetch_data(self, query: str, packed_data=None) -> list:
@@ -211,14 +259,14 @@ class OracleConnection(object):
         :return: rows
         """
 
-        connection = self._session_pool.acquire()
-        cursor = connection.cursor()
-        if packed_data:
-            cursor.execute(query, packed_data)
-        else:
-            cursor.execute(query)
-        rows = cursor.fetchall()
-        self._session_pool.release(connection)
+        connection = self._get_connection()
+        with connection:
+            cursor = connection.cursor()
+            if packed_data:
+                cursor.execute(query, packed_data)
+            else:
+                cursor.execute(query)
+            rows = cursor.fetchall()
         return rows
 
     @retry
@@ -267,7 +315,7 @@ class OracleConnection(object):
             dfObj = dfObj.replace({np.nan: None})
         main_dict = dfObj.to_dict('records')
 
-        query = """INSERT INTO {} ({}) VALUES ({})""".format(outputTableName, col, bind)
+        query = f"""INSERT INTO {outputTableName} ({col}) VALUES ({bind})"""
         self.execute_many(query, main_dict)
 
     @retry
@@ -279,7 +327,7 @@ class OracleConnection(object):
         :return: None
         """
 
-        truncateQuery = """TRUNCATE TABLE {}""".format(tableName)
+        truncateQuery = f"""TRUNCATE TABLE {tableName}"""
         self.execute(truncateQuery)
 
     @retry
@@ -291,7 +339,7 @@ class OracleConnection(object):
         :return: None
         """
 
-        deleteQuery = """DELETE FROM {}""".format(tableName)
+        deleteQuery = f"""DELETE FROM {tableName}"""
         self.execute(deleteQuery)
 
     def __del__(self) -> None:
@@ -301,7 +349,12 @@ class OracleConnection(object):
         :return: None
         """
 
-        self._session_pool.close()
+        if self.use_pool:
+            self._session_pool.close()
+        else:
+            if self._connection and self._connection.is_healthy():
+                self._connection.close()
+            self._connection = None
 
 
 class AsyncOracleConnection(object):
@@ -311,7 +364,7 @@ class AsyncOracleConnection(object):
     :return: None
     """
 
-    def __init__(self, min_connections: int = 2, max_connections: int = 5):
+    def __init__(self, use_pool: bool = False, min_connections: int = 2, max_connections: int = 5):
         self._db_service: str = "Oracle"
         self._username: Optional[str] = None
         self._password: Optional[str] = None
@@ -319,8 +372,10 @@ class AsyncOracleConnection(object):
         self._port: Optional[int] = None
         self._database: Optional[str] = None
         self._sid: Optional[str] = None
+        self._connection: Optional[AsyncConnection] = None
         self._session_pool: Optional[AsyncConnectionPool] = None
 
+        self.use_pool = use_pool
         self.min_connections = min_connections
         self.max_connections = max_connections
 
@@ -338,8 +393,28 @@ class AsyncOracleConnection(object):
 
         sid_or_service = self._database if self._database else self._sid
 
-        self._session_pool = await _async_connect_warehouse(self._username, self._password, self._hostname, self._port,
-                                                            sid_or_service, self.min_connections, self.max_connections)
+        connection = await _async_connect_warehouse(self._username, self._password, self._hostname, self._port,
+                                                    sid_or_service, self.min_connections, self.max_connections,
+                                                    self.use_pool)
+
+        if self.use_pool:
+            self._session_pool = connection
+        else:
+            self._connection = connection
+
+    async def _get_connection(self) -> AsyncConnection:
+        """
+        Get the connection, either from the pool or create a new one
+
+        :return: AsyncConnection
+        """
+
+        if self.use_pool:
+            return await self._session_pool.acquire()
+        else:
+            if not self._connection or not self._connection.is_healthy():
+                await self._connect()
+            return self._connection
 
     async def set_user(self, credentials_dict: dict) -> None:
         """
@@ -368,7 +443,12 @@ class AsyncOracleConnection(object):
         :return: None
         """
 
-        await self._session_pool.close()
+        if self.use_pool:
+            await self._session_pool.close()
+        else:
+            if self._connection and self._connection.is_healthy():
+                await self._connection.close()
+            self._connection = None
 
     @async_retry
     async def execute(self, query: str) -> None:
@@ -379,7 +459,8 @@ class AsyncOracleConnection(object):
         :return: None
         """
 
-        async with self._session_pool.acquire() as connection:
+        connection = await self._get_connection()
+        async with connection:
             with connection.cursor() as cursor:
                 await cursor.execute(query)
                 await connection.commit()
@@ -394,13 +475,14 @@ class AsyncOracleConnection(object):
         :return: None
         """
 
-        async with self._session_pool.acquire() as connection:
+        connection = await self._get_connection()
+        async with connection:
             with connection.cursor() as cursor:
                 await cursor.execute(query, packed_values)
                 await connection.commit()
 
     @async_retry
-    async def execute_multiple(self, queries: list[list[str, dict]]) -> None:
+    async def execute_multiple(self, queries: list[tuple[str, dict]]) -> None:
         """
         Execute multiple queries
 
@@ -408,7 +490,8 @@ class AsyncOracleConnection(object):
         :return: None
         """
 
-        async with self._session_pool.acquire() as connection:
+        connection = await self._get_connection()
+        async with connection:
             with connection.cursor() as cursor:
                 for item in queries:
                     query = item[0]
@@ -429,7 +512,8 @@ class AsyncOracleConnection(object):
         :return: None
         """
 
-        async with self._session_pool.acquire() as connection:
+        connection = await self._get_connection()
+        async with connection:
             with connection.cursor() as cursor:
                 await cursor.executemany(query, dictionary)
                 await connection.commit()
@@ -444,7 +528,8 @@ class AsyncOracleConnection(object):
         :return: rows
         """
 
-        async with self._session_pool.acquire() as connection:
+        connection = await self._get_connection()
+        async with connection:
             with connection.cursor() as cursor:
                 if packed_data:
                     await cursor.execute(query, packed_data)
@@ -499,7 +584,7 @@ class AsyncOracleConnection(object):
             dfObj = dfObj.replace({np.nan: None})
         main_dict = dfObj.to_dict('records')
 
-        query = """INSERT INTO {} ({}) VALUES ({})""".format(outputTableName, col, bind)
+        query = f"""INSERT INTO {outputTableName} ({col}) VALUES ({bind})"""
         await self.execute_many(query, main_dict)
 
     @async_retry
@@ -511,7 +596,7 @@ class AsyncOracleConnection(object):
         :return: None
         """
 
-        truncateQuery = """TRUNCATE TABLE {}""".format(tableName)
+        truncateQuery = f"""TRUNCATE TABLE {tableName}"""
         await self.execute(truncateQuery)
 
     @async_retry
@@ -523,5 +608,5 @@ class AsyncOracleConnection(object):
         :return: None
         """
 
-        deleteQuery = """DELETE FROM {}""".format(tableName)
+        deleteQuery = f"""DELETE FROM {tableName}"""
         await self.execute(deleteQuery)

{wcp_library-1.5.7 → wcp_library-1.6.1}/wcp_library/sql/postgres.py

@@ -3,6 +3,8 @@ from typing import Optional
 
 import numpy as np
 import pandas as pd
+import psycopg
+from psycopg import AsyncConnection, Connection
 from psycopg.conninfo import make_conninfo
 from psycopg.sql import SQL
 from psycopg_pool import AsyncConnectionPool, ConnectionPool
@@ -13,7 +15,7 @@ logger = logging.getLogger(__name__)
 
 
 def _connect_warehouse(username: str, password: str, hostname: str, port: int, database: str, min_connections: int,
-                       max_connections: int) -> ConnectionPool:
+                       max_connections: int, use_pool: bool) -> Connection | ConnectionPool:
     """
     Create Warehouse Connection
 
@@ -30,18 +32,24 @@ def _connect_warehouse(username: str, password: str, hostname: str, port: int, d
     conn_string = f"dbname={database} user={username} password={password} host={hostname} port={port}"
     conninfo = make_conninfo(conn_string)
 
-    session_pool = ConnectionPool(
-        conninfo=conninfo,
-        min_size=min_connections,
-        max_size=max_connections,
-        kwargs={'options': '-c datestyle=ISO,YMD'},
-        open=True
-    )
-    return session_pool
+    if use_pool:
+        logger.debug(f"Creating connection pool with min size {min_connections} and max size {max_connections}")
+        session_pool = ConnectionPool(
+            conninfo=conninfo,
+            min_size=min_connections,
+            max_size=max_connections,
+            kwargs={'options': '-c datestyle=ISO,YMD'},
+            open=True
+        )
+        return session_pool
+    else:
+        logger.debug("Creating single connection")
+        connection = psycopg.connect(conninfo=conninfo, options='-c datestyle=ISO,YMD')
+        return connection
 
 
 async def _async_connect_warehouse(username: str, password: str, hostname: str, port: int, database: str, min_connections: int,
-                             max_connections: int) -> AsyncConnectionPool:
+                                   max_connections: int, use_pool: bool) -> AsyncConnection | AsyncConnectionPool:
     """
     Create Warehouse Connection
 
@@ -58,14 +66,20 @@ async def _async_connect_warehouse(username: str, password: str, hostname: str,
     conn_string = f"dbname={database} user={username} password={password} host={hostname} port={port}"
     conninfo = make_conninfo(conn_string)
 
-    session_pool = AsyncConnectionPool(
-        conninfo=conninfo,
-        min_size=min_connections,
-        max_size=max_connections,
-        kwargs={"options": "-c datestyle=ISO,YMD"},
-        open=False
-    )
-    return session_pool
+    if use_pool:
+        logger.debug(f"Creating async connection pool with min size {min_connections} and max size {max_connections}")
+        session_pool = AsyncConnectionPool(
+            conninfo=conninfo,
+            min_size=min_connections,
+            max_size=max_connections,
+            kwargs={"options": "-c datestyle=ISO,YMD"},
+            open=False
+        )
+        return session_pool
+    else:
+        logger.debug("Creating single async connection")
+        connection = await AsyncConnection.connect(conninfo=conninfo, options='-c datestyle=ISO,YMD')
+        return connection
 
 
 """~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"""
@@ -78,14 +92,16 @@ class PostgresConnection(object):
     :return: None
     """
 
-    def __init__(self, min_connections: int = 2, max_connections: int = 5):
+    def __init__(self, use_pool: bool = False, min_connections: int = 2, max_connections: int = 5):
         self._username: Optional[str] = None
         self._password: Optional[str] = None
         self._hostname: Optional[str] = None
         self._port: Optional[int] = None
         self._database: Optional[str] = None
+        self._connection: Optional[Connection] = None
         self._session_pool: Optional[ConnectionPool] = None
 
+        self.use_pool = use_pool
         self.min_connections = min_connections
         self.max_connections = max_connections
 
@@ -101,8 +117,30 @@ class PostgresConnection(object):
         :return: None
         """
 
-        self._session_pool = _connect_warehouse(self._username, self._password, self._hostname, self._port,
-                                               self._database, self.min_connections, self.max_connections)
+
+        self.connection = _connect_warehouse(self._username, self._password, self._hostname, self._port,
+                                             self._database, self.min_connections, self.max_connections, self.use_pool)
+
+        if self.use_pool:
+            self._session_pool = self.connection
+            self._session_pool.open()
+        else:
+            self._connection = self.connection
+
+    def _get_connection(self) -> Connection:
+        """
+        Get the connection object
+
+        :return: connection
+        """
+
+        if self.use_pool:
+            connection = self._session_pool.getconn()
+            return connection
+        else:
+            if self._connection is None or self._connection.closed:
+                self._connect()
+            return self._connection
 
     def set_user(self, credentials_dict: dict) -> None:
         """
@@ -127,7 +165,12 @@ class PostgresConnection(object):
         :return: None
         """
 
-        self._session_pool.close()
+        if self.use_pool:
+            self._session_pool.close()
+        else:
+            if self._connection is not None and not self._connection.closed:
+                self._connection.close()
+            self._connection = None
 
     @retry
     def execute(self, query: SQL | str) -> None:
@@ -138,9 +181,13 @@ class PostgresConnection(object):
         :return: None
         """
 
-        with self._session_pool.connection() as connection:
+        connection = self._get_connection()
+        with connection:
             connection.execute(query)
 
+        if self.use_pool:
+            self._session_pool.putconn(connection)
+
     @retry
     def safe_execute(self, query: SQL | str, packed_values: dict) -> None:
         """
@@ -151,11 +198,15 @@ class PostgresConnection(object):
         :return: None
         """
 
-        with self._session_pool.connection() as connection:
+        connection = self._get_connection()
+        with connection:
             connection.execute(query, packed_values)
 
+        if self.use_pool:
+            self._session_pool.putconn(connection)
+
     @retry
-    def execute_multiple(self, queries: list[list[SQL | str, dict]]) -> None:
+    def execute_multiple(self, queries: list[tuple[SQL | str, dict]]) -> None:
         """
         Execute multiple queries
 
@@ -163,7 +214,8 @@ class PostgresConnection(object):
         :return: None
         """
 
-        with self._session_pool.connection() as connection:
+        connection = self._get_connection()
+        with connection:
             for item in queries:
                 query = item[0]
                 packed_values = item[1]
@@ -172,6 +224,9 @@ class PostgresConnection(object):
                 else:
                     connection.execute(query)
 
+        if self.use_pool:
+            self._session_pool.putconn(connection)
+
     @retry
     def execute_many(self, query: SQL | str, dictionary: list[dict]) -> None:
         """
@@ -182,10 +237,14 @@ class PostgresConnection(object):
         :return: None
         """
 
-        with self._session_pool.connection() as connection:
+        connection = self._get_connection()
+        with connection:
             cursor = connection.cursor()
             cursor.executemany(query, dictionary)
 
+        if self.use_pool:
+            self._session_pool.putconn(connection)
+
     @retry
     def fetch_data(self, query: SQL | str, packed_data=None) -> list[tuple]:
         """
@@ -196,13 +255,17 @@ class PostgresConnection(object):
         :return: rows
         """
 
-        with self._session_pool.connection() as connection:
+        connection = self._get_connection()
+        with connection:
             cursor = connection.cursor()
             if packed_data:
                 cursor.execute(query, packed_data)
             else:
                 cursor.execute(query)
             rows = cursor.fetchall()
+
+        if self.use_pool:
+            self._session_pool.putconn(connection)
         return rows
 
     @retry
@@ -255,7 +318,7 @@ class PostgresConnection(object):
                 if record[key] == '':
                     record[key] = None
 
-        query = """INSERT INTO {} ({}) VALUES ({})""".format(outputTableName, col, params)
+        query = f"INSERT INTO {outputTableName} ({col}) VALUES ({params})"
         self.execute_many(query, main_dict)
 
     @retry
@@ -267,7 +330,7 @@ class PostgresConnection(object):
         :return: None
         """
 
-        truncateQuery = """TRUNCATE TABLE {}""".format(tableName)
+        truncateQuery = f"TRUNCATE TABLE {tableName}"
         self.execute(truncateQuery)
 
     @retry
@@ -279,7 +342,7 @@ class PostgresConnection(object):
         :return: None
         """
 
-        deleteQuery = """DELETE FROM {}""".format(tableName)
+        deleteQuery = f"DELETE FROM {tableName}"
         self.execute(deleteQuery)
 
     def __del__(self) -> None:
@@ -289,7 +352,12 @@ class PostgresConnection(object):
         :return: None
         """
 
-        self._session_pool.close()
+        if self._session_pool is not None:
+            self._session_pool.close()
+        else:
+            if self._connection is not None and not self._connection.closed:
+                self._connection.close()
+            self._connection = None
 
 
 class AsyncPostgresConnection(object):
@@ -299,14 +367,16 @@ class AsyncPostgresConnection(object):
     :return: None
     """
 
-    def __init__(self, min_connections: int = 2, max_connections: int = 5):
+    def __init__(self, use_pool: bool = False, min_connections: int = 2, max_connections: int = 5):
         self._username: Optional[str] = None
         self._password: Optional[str] = None
         self._hostname: Optional[str] = None
         self._port: Optional[int] = None
         self._database: Optional[str] = None
+        self._connection: Optional[AsyncConnection] = None
         self._session_pool: Optional[AsyncConnectionPool] = None
 
+        self.use_pool = use_pool
         self.min_connections = min_connections
         self.max_connections = max_connections
 
@@ -322,9 +392,30 @@ class AsyncPostgresConnection(object):
         :return: None
         """
 
-        self._session_pool = await _async_connect_warehouse(self._username, self._password, self._hostname, self._port,
-                                                            self._database, self.min_connections, self.max_connections)
-        await self._session_pool.open()
+        connection = await _async_connect_warehouse(self._username, self._password, self._hostname, self._port,
+                                                    self._database, self.min_connections, self.max_connections,
+                                                    self.use_pool)
+        if self.use_pool:
+            self._session_pool = connection
+            await self._session_pool.open()
+        else:
+            self._connection = connection
+
+    async def _get_connection(self) -> AsyncConnection:
+        """
+        Get the connection object
+
+        :return: connection
+        """
+
+        if self.use_pool:
+            connection = await self._session_pool.getconn()
+            return connection
+        else:
+            if self._connection is None or self._connection.closed:
+                await self._connect()
+            return self._connection
+
 
     async def set_user(self, credentials_dict: dict) -> None:
         """
@@ -349,7 +440,12 @@ class AsyncPostgresConnection(object):
         :return: None
         """
 
-        await self._session_pool.close()
+        if self.use_pool:
+            await self._session_pool.close()
+        else:
+            if self._connection is not None and not self._connection.closed:
+                await self._connection.close()
+            self._connection = None
 
     @async_retry
     async def execute(self, query: SQL | str) -> None:
@@ -360,9 +456,13 @@ class AsyncPostgresConnection(object):
         :return: None
         """
 
-        async with self._session_pool.connection() as connection:
+        connection = await self._get_connection()
+        async with connection:
             await connection.execute(query)
 
+        if self.use_pool:
+            await self._session_pool.putconn(connection)
+
     @async_retry
     async def safe_execute(self, query: SQL | str, packed_values: dict) -> None:
         """
@@ -373,11 +473,15 @@ class AsyncPostgresConnection(object):
         :return: None
         """
 
-        async with self._session_pool.connection() as connection:
+        connection = await self._get_connection()
+        async with connection:
             await connection.execute(query, packed_values)
 
+        if self.use_pool:
+            await self._session_pool.putconn(connection)
+
     @async_retry
-    async def execute_multiple(self, queries: list[list[SQL | str, dict]]) -> None:
+    async def execute_multiple(self, queries: list[tuple[SQL | str, dict]]) -> None:
         """
         Execute multiple queries
 
@@ -385,7 +489,8 @@ class AsyncPostgresConnection(object):
         :return: None
         """
 
-        async with self._session_pool.connection() as connection:
+        connection = await self._get_connection()
+        async with connection:
             for item in queries:
                 query = item[0]
                 packed_values = item[1]
@@ -394,6 +499,9 @@ class AsyncPostgresConnection(object):
                 else:
                     await connection.execute(query)
 
+        if self.use_pool:
+            await self._session_pool.putconn(connection)
+
     @async_retry
     async def execute_many(self, query: SQL | str, dictionary: list[dict]) -> None:
         """
@@ -404,10 +512,14 @@ class AsyncPostgresConnection(object):
         :return: None
         """
 
-        async with self._session_pool.connection() as connection:
+        connection = await self._get_connection()
+        async with connection:
             cursor = connection.cursor()
             await cursor.executemany(query, dictionary)
 
+        if self.use_pool:
+            await self._session_pool.putconn(connection)
+
     @async_retry
     async def fetch_data(self, query: SQL | str, packed_data=None) -> list[tuple]:
         """
@@ -418,13 +530,17 @@ class AsyncPostgresConnection(object):
         :return: rows
         """
 
-        async with self._session_pool.connection() as connection:
+        connection = await self._get_connection()
+        async with connection:
             cursor = connection.cursor()
             if packed_data:
                 await cursor.execute(query, packed_data)
             else:
                 await cursor.execute(query)
             rows = await cursor.fetchall()
+
+        if self.use_pool:
+            await self._session_pool.putconn(connection)
         return rows
 
     @async_retry
@@ -448,7 +564,7 @@ class AsyncPostgresConnection(object):
             params = param_list[0]
 
         main_dict = df.to_dict('records')
-        query = """DELETE FROM {} WHERE {}""".format(outputTableName, params)
+        query = f"DELETE FROM {outputTableName} WHERE {params}"
         await self.execute_many(query, main_dict)
 
     @async_retry
@@ -477,7 +593,7 @@ class AsyncPostgresConnection(object):
                 if record[key] == '':
                     record[key] = None
 
-        query = """INSERT INTO {} ({}) VALUES ({})""".format(outputTableName, col, params)
+        query = f"INSERT INTO {outputTableName} ({col}) VALUES ({params})"
         await self.execute_many(query, main_dict)
 
     @async_retry
@@ -489,7 +605,7 @@ class AsyncPostgresConnection(object):
         :return: None
         """
 
-        truncateQuery = """TRUNCATE TABLE {}""".format(tableName)
+        truncateQuery = f"TRUNCATE TABLE {tableName}"
         await self.execute(truncateQuery)
 
     @async_retry
@@ -501,5 +617,5 @@ class AsyncPostgresConnection(object):
         :return: None
         """
 
-        deleteQuery = """DELETE FROM {}""".format(tableName)
+        deleteQuery = f"DELETE FROM {tableName}"
         await self.execute(deleteQuery)