database-wrapper 0.1.44__py3-none-any.whl → 0.1.72__py3-none-any.whl

database_wrapper/db_wrapper.py

@@ -10,48 +10,6 @@ class DBWrapper(DBWrapperMixin):
     Database wrapper class.
     """
 
-    #######################
-    ### Class lifecycle ###
-    #######################
-
-    def close(self) -> None:
-        """
-        Close resources. Usually you should not close connections here,
-        just remove references.
-        """
-
-        raise NotImplementedError("Method not implemented")
-
-    ######################
-    ### Helper methods ###
-    ######################
-
-    @overload
-    def createCursor(self) -> Any: ...
-
-    @overload
-    def createCursor(self, emptyDataClass: DBDataModel) -> Any: ...
-
-    def createCursor(self, emptyDataClass: DBDataModel | None = None) -> Any:
-        """
-        Creates a new cursor object.
-
-        Args:
-            emptyDataClass (DataModelType | None, optional): The data model to use for the cursor. Defaults to None.
-
-        Returns:
-            The created cursor object.
-        """
-        if self.db is None and self.dbConn is None:
-            raise ValueError(
-                "Database object and connection is not properly initialized"
-            )
-
-        if self.dbConn is not None:
-            return self.dbConn.cursor()
-
-        return self.db.cursor
-
     #####################
     ### Query methods ###
     #####################
@@ -86,6 +44,8 @@ class DBWrapper(DBWrapperMixin):
         )
         for row in res:
             return row
+        else:
+            return None
 
     def getByKey(
         self,
@@ -112,6 +72,8 @@ class DBWrapper(DBWrapperMixin):
         )
         for row in res:
             return row
+        else:
+            return None
 
     def getAll(
         self,
@@ -158,28 +120,19 @@ class DBWrapper(DBWrapperMixin):
         # Create a SQL object for the query and format it
         querySql = self._formatFilterQuery(_query, _filter, _order, _limit)
 
-        # Create a new cursor
-        newCursor = self.createCursor(emptyDataClass)
-
         # Log
-        self.logQuery(newCursor, querySql, _params)
-
-        # Load data
-        try:
-            # Execute the query
-            newCursor.execute(querySql, _params)
+        self.logQuery(self.dbCursor, querySql, _params)
 
-            # Instead of fetchall(), we'll use a generator to yield results one by one
-            while True:
-                row = newCursor.fetchone()
-                if row is None:
-                    break
+        # Execute the query
+        self.dbCursor.execute(querySql, _params)
 
-                yield self.turnDataIntoModel(emptyDataClass, row)
+        # Instead of fetchall(), we'll use a generator to yield results one by one
+        while True:
+            row = self.dbCursor.fetchone()
+            if row is None:
+                break
 
-        finally:
-            # Ensure the cursor is closed after the generator is exhausted or an error occurs
-            newCursor.close()
+            yield self.turnDataIntoModel(emptyDataClass.__class__, row)
 
     def getFiltered(
         self,
@@ -205,30 +158,21 @@ class DBWrapper(DBWrapperMixin):
         # Create SQL query
         querySql = self._formatFilterQuery(_query, _filter, _order, _limit)
 
-        # Create a new cursor
-        newCursor = self.createCursor(emptyDataClass)
-
         # Log
-        self.logQuery(newCursor, querySql, _params)
-
-        # Load data
-        try:
-            # Execute the query
-            newCursor.execute(querySql, _params)
+        self.logQuery(self.dbCursor, querySql, _params)
 
-            # Instead of fetchall(), we'll use a generator to yield results one by one
-            while True:
-                row = newCursor.fetchone()
-                if row is None:
-                    break
+        # Execute the query
+        self.dbCursor.execute(querySql, _params)
 
-                yield self.turnDataIntoModel(emptyDataClass, row)
+        # Instead of fetchall(), we'll use a generator to yield results one by one
+        while True:
+            row = self.dbCursor.fetchone()
+            if row is None:
+                break
 
-        finally:
-            # Ensure the cursor is closed after the generator is exhausted or an error occurs
-            newCursor.close()
+            yield self.turnDataIntoModel(emptyDataClass.__class__, row)
 
-    def _store(
+    def _insert(
         self,
         emptyDataClass: DBDataModel,
         schemaName: str | None,
@@ -254,35 +198,27 @@ class DBWrapper(DBWrapperMixin):
         returnKey = self.makeIdentifier(emptyDataClass.tableAlias, idKey)
         insertQuery = self._formatInsertQuery(tableIdentifier, storeData, returnKey)
 
-        # Create a new cursor
-        newCursor = self.createCursor(emptyDataClass)
-
         # Log
-        self.logQuery(newCursor, insertQuery, tuple(values))
+        self.logQuery(self.dbCursor, insertQuery, tuple(values))
 
         # Insert
-        try:
-            newCursor.execute(insertQuery, tuple(values))
-            affectedRows = newCursor.rowcount
-            result = newCursor.fetchone()
-
-            return (
-                result.id if result and hasattr(result, "id") else 0,
-                affectedRows,
-            )
+        self.dbCursor.execute(insertQuery, tuple(values))
+        affectedRows = self.dbCursor.rowcount
+        result = self.dbCursor.fetchone()
 
-        finally:
-            # Close the cursor
-            newCursor.close()
+        return (
+            result.id if result and hasattr(result, "id") else 0,
+            affectedRows,
+        )
 
     @overload
-    def store(self, records: DataModelType) -> tuple[int, int]:  # type: ignore
+    def insert(self, records: DataModelType) -> tuple[int, int]:  # type: ignore
         ...
 
     @overload
-    def store(self, records: list[DataModelType]) -> list[tuple[int, int]]: ...
+    def insert(self, records: list[DataModelType]) -> list[tuple[int, int]]: ...
 
-    def store(
+    def insert(
         self,
         records: DataModelType | list[DataModelType],
     ) -> tuple[int, int] | list[tuple[int, int]]:
@@ -310,7 +246,7 @@ class DBWrapper(DBWrapperMixin):
             if not storeIdKey or not storeData:
                 continue
 
-            res = self._store(
+            res = self._insert(
                 row,
                 row.schemaName,
                 row.tableName,
@@ -356,22 +292,14 @@ class DBWrapper(DBWrapperMixin):
         updateKey = self.makeIdentifier(emptyDataClass.tableAlias, idKey)
         updateQuery = self._formatUpdateQuery(tableIdentifier, updateKey, updateData)
 
-        # Create a new cursor
-        newCursor = self.createCursor(emptyDataClass)
-
         # Log
-        self.logQuery(newCursor, updateQuery, tuple(values))
+        self.logQuery(self.dbCursor, updateQuery, tuple(values))
 
         # Update
-        try:
-            newCursor.execute(updateQuery, tuple(values))
-            affectedRows = newCursor.rowcount
+        self.dbCursor.execute(updateQuery, tuple(values))
+        affectedRows = self.dbCursor.rowcount
 
-            return affectedRows
-
-        finally:
-            # Close the cursor
-            newCursor.close()
+        return affectedRows
 
     @overload
     def update(self, records: DataModelType) -> int:  # type: ignore
@@ -470,22 +398,14 @@ class DBWrapper(DBWrapperMixin):
         deleteKey = self.makeIdentifier(emptyDataClass.tableAlias, idKey)
         delete_query = self._formatDeleteQuery(tableIdentifier, deleteKey)
 
-        # Create a new cursor
-        newCursor = self.createCursor(emptyDataClass)
-
         # Log
-        self.logQuery(newCursor, delete_query, (idValue,))
+        self.logQuery(self.dbCursor, delete_query, (idValue,))
 
         # Delete
-        try:
-            newCursor.execute(delete_query, (idValue,))
-            affected_rows = newCursor.rowcount
-
-            return affected_rows
+        self.dbCursor.execute(delete_query, (idValue,))
+        affected_rows = self.dbCursor.rowcount
 
-        finally:
-            # Close the cursor
-            newCursor.close()
+        return affected_rows
 
     @overload
     def delete(self, records: DataModelType) -> int:  # type: ignore

database_wrapper/db_wrapper_async.py

@@ -9,43 +9,9 @@ class DBWrapperAsync(DBWrapperMixin):
     """
     Async Database wrapper class.
 
