database-wrapper-pgsql 0.1.28__tar.gz

database_wrapper_pgsql-0.1.28/PKG-INFO

@@ -0,0 +1,93 @@
+Metadata-Version: 2.1
+Name: database_wrapper_pgsql
+Version: 0.1.28
+Summary: database_wrapper for PostgreSQL database
+Author-email: Gints Murans <gm@gm.lv>
+License: GNU General Public License v3.0 (GPL-3.0)
+Project-URL: Homepage, https://github.com/gintsmurans/py_database_wrapper
+Project-URL: Documentation, https://github.com/gintsmurans/py_database_wrapper
+Project-URL: Changes, https://github.com/gintsmurans/py_database_wrapper
+Project-URL: Code, https://github.com/gintsmurans/py_database_wrapper
+Project-URL: Issue Tracker, https://github.com/gintsmurans/py_database_wrapper/issues
+Project-URL: Download, https://pypi.org/project/database_wrapper/
+Keywords: database,wrapper,python,postgresql,pgsql
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Database
+Classifier: Topic :: Database :: Front-Ends
+Classifier: Topic :: Software Development
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: database_wrapper==0.1.28
+Requires-Dist: psycopg[binary]>=3.2.0
+Requires-Dist: psycopg[pool]>=3.2.0
+
+# database_wrapper
+
+_Part of the `database_wrapper` package._
+
+This python package is a database wrapper for [PostgreSQL](https://www.postgresql.org/) (also called pgsql) databases.
+
+## Installation
+
+```bash
+pip install database_wrapper[pgsql]
+```
+
+## Usage
+
+```python
+from database_wrapper_pgsql import AsyncPgSQLWithPooling, DBWrapperPgSQL
+
+db = MySQL({
+    "hostname": "localhost",
+    "port": 3306,
+    "username": "root",
+    "password": "your_password",
+    "database": "my_database"
+})
+db.open()
+dbWrapper = DBWrapperMySQL(db=db)
+
+# Simple query
+aModel = MyModel()
+res = await dbWrapper.getByKey(
+    aModel,
+    "id",
+    3005,
+)
+if res:
+    print(f"getByKey: {res.toDict()}")
+else:
+    print("No results")
+
+# Raw query
+res = await dbWrapper.getAll(
+    aModel,
+    """
+        SELECT t1.*, t2.name AS other_name
+        FROM my_table AS t1
+        LEFT JOIN other_table AS t2 ON t1.other_id = t2.id
+    """
+)
+async for record in res:
+    print(f"getAll: {record.toDict()}")
+else:
+    print("No results")
+
+db.close()
+```

database_wrapper_pgsql-0.1.28/README.md

@@ -0,0 +1,55 @@
+# database_wrapper
+
+_Part of the `database_wrapper` package._
+
+This python package is a database wrapper for [PostgreSQL](https://www.postgresql.org/) (also called pgsql) databases.
+
+## Installation
+
+```bash
+pip install database_wrapper[pgsql]
+```
+
+## Usage
+
+```python
+from database_wrapper_pgsql import AsyncPgSQLWithPooling, DBWrapperPgSQL
+
+db = MySQL({
+    "hostname": "localhost",
+    "port": 3306,
+    "username": "root",
+    "password": "your_password",
+    "database": "my_database"
+})
+db.open()
+dbWrapper = DBWrapperMySQL(db=db)
+
+# Simple query
+aModel = MyModel()
+res = await dbWrapper.getByKey(
+    aModel,
+    "id",
+    3005,
+)
+if res:
+    print(f"getByKey: {res.toDict()}")
+else:
+    print("No results")
+
+# Raw query
+res = await dbWrapper.getAll(
+    aModel,
+    """
+        SELECT t1.*, t2.name AS other_name
+        FROM my_table AS t1
+        LEFT JOIN other_table AS t2 ON t1.other_id = t2.id
+    """
+)
+async for record in res:
+    print(f"getAll: {record.toDict()}")
+else:
+    print("No results")
+
+db.close()
+```

database_wrapper_pgsql-0.1.28/database_wrapper_pgsql/__init__.py

@@ -0,0 +1,25 @@
+"""
+database_wrapper_pgsql package - PostgreSQL database wrapper
+
+Part of the database_wrapper package
+"""
+
+# Copyright 2024 Gints Murans
+
+import logging
+
+from .db_wrapper_pgsql import DBWrapperPgSQL
+from .connector import PgConfig, AsyncPgSQLWithPooling, PgSQL
+
+# Set the logger to a quiet default, can be enabled if needed
+logger = logging.getLogger("database_wrapper_pgsql")
+if logger.level == logging.NOTSET:
+    logger.setLevel(logging.WARNING)
+
+
+__all__ = [
+    "DBWrapperPgSQL",
+    "PgConfig",
+    "AsyncPgSQLWithPooling",
+    "PgSQL",
+]

database_wrapper_pgsql-0.1.28/database_wrapper_pgsql/connector.py

@@ -0,0 +1,323 @@
+import asyncio
+from contextvars import ContextVar
+from typing import Any, NotRequired, TypedDict, cast
+
+from psycopg import (
+    # Async
+    AsyncConnection as PgAsyncConnection,
+    AsyncCursor as PgAsyncCursor,
+    # Sync
+    Connection as PgConnection,
+    Cursor as PgCursor,
+    connect as PgConnect,
+)
+from psycopg.rows import (
+    DictRow as PgDictRow,
+    dict_row as PgDictRowFactory,
+)
+from psycopg_pool import AsyncConnectionPool
+
+from database_wrapper import DatabaseBackend
+from database_wrapper.utils.timer import Timer
+
+
+PgConnectionType = PgConnection[PgDictRow]
+PgCursorType = PgCursor[PgDictRow]
+
+PgAsyncConnectionType = PgAsyncConnection[PgDictRow]
+PgAsyncCursorType = PgAsyncCursor[PgDictRow]
+
+
+class PgConfig(TypedDict):
+    hostname: str
+    port: NotRequired[int]
+    username: str
+    password: str
+    database: str
+    ssl: NotRequired[str]
+    kwargs: NotRequired[dict[str, Any]]
+
+    # Connection Pooling
+    maxconnections: int
+    pool_kwargs: NotRequired[dict[str, Any]]
+
+
+class PgSQL(DatabaseBackend):
+    """
+    PostgreSQL database implementation
+
+    :param config: Configuration for PostgreSQL
+    :type config: PgConfig
+
+    Defaults:
+        port = 5432
+        ssl = prefer
+
+    """
+
+    config: PgConfig
+
+    connection: PgConnectionType | None
+    cursor: PgCursorType | None
+
+    def open(self):
+        # Free resources
+        if hasattr(self, "connection") and self.connection:
+            self.close()
+
+        # Set defaults
+        if "port" not in self.config or not self.config["port"]:
+            self.config["port"] = 5432
+
+        if "ssl" not in self.config or not self.config["ssl"]:
+            self.config["ssl"] = "prefer"
+
+        if "kwargs" not in self.config or not self.config["kwargs"]:
+            self.config["kwargs"] = {}
+
+        self.logger.debug("Connecting to DB")
+        self.connection = cast(
+            PgConnectionType,
+            PgConnect(
+                host=self.config["hostname"],
+                port=self.config["port"],
+                sslmode=self.config["ssl"],
+                user=self.config["username"],
+                password=self.config["password"],
+                dbname=self.config["database"],
+                connect_timeout=self.connectionTimeout,
+                row_factory=PgDictRowFactory,  # type: ignore
+                **self.config["kwargs"],
+            ),
+        )
+        self.cursor = self.connection.cursor(row_factory=PgDictRowFactory)
+
+        # Lets do some socket magic
+        self.fixSocketTimeouts(self.connection.fileno())
+
+    def affectedRows(self) -> int:
+        assert self.cursor, "Cursor is not initialized"
+
+        return self.cursor.rowcount
+
+    def commit(self) -> None:
+        """Commit DB queries"""
+        assert self.connection, "Connection is not initialized"
+
+        self.logger.debug(f"Commit DB queries")
+        self.connection.commit()
+
+    def rollback(self) -> None:
+        """Rollback DB queries"""
+        assert self.connection, "Connection is not initialized"
+
+        self.logger.debug(f"Rollback DB queries")
+        self.connection.rollback()
+
+
+class AsyncPgSQLWithPooling(DatabaseBackend):
+    """
+    PostgreSQL database implementation with async and connection pooling
+
+    :param config: Configuration for PostgreSQL
+    :type config: PgConfig
+
+    Defaults:
+        port = 5432
+        ssl = prefer
+        maxconnections = 5
+    """
+
+    config: PgConfig
+
+    asyncPool: AsyncConnectionPool[PgAsyncConnectionType]
+    contextAsyncConnection: ContextVar[
+        tuple[PgAsyncConnectionType, PgAsyncCursorType] | None
+    ]
+
+    def __init__(
+        self,
+        dbConfig: PgConfig,
+        connectionTimeout: int = 5,
+        instanceName: str = "async_postgresql",
+    ) -> None:
+        """
+        Main concept here is that in init we do not connect to database,
+        so that class instances can be safely made regardless of connection statuss.
+
+        Remember to call open() after creating instance to actually open the pool to the database
+        and also close() to close the pool.
+        """
+
+        super().__init__(dbConfig, connectionTimeout, instanceName)
+
+        # Set defaults
+        if not "port" in self.config or not self.config["port"]:
+            self.config["port"] = 5432
+
+        if not "ssl" in self.config or not self.config["ssl"]:
+            self.config["ssl"] = "prefer"
+
+        if not "kwargs" in self.config or not self.config["kwargs"]:
+            self.config["kwargs"] = {}
+
+        if not "auto_commit" in self.config["kwargs"]:
+            self.config["kwargs"]["auto_commit"] = True
+
+        # Connection pooling defaults
+        if not "maxconnections" in self.config or not self.config["maxconnections"]:
+            self.config["maxconnections"] = 5
+
+        if not "pool_kwargs" in self.config or not self.config["pool_kwargs"]:
+            self.config["pool_kwargs"] = {}
+
+        connStr = (
+            f"postgresql://{self.config['username']}:{self.config['password']}@{self.config['hostname']}:{self.config['port']}"
+            f"/{self.config['database']}?connect_timeout={self.connectionTimeout}&application_name={self.name}"
+            f"&sslmode={self.config['ssl']}"
+        )
+        self.asyncPool = AsyncConnectionPool(
+            connStr,
+            open=False,
+            min_size=2,
+            max_size=self.config["maxconnections"],
+            max_lifetime=20 * 60,
+            max_idle=400,
+            timeout=self.connectionTimeout,
+            reconnect_timeout=0,
+            num_workers=4,
+            connection_class=PgAsyncConnectionType,
+            kwargs={
+                "autocommit": True,
+            },
+            **self.config["pool_kwargs"],
+        )
+
+    async def openAsync(self) -> None:
+        await self.asyncPool.open(wait=True, timeout=self.connectionTimeout)
+
+    async def newConnection(
+        self,
+    ) -> tuple[PgAsyncConnectionType, PgAsyncCursorType] | None:
+        timer = self.timer.get()
+        assert self.asyncPool, "Async pool is not initialized"
+
+        # Create dummy timer
+        if timer is None:
+            timer = Timer("db")
+            self.timer.set(timer)
+
+        # Log
+        self.logger.debug("Getting connection from the pool")
+
+        # Get connection from the pool
+        tries = 0
+        while not self.shutdownRequested.is_set():
+            connection = None
+            try:
+                connection = await self.asyncPool.getconn(
+                    timeout=self.connectionTimeout
+                )
+                cursor = connection.cursor(row_factory=PgDictRowFactory)
+
+                # Lets do some socket magic
+                self.fixSocketTimeouts(connection.fileno())
+
+                async with timer.aenter("AsyncPgSQLWithPooling.__aenter__.ping"):
+                    async with connection.transaction():
+                        await cursor.execute("SELECT 1")
+                        await cursor.fetchone()
+
+                return (connection, cursor)
+
+            except Exception as e:
+                if connection:
+                    await connection.close()
+                    await self.asyncPool.putconn(connection)
+
+                self.logger.error(f"Error while getting connection from the pool: {e}")
+                self.shutdownRequested.wait(self.slowDownTimeout)
+                tries += 1
+                if tries >= 3:
+                    break
+                continue
+
+        return None
+
+    async def returnConnection(self, connection: PgAsyncConnectionType) -> None:
+        """Return connection to the pool"""
+        timer = self.timer.get()
+        assert self.asyncPool, "Async pool is not initialized"
+
+        # Create dummy timer
+        if timer is None:
+            timer = Timer("db")
+
+        # Log
+        self.logger.debug("Putting connection back to the pool")
+
+        # Put connection back to the pool
+        await self.asyncPool.putconn(connection)
+
+        # Debug
+        self.logger.debug(self.asyncPool.get_stats())
+        timer.printTimerStats()
+        timer.resetTimers()
+
+    async def __aenter__(
+        self,
+    ) -> tuple[PgAsyncConnectionType | None, PgAsyncCursorType | None]:
+        """Context manager"""
+
+        # Init timer
+        timer = Timer("db")
+        self.timer.set(timer)
+
+        # Lets set the context var so that it is set even if we fail to get connection
+        self.contextAsyncConnection.set(None)
+
+        res = await self.newConnection()
+        if res:
+            self.contextAsyncConnection.set(res)
+            return res
+
+        return (
+            None,
+            None,
+        )
+
+    async def __aexit__(self, exc_type: Any, exc_value: Any, traceback: Any) -> None:
+        """Context manager"""
+
+        testData = self.contextAsyncConnection.get()
+        if testData:
+            await self.returnConnection(testData[0])
+
+        # Reset context
+        self.contextAsyncConnection.set(None)
+        self.timer.set(None)
+
+    def close(self) -> None:
+        """Close connections"""
+
+        if self.shutdownRequested.is_set():
+            return
+
+        self.logger.debug("Closing connection pool")
+
+        # Shutdown
+        self.shutdownRequested.set()
+
+        # Close async pool
+        if hasattr(self, "asyncPool") and self.asyncPool.closed is False:
+            try:
+                loop = asyncio.get_event_loop()
+                if loop.is_running():
+                    loop.create_task(self.asyncPool.close())
+                else:
+                    loop.run_until_complete(self.asyncPool.close())
+
+            except RuntimeError as e:
+                ...  # Ignore, as it is expected
+            except Exception as e:
+                self.logger.debug(f"Error while closing async pool: {e}", exc_info=True)

database_wrapper_pgsql-0.1.28/database_wrapper_pgsql/db_wrapper_pgsql.py

@@ -0,0 +1,556 @@
+import logging
+from typing import Any, AsyncGenerator, overload
+
+from psycopg import Cursor, AsyncCursor, sql
+from psycopg.rows import class_row
+
+from database_wrapper import T, OrderByItem, DBWrapper, DBDataModel
+
+from .connector import (
+    # Sync
+    PgConnectionType,
+    PgCursorType,
+    PgSQL,
+    # Async
+    PgAsyncConnectionType,
+    PgAsyncCursorType,
+    AsyncPgSQLWithPooling,
+)
+
+
+class DBWrapperPgSQL(DBWrapper):
+    """
+    Database wrapper for postgres
+
+    This is meant to be used in async environments. Also remember to call close() when done.
+
+    """
+
+    # Override db instance
+    db: PgSQL | AsyncPgSQLWithPooling
+    dbConn: PgConnectionType | PgAsyncConnectionType | None = None
+
+    #######################
+    ### Class lifecycle ###
+    #######################
+
+    # Meta methods
+    def __init__(
+        self,
+        db: PgSQL | AsyncPgSQLWithPooling,
+        dbConn: PgConnectionType | PgAsyncConnectionType | None = None,
+        logger: logging.Logger | None = None,
+    ):
+        """
+        Initializes a new instance of the DBWrapper class.
+
+        Args:
+            db (MySQL): The MySQL object.
+            logger (logging.Logger, optional): The logger object. Defaults to None.
+        """
+        super().__init__(db, dbConn, logger)
+
+    async def close(self) -> None:
+        if hasattr(self, "dbConn") and self.dbConn and hasattr(self, "db") and self.db:
+            if isinstance(self.db, AsyncPgSQLWithPooling):
+                await self.db.returnConnection(self.dbConn)  # type: ignore
+            self.dbConn = None
+
+    ######################
+    ### Helper methods ###
+    ######################
+
+    def makeIdentifier(self, schema: str | None, name: str) -> sql.Identifier | str:
+        """
+        Creates a SQL identifier object from the given name.
+
+        Args:
+            name (str): The name to create the identifier from.
+
+        Returns:
+            sql.Identifier: The created SQL identifier object.
+        """
+        if schema:
+            return sql.Identifier(schema, name)
+
+        return sql.Identifier(name)
+
+    @overload
+    async def createCursor(self) -> PgCursorType | PgAsyncCursorType: ...
+
+    @overload
+    async def createCursor(
+        self,
+        emptyDataClass: T,
+    ) -> Cursor[T] | AsyncCursor[T]: ...
+
+    async def createCursor(
+        self,
+        emptyDataClass: T | None = None,
+    ) -> Cursor[T] | PgCursorType | AsyncCursor[T] | PgAsyncCursorType:
+        """
+        Creates a new cursor object.
+
+        Args:
+            emptyDataClass (DBDataModel | None, optional): The data model to use for the cursor.
+                Defaults to None.
+
+        Returns:
+            PgAsyncCursorType | AsyncCursor[DBDataModel]: The created cursor object.
+        """
+        assert self.db is not None, "Database connection is not set"
+
+        # First we need connection
+        if self.dbConn is None:
+            if isinstance(self.db, PgSQL):
+                self.dbConn = self.db.connection
+
+            if isinstance(self.db, AsyncPgSQLWithPooling):
+                status = await self.db.newConnection()
+                if not status:
+                    raise Exception("Failed to create new connection")
+
+                (pgConn, _pgCur) = status
+                self.dbConn = pgConn
+
+        # Lets make sure we have a connection
+        if self.dbConn is None:
+            raise Exception("Failed to get connection")
+
+        if emptyDataClass is None:
+            return self.dbConn.cursor()
+
+        return self.dbConn.cursor(row_factory=class_row(emptyDataClass.__class__))
+
+    def logQuery(
+        self,
+        cursor: AsyncCursor[Any] | Cursor[Any],
+        query: sql.SQL | sql.Composed,
+        params: tuple[Any, ...],
+    ) -> None:
+        """
+        Logs the given query and parameters.
+
+        Args:
+            cursor (Any): The database cursor.
+            query (Any): The query to log.
+            params (tuple[Any, ...]): The parameters to log.
+        """
+        queryString = query.as_string(self.dbConn)
+        self.logger.debug(f"Query: {queryString}")
+
+    #####################
+    ### Query methods ###
+    #####################
+
+    def filterQuery(
+        self,
+        schemaName: str | None,
+        tableName: str,
+    ) -> sql.SQL | sql.Composed | str:
+        """
+        Creates a SQL query to filter data from the given table.
+
+        Args:
+            schemaName (str): The name of the schema to filter data from.
+            tableName (str): The name of the table to filter data from.
+
+        Returns:
+            sql.SQL | sql.Composed: The created SQL query object.
+        """
+        return sql.SQL("SELECT * FROM {table}").format(
+            table=self.makeIdentifier(schemaName, tableName)
+        )
+
+    def limitQuery(self, offset: int = 0, limit: int = 100) -> sql.Composed | sql.SQL:
+        return sql.SQL("LIMIT {} OFFSET {}").format(limit, offset)
+
+    # Action methods
+    async def getOne(
+        self,
+        emptyDataClass: T,
+        customQuery: sql.SQL | sql.Composed | str | None = None,
+    ) -> T | None:
+        """
+        Retrieves a single record from the database.
+
+        Args:
+            emptyDataClass (T): The data model to use for the query.
+            customQuery (sql.SQL | sql.Composed | str | None, optional): The custom query to use.
+                Defaults to None.
+
+        Returns:
+            T | None: The result of the query.
+        """
+        # Query
+        _query = (
+            customQuery
+            or emptyDataClass.queryBase()
+            or self.filterQuery(emptyDataClass.schemaName, emptyDataClass.tableName)
+        )
+        idKey = emptyDataClass.idKey
+        idValue = emptyDataClass.id
+        if not idKey:
+            raise ValueError("Id key is not set")
+        if not idValue:
+            raise ValueError("Id value is not set")
+
+        # Create a SQL object for the query and format it
+        querySql = sql.SQL("{query} WHERE {idkey} = %s").format(
+            query=_query, idkey=self.makeIdentifier(emptyDataClass.tableAlias, idKey)
+        )
+
+        # Create a new cursor
+        newCursor = await self.createCursor(emptyDataClass)
+
+        # Log
+        self.logQuery(newCursor, querySql, (idValue,))
+
+        # Load data
+        try:
+            if isinstance(newCursor, AsyncCursor):
+                await newCursor.execute(querySql, (idValue,))
+                dbData = await newCursor.fetchone()
+            else:
+                newCursor.execute(querySql, (idValue,))
+                dbData = newCursor.fetchone()
+
+            return dbData
+
+        finally:
+            # Close the cursor
+            if isinstance(newCursor, AsyncCursor):
+                await newCursor.close()
+            else:
+                newCursor.close()
+
+    async def getByKey(
+        self,
+        emptyDataClass: T,
+        idKey: str,
+        idValue: Any,
+        customQuery: sql.SQL | sql.Composed | str | None = None,
+    ) -> T | None:
+        """
+        Retrieves a single record from the database using the given key.
+
+        Args:
+            emptyDataClass (T): The data model to use for the query.
+            idKey (str): The name of the key to use for the query.
+            idValue (Any): The value of the key to use for the query.
+            customQuery (sql.SQL | sql.Composed | str | None, optional): The custom query to use.
+                Defaults to None.
+
+        Returns:
+            T | None: The result of the query.
+        """
+        # Query
+        _query = (
+            customQuery
+            or emptyDataClass.queryBase()
+            or self.filterQuery(emptyDataClass.schemaName, emptyDataClass.tableName)
+        )
+
+        # Create a SQL object for the query and format it
+        querySql = sql.SQL("{} WHERE {} = %s").format(
+            _query, self.makeIdentifier(emptyDataClass.tableAlias, idKey)
+        )
+
+        # Create a new cursor
+        newCursor = await self.createCursor(emptyDataClass)
+
+        # Log
+        self.logQuery(newCursor, querySql, (idValue,))
+
+        # Load data
+        try:
+            if isinstance(newCursor, AsyncCursor):
+                await newCursor.execute(querySql, (idValue,))
+                dbData = await newCursor.fetchone()
+            else:
+                newCursor.execute(querySql, (idValue,))
+                dbData = newCursor.fetchone()
+
+            return dbData
+
+        finally:
+            # Ensure the cursor is closed after the generator is exhausted or an error occurs
+            if isinstance(newCursor, AsyncCursor):
+                await newCursor.close()
+            else:
+                newCursor.close()
+
+    async def getAll(
+        self,
+        emptyDataClass: T,
+        idKey: str | None = None,
+        idValue: Any | None = None,
+        orderBy: OrderByItem | None = None,
+        offset: int = 0,
+        limit: int = 100,
+        customQuery: sql.SQL | sql.Composed | str | None = None,
+    ) -> AsyncGenerator[T, None]:
+        """
+        Retrieves all records from the database.
+
+        Args:
+            emptyDataClass (T): The data model to use for the query.
+            idKey (str | None, optional): The name of the key to use for filtering. Defaults to None.
+            idValue (Any | None, optional): The value of the key to use for filtering. Defaults to None.
+            orderBy (OrderByItem | None, optional): The order by item to use for sorting. Defaults to None.
+            offset (int, optional): The number of results to skip. Defaults to 0.
+            limit (int, optional): The maximum number of results to return. Defaults to 100.
+            customQuery (sql.SQL | sql.Composed | str | None, optional): The custom query to use. Defaults to None.
+
+        Returns:
+            AsyncGenerator[T, None]: The result of the query.
+        """
+        # Query
+        _query = (
+            customQuery
+            or emptyDataClass.queryBase()
+            or self.filterQuery(emptyDataClass.schemaName, emptyDataClass.tableName)
+        )
+        _params: tuple[Any, ...] = ()
+
+        # Filter
+        if idKey and idValue:
+            _query = sql.SQL("{} WHERE {} = %s").format(
+                _query, self.makeIdentifier(emptyDataClass.tableAlias, idKey)
+            )
+            _params = (idValue,)
+
+        # Limits
+        _order: sql.Composable = sql.SQL("")
+        _limit: sql.Composable = sql.SQL("")
+
+        if orderBy:
+            orderList = [
+                f"{item[0]} {item[1] if len(item) > 1 and item[1] != None else 'ASC'}"
+                for item in orderBy
+            ]
+            _order = sql.SQL("ORDER BY %s" % ", ".join(orderList))  # type: ignore
+        if offset or limit:
+            _limit = sql.SQL("{}").format(self.limitQuery(offset, limit))
+
+        # Create a SQL object for the query and format it
+        querySql = sql.SQL("{query} {order} {limit}").format(
+            query=_query, order=_order, limit=_limit
+        )
+
+        # Create a new cursor
+        newCursor = await self.createCursor(emptyDataClass)
+
+        # Log
+        self.logQuery(newCursor, querySql, _params)
+
+        # Load data
+        try:
+            if isinstance(newCursor, AsyncCursor):
+                # Execute the query
+                await newCursor.execute(querySql, _params)
+
+                # Instead of fetchall(), we'll use a generator to yield results one by one
+                while True:
+                    row = await newCursor.fetchone()
+                    if row is None:
+                        break
+                    yield row
+            else:
+                newCursor.execute(querySql, _params)
+                while True:
+                    row = newCursor.fetchone()
+                    if row is None:
+                        break
+                    yield row
+        finally:
+            # Ensure the cursor is closed after the generator is exhausted or an error occurs
+            if isinstance(newCursor, AsyncCursor):
+                await newCursor.close()
+            else:
+                newCursor.close()
+
+    async def getFiltered(
+        self,
+        emptyDataClass: T,
+        filter: dict[str, Any],
+        orderBy: OrderByItem | None = None,
+        offset: int = 0,
+        limit: int = 100,
+        customQuery: sql.SQL | sql.Composed | str | None = None,
+    ) -> AsyncGenerator[T, None]:
+        # Filter
+        _query = (
+            customQuery
+            or emptyDataClass.queryBase()
+            or self.filterQuery(emptyDataClass.schemaName, emptyDataClass.tableName)
+        )
+        (_filter, _params) = self.createFilter(filter)
+        _filter = sql.SQL(_filter)  # type: ignore
+
+        # Limits
+        _order: sql.Composable = sql.SQL("")
+        _limit: sql.Composable = sql.SQL("")
+
+        if orderBy:
+            orderList = [
+                f"{item[0]} {item[1] if len(item) > 1 and item[1] != None else 'ASC'}"
+                for item in orderBy
+            ]
+            _order = sql.SQL("ORDER BY %s" % ", ".join(orderList))  # type: ignore
+        if offset or limit:
+            _limit = sql.SQL("{}").format(self.limitQuery(offset, limit))
+
+        # Create a SQL object for the query and format it
+        querySql = sql.SQL("{query} {filter} {order} {limit}").format(
+            query=_query, filter=_filter, order=_order, limit=_limit
+        )
+
+        # Create a new cursor
+        newCursor = await self.createCursor(emptyDataClass)
+
+        # Log
+        self.logQuery(newCursor, querySql, _params)
+
+        # Load data
+        try:
+            if isinstance(newCursor, AsyncCursor):
+                # Execute the query
+                await newCursor.execute(querySql, _params)
+
+                # Instead of fetchall(), we'll use a generator to yield results one by one
+                while True:
+                    row = await newCursor.fetchone()
+                    if row is None:
+                        break
+                    yield row
+            else:
+                newCursor.execute(querySql, _params)
+                while True:
+                    row = newCursor.fetchone()
+                    if row is None:
+                        break
+                    yield row
+        finally:
+            # Ensure the cursor is closed after the generator is exhausted or an error occurs
+            if isinstance(newCursor, AsyncCursor):
+                await newCursor.close()
+            else:
+                newCursor.close()
+
+    async def _store(
+        self,
+        emptyDataClass: DBDataModel,
+        schemaName: str | None,
+        tableName: str,
+        storeData: dict[str, Any],
+        idKey: str,
+    ) -> tuple[int, int]:
+        keys = storeData.keys()
+        values = list(storeData.values())
+
+        tableIdentifier = self.makeIdentifier(schemaName, tableName)
+        returnKey = self.makeIdentifier(emptyDataClass.tableAlias, idKey)
+
+        insertQuery = sql.SQL(
+            "INSERT INTO {table} ({columns}) VALUES ({values}) RETURNING {id_key}"
+        ).format(
+            table=tableIdentifier,
+            columns=sql.SQL(", ").join(map(sql.Identifier, keys)),
+            values=sql.SQL(", ").join(sql.Placeholder() * len(values)),
+            id_key=returnKey,
+        )
+
+        # Create a new cursor
+        newCursor = await self.createCursor(emptyDataClass)
+
+        # Log
+        self.logQuery(newCursor, insertQuery, tuple(values))
+
+        # Insert
+        if isinstance(newCursor, AsyncCursor):
+            await newCursor.execute(insertQuery, tuple(values))
+            affectedRows = newCursor.rowcount
+            result = await newCursor.fetchone()
+        else:
+            newCursor.execute(insertQuery, tuple(values))
+            affectedRows = newCursor.rowcount
+            result = newCursor.fetchone()
+
+        return (
+            result.id if result and hasattr(result, "id") else 0,
+            affectedRows,
+        )
+
+    async def _update(
+        self,
+        emptyDataClass: DBDataModel,
+        schemaName: str | None,
+        tableName: str,
+        updateData: dict[str, Any],
+        updateId: tuple[str, Any],
+    ) -> int:
+        (idKey, idValue) = updateId
+        keys = updateData.keys()
+        values = list(updateData.values())
+        values.append(idValue)
+
+        set_clause = sql.SQL(", ").join(
+            sql.Identifier(key) + sql.SQL(" = %s") for key in keys
+        )
+
+        tableIdentifier = self.makeIdentifier(schemaName, tableName)
+        updateKey = self.makeIdentifier(emptyDataClass.tableAlias, idKey)
+        updateQuery = sql.SQL(
+            "UPDATE {table} SET {set_clause} WHERE {id_key} = %s"
+        ).format(
+            table=tableIdentifier,
+            set_clause=set_clause,
+            id_key=updateKey,
+        )
+
+        # Create a new cursor
+        newCursor = await self.createCursor(emptyDataClass)
+
+        # Log
+        self.logQuery(newCursor, updateQuery, tuple(values))
+
+        # Update
+        if isinstance(newCursor, AsyncCursor):
+            await newCursor.execute(updateQuery, tuple(values))
+        else:
+            newCursor.execute(updateQuery, tuple(values))
+        affectedRows = newCursor.rowcount
+
+        return affectedRows
+
+    async def _delete(
+        self,
+        emptyDataClass: DBDataModel,
+        schemaName: str | None,
+        tableName: str,
+        deleteId: tuple[str, Any],
+    ) -> int:
+        (idKey, idValue) = deleteId
+
+        tableIdentifier = self.makeIdentifier(schemaName, tableName)
+        deleteKey = self.makeIdentifier(emptyDataClass.tableAlias, idKey)
+
+        delete_query = sql.SQL("DELETE FROM {table} WHERE {id_key} = %s").format(
+            table=tableIdentifier, id_key=deleteKey
+        )
+
+        # Create a new cursor
+        newCursor = await self.createCursor(emptyDataClass)
+
+        # Log
+        self.logQuery(newCursor, delete_query, (idValue,))
+
+        # Delete
+        if isinstance(newCursor, AsyncCursor):
+            await newCursor.execute(delete_query, (idValue,))
+        else:
+            newCursor.execute(delete_query, (idValue,))
+        affected_rows = newCursor.rowcount
+
+        return affected_rows

database_wrapper_pgsql-0.1.28/database_wrapper_pgsql.egg-info/PKG-INFO

@@ -0,0 +1,93 @@
+Metadata-Version: 2.1
+Name: database_wrapper_pgsql
+Version: 0.1.28
+Summary: database_wrapper for PostgreSQL database
+Author-email: Gints Murans <gm@gm.lv>
+License: GNU General Public License v3.0 (GPL-3.0)
+Project-URL: Homepage, https://github.com/gintsmurans/py_database_wrapper
+Project-URL: Documentation, https://github.com/gintsmurans/py_database_wrapper
+Project-URL: Changes, https://github.com/gintsmurans/py_database_wrapper
+Project-URL: Code, https://github.com/gintsmurans/py_database_wrapper
+Project-URL: Issue Tracker, https://github.com/gintsmurans/py_database_wrapper/issues
+Project-URL: Download, https://pypi.org/project/database_wrapper/
+Keywords: database,wrapper,python,postgresql,pgsql
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Database
+Classifier: Topic :: Database :: Front-Ends
+Classifier: Topic :: Software Development
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: database_wrapper==0.1.28
+Requires-Dist: psycopg[binary]>=3.2.0
+Requires-Dist: psycopg[pool]>=3.2.0
+
+# database_wrapper
+
+_Part of the `database_wrapper` package._
+
+This python package is a database wrapper for [PostgreSQL](https://www.postgresql.org/) (also called pgsql) databases.
+
+## Installation
+
+```bash
+pip install database_wrapper[pgsql]
+```
+
+## Usage
+
+```python
+from database_wrapper_pgsql import AsyncPgSQLWithPooling, DBWrapperPgSQL
+
+db = MySQL({
+    "hostname": "localhost",
+    "port": 3306,
+    "username": "root",
+    "password": "your_password",
+    "database": "my_database"
+})
+db.open()
+dbWrapper = DBWrapperMySQL(db=db)
+
+# Simple query
+aModel = MyModel()
+res = await dbWrapper.getByKey(
+    aModel,
+    "id",
+    3005,
+)
+if res:
+    print(f"getByKey: {res.toDict()}")
+else:
+    print("No results")
+
+# Raw query
+res = await dbWrapper.getAll(
+    aModel,
+    """
+        SELECT t1.*, t2.name AS other_name
+        FROM my_table AS t1
+        LEFT JOIN other_table AS t2 ON t1.other_id = t2.id
+    """
+)
+async for record in res:
+    print(f"getAll: {record.toDict()}")
+else:
+    print("No results")
+
+db.close()
+```

database_wrapper_pgsql-0.1.28/database_wrapper_pgsql.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+README.md
+pyproject.toml
+database_wrapper_pgsql/__init__.py
+database_wrapper_pgsql/connector.py
+database_wrapper_pgsql/db_wrapper_pgsql.py
+database_wrapper_pgsql/py.typed
+database_wrapper_pgsql.egg-info/PKG-INFO
+database_wrapper_pgsql.egg-info/SOURCES.txt
+database_wrapper_pgsql.egg-info/dependency_links.txt
+database_wrapper_pgsql.egg-info/requires.txt
+database_wrapper_pgsql.egg-info/top_level.txt

database_wrapper_pgsql-0.1.28/database_wrapper_pgsql.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

database_wrapper_pgsql-0.1.28/database_wrapper_pgsql.egg-info/requires.txt

@@ -0,0 +1,3 @@
+database_wrapper==0.1.28
+psycopg[binary]>=3.2.0
+psycopg[pool]>=3.2.0

database_wrapper_pgsql-0.1.28/database_wrapper_pgsql.egg-info/top_level.txt

@@ -0,0 +1 @@
+database_wrapper_pgsql

database_wrapper_pgsql-0.1.28/pyproject.toml

@@ -0,0 +1,52 @@
+[build-system]
+requires = ["setuptools >= 61.0.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "database_wrapper_pgsql"
+version = "0.1.28"
+description = "database_wrapper for PostgreSQL database"
+readme = "README.md"
+requires-python = ">=3.8"
+license = {text = "GNU General Public License v3.0 (GPL-3.0)"}
+authors = [
+    {name = "Gints Murans", email = "gm@gm.lv"}
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: GNU General Public License v3 (GPLv3)",
+    "Operating System :: MacOS :: MacOS X",
+    "Operating System :: Microsoft :: Windows",
+    "Operating System :: POSIX",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: Implementation :: CPython",
+    "Programming Language :: Python :: Implementation :: PyPy",
+    "Topic :: Database",
+    "Topic :: Database :: Front-Ends",
+    "Topic :: Software Development",
+    "Topic :: Software Development :: Libraries :: Python Modules"
+]
+keywords = ["database", "wrapper", "python", "postgresql", "pgsql"]
+dependencies = [
+    "database_wrapper == 0.1.28",
+    "psycopg[binary] >= 3.2.0",
+    "psycopg[pool] >= 3.2.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/gintsmurans/py_database_wrapper"
+Documentation = "https://github.com/gintsmurans/py_database_wrapper"
+Changes = "https://github.com/gintsmurans/py_database_wrapper"
+Code = "https://github.com/gintsmurans/py_database_wrapper"
+"Issue Tracker" = "https://github.com/gintsmurans/py_database_wrapper/issues"
+Download = "https://pypi.org/project/database_wrapper/"
+
+[tool.setuptools.package-data]
+database_wrapper_pgsql = ["py.typed"]

database_wrapper_pgsql-0.1.28/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+