-    Note: In async environment we cannot call close method from __del__ method.
-        It means you will need to call close method manually from async context.
+    This class is meant to be used in async environments.
     """
 
-    #######################
-    ### Class lifecycle ###
-    #######################
-
-    async def close(self) -> None:
-        """
-        Async method for closing async resources.
-        """
-        raise NotImplementedError("Method not implemented")
-
-    ######################
-    ### Helper methods ###
-    ######################
-
-    @overload
-    async def createCursor(self) -> Any: ...
-
-    @overload
-    async def createCursor(self, emptyDataClass: DBDataModel) -> Any: ...
-
-    async def createCursor(self, emptyDataClass: DBDataModel | None = None) -> Any:
-        """
-        Creates a new cursor object.
-
-        Args:
-            emptyDataClass (T | None, optional): The data model to use for the cursor. Defaults to None.
-
-        Returns:
-            The created cursor object.
-        """
-        assert self.db is not None, "Database connection is not set"
-        return self.db.cursor
-
     #####################
     ### Query methods ###
     #####################
@@ -76,10 +42,16 @@ class DBWrapperAsync(DBWrapperMixin):
 
         # Get the record
         res = self.getAll(
-            emptyDataClass, idKey, idValue, limit=1, customQuery=customQuery
+            emptyDataClass,
+            idKey,
+            idValue,
+            limit=1,
+            customQuery=customQuery,
         )
         async for row in res:
             return row
+        else:
+            return None
 
     async def getByKey(
         self,
@@ -102,10 +74,16 @@ class DBWrapperAsync(DBWrapperMixin):
         """
         # Get the record
         res = self.getAll(
-            emptyDataClass, idKey, idValue, limit=1, customQuery=customQuery
+            emptyDataClass,
+            idKey,
+            idValue,
+            limit=1,
+            customQuery=customQuery,
         )
         async for row in res:
             return row
+        else:
+            return None
 
     async def getAll(
         self,
@@ -152,28 +130,19 @@ class DBWrapperAsync(DBWrapperMixin):
         # Create a SQL object for the query and format it
         querySql = self._formatFilterQuery(_query, _filter, _order, _limit)
 
-        # Create a new cursor
-        newCursor = await self.createCursor(emptyDataClass)
-
         # Log
-        self.logQuery(newCursor, querySql, _params)
-
-        # Load data
-        try:
-            # Execute the query
-            await newCursor.execute(querySql, _params)
+        self.logQuery(self.dbCursor, 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
+        # Execute the query
+        await self.dbCursor.execute(querySql, _params)
 
-                yield self.turnDataIntoModel(emptyDataClass, row)
+        # Instead of fetchall(), we'll use a generator to yield results one by one
+        while True:
+            row = await self.dbCursor.fetchone()
+            if row is None:
+                break
 
-        finally:
-            # Ensure the cursor is closed after the generator is exhausted or an error occurs
-            await newCursor.close()
+            yield self.turnDataIntoModel(emptyDataClass.__class__, row)
 
     async def getFiltered(
         self,
@@ -199,30 +168,21 @@ class DBWrapperAsync(DBWrapperMixin):
         # Create SQL query
         querySql = self._formatFilterQuery(_query, _filter, _order, _limit)
 
-        # Create a new cursor
-        newCursor = await self.createCursor(emptyDataClass)
-
         # Log
-        self.logQuery(newCursor, querySql, _params)
-
-        # Load data
-        try:
-            # Execute the query
-            await newCursor.execute(querySql, _params)
+        self.logQuery(self.dbCursor, 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
+        # Execute the query
+        await self.dbCursor.execute(querySql, _params)
 
-                yield self.turnDataIntoModel(emptyDataClass, row)
+        # Instead of fetchall(), we'll use a generator to yield results one by one
+        while True:
+            row = await self.dbCursor.fetchone()
+            if row is None:
+                break
 
-        finally:
-            # Ensure the cursor is closed after the generator is exhausted or an error occurs
-            await newCursor.close()
+            yield self.turnDataIntoModel(emptyDataClass.__class__, row)
 
-    async def _store(
+    async def _insert(
         self,
         emptyDataClass: DBDataModel,
         schemaName: str | None,
@@ -248,35 +208,27 @@ class DBWrapperAsync(DBWrapperMixin):
         returnKey = self.makeIdentifier(emptyDataClass.tableAlias, idKey)
         insertQuery = self._formatInsertQuery(tableIdentifier, storeData, returnKey)
 
-        # Create a new cursor
-        newCursor = await self.createCursor(emptyDataClass)
-
         # Log
-        self.logQuery(newCursor, insertQuery, tuple(values))
+        self.logQuery(self.dbCursor, insertQuery, tuple(values))
 
         # Insert
-        try:
-            await newCursor.execute(insertQuery, tuple(values))
-            affectedRows = newCursor.rowcount
-            result = await newCursor.fetchone()
-
-            return (
-                result.id if result and hasattr(result, "id") else 0,
-                affectedRows,
-            )
+        await self.dbCursor.execute(insertQuery, tuple(values))
+        affectedRows = self.dbCursor.rowcount
+        result = await self.dbCursor.fetchone()
 
-        finally:
-            # Close the cursor
-            await newCursor.close()
+        return (
+            result.id if result and hasattr(result, "id") else 0,
+            affectedRows,
+        )
 
     @overload
-    async def store(self, records: DataModelType) -> tuple[int, int]:  # type: ignore
+    async def insert(self, records: DataModelType) -> tuple[int, int]:  # type: ignore
         ...
 
     @overload
-    async def store(self, records: list[DataModelType]) -> list[tuple[int, int]]: ...
+    async def insert(self, records: list[DataModelType]) -> list[tuple[int, int]]: ...
 
-    async def store(
+    async def insert(
         self,
         records: DataModelType | list[DataModelType],
     ) -> tuple[int, int] | list[tuple[int, int]]:
@@ -304,7 +256,7 @@ class DBWrapperAsync(DBWrapperMixin):
             if not storeIdKey or not storeData:
                 continue
 
-            res = await self._store(
+            res = await self._insert(
                 row,
                 row.schemaName,
                 row.tableName,
@@ -350,22 +302,14 @@ class DBWrapperAsync(DBWrapperMixin):
         updateKey = self.makeIdentifier(emptyDataClass.tableAlias, idKey)
         updateQuery = self._formatUpdateQuery(tableIdentifier, updateKey, updateData)
 
-        # Create a new cursor
-        newCursor = await self.createCursor(emptyDataClass)
-
         # Log
-        self.logQuery(newCursor, updateQuery, tuple(values))
+        self.logQuery(self.dbCursor, updateQuery, tuple(values))
 
         # Update
-        try:
-            await newCursor.execute(updateQuery, tuple(values))
-            affectedRows = newCursor.rowcount
+        await self.dbCursor.execute(updateQuery, tuple(values))
+        affectedRows = self.dbCursor.rowcount
 
-            return affectedRows
-
-        finally:
-            # Close the cursor
-            await newCursor.close()
+        return affectedRows
 
     @overload
     async def update(self, records: DataModelType) -> int:  # type: ignore
@@ -466,22 +410,14 @@ class DBWrapperAsync(DBWrapperMixin):
         deleteKey = self.makeIdentifier(emptyDataClass.tableAlias, idKey)
         delete_query = self._formatDeleteQuery(tableIdentifier, deleteKey)
 
-        # Create a new cursor
-        newCursor = await self.createCursor(emptyDataClass)
-
         # Log
-        self.logQuery(newCursor, delete_query, (idValue,))
+        self.logQuery(self.dbCursor, delete_query, (idValue,))
 
         # Delete
-        try:
-            await newCursor.execute(delete_query, (idValue,))
-            affected_rows = newCursor.rowcount
-
-            return affected_rows
+        await self.dbCursor.execute(delete_query, (idValue,))
+        affected_rows = self.dbCursor.rowcount
 
-        finally:
-            # Close the cursor
-            await newCursor.close()
+        return affected_rows
 
     @overload
     async def delete(self, records: DataModelType) -> int:  # type: ignore

database_wrapper/db_wrapper_mixin.py

@@ -1,6 +1,6 @@
 import logging
 
-from typing import cast, Any
+from typing import Type, cast, Any
 
 from .common import OrderByItem, NoParam, DataModelType
 
@@ -10,8 +10,7 @@ class DBWrapperMixin:
     Mixin class for the DBWrapper class to provide methods that can be
     used by both sync and async versions of the DBWrapper class.
 
-    :property db: Database backend object.
-    :property dbConn: Database connection object.
+    :property dbCursor: Database cursor object.
     :property logger: Logger object
     """
 
@@ -19,16 +18,9 @@ class DBWrapperMixin:
     ### Instance properties ###
     ###########################
 
-    # Db backend
-    db: Any
-    """Database backend object"""
-
-    dbConn: Any
+    dbCursor: Any
     """
-    Database connection object.
-
-    Its not always set. Currently is used as a placeholder for async connections.
-    For sync connections db - DatabaseBackend.connection is used.
+    Database cursor object.
     """
 
     # logger
@@ -42,10 +34,9 @@ class DBWrapperMixin:
     # Meta methods
     def __init__(
         self,
-        db: Any = None,
-        dbConn: Any = None,
+        dbCursor: Any = None,
         logger: logging.Logger | None = None,
-    ):
+    ) -> None:
         """
         Initializes a new instance of the DBWrapper class.
 
@@ -53,8 +44,7 @@ class DBWrapperMixin:
             db (DatabaseBackend): The DatabaseBackend object.
             logger (logging.Logger, optional): The logger object. Defaults to None.
         """
-        self.db = db
-        self.dbConn = dbConn
+        self.dbCursor = dbCursor
 
         if logger is None:
             loggerName = f"{__name__}.{self.__class__.__name__}"
@@ -62,49 +52,33 @@ class DBWrapperMixin:
         else:
             self.logger = logger
 
-    def __del__(self):
+    def __del__(self) -> None:
         """
         Deallocates the instance of the DBWrapper class.
         """
         self.logger.debug("Dealloc")
 
         # Force remove instances so that there are no circular references
-        if hasattr(self, "db") and self.db:
-            del self.db
-
-        if hasattr(self, "dbConn") and self.dbConn:
-            del self.dbConn
+        if hasattr(self, "dbCursor") and self.dbCursor:
+            del self.dbCursor
 
     ###############
     ### Setters ###
     ###############
 
-    def setDb(self, db: Any) -> None:
-        """
-        Updates the database backend object.
-
-        Args:
-            db (Any): The new database backend object.
-        """
-        if db is None:
-            del self.db
-            return
-
-        self.db = db
-
-    def setDbConn(self, dbConn: Any) -> None:
+    def setDbCursor(self, dbCursor: Any) -> None:
         """
-        Updates the database connection object.
+        Updates the database cursor object.
 
         Args:
-            dbConn (Any): The new database connection object.
+            dbCursor (Any): The new database cursor object.
         """
 
-        if dbConn is None:
-            del self.dbConn
+        if dbCursor is None:
+            del self.dbCursor
             return
 
-        self.dbConn = dbConn
+        self.dbCursor = dbCursor
 
     ######################
     ### Helper methods ###
@@ -139,7 +113,7 @@ class DBWrapperMixin:
 
     def turnDataIntoModel(
         self,
-        emptyDataClass: DataModelType,
+        emptyDataClass: Type[DataModelType],
         dbData: dict[str, Any],
     ) -> DataModelType:
         """
@@ -155,7 +129,7 @@ class DBWrapperMixin:
             DataModelType: The data model filled with data.
         """
 
-        result = emptyDataClass.__class__()
+        result = emptyDataClass()
         result.fillDataFromDict(dbData)
         result.raw_data = dbData