reydb 1.1.28__py3-none-any.whl → 1.1.29__py3-none-any.whl

reydb/__init__.py

@@ -17,5 +17,6 @@ rdb : Database methods.
 rexec : Database execute methods.
 rfile : Database file methods.
 rinfo : Database information methods.
+rlog : Database log methods.
 rparam : Database parameter methods.
 """

reydb/rall.py

@@ -16,4 +16,5 @@ from .rdb import *
 from .rexec import *
 from .rfile import *
 from .rinfo import *
+from .rlog import *
 from .rparam import *

reydb/rbase.py

@@ -13,11 +13,11 @@ from reykit.rbase import Base
 
 
 __all__ = (
-    'BaseDatabase',
+    'DatabaseBase',
 )
 
 
-class BaseDatabase(Base):
+class DatabaseBase(Base):
     """
     Database base type.
     """

reydb/rbuild.py

@@ -14,13 +14,13 @@ from copy import deepcopy
 from reykit.rbase import throw
 from reykit.rstdout import ask
 
-from .rbase import BaseDatabase
-from .rconn import DBConnection
+from .rbase import DatabaseBase
+from .rconn import DatabaseConnection
 from .rdb import Database
 
 
 __all__ = (
-    'DBBuild',
+    'DatabaseBuild',
 )
 
 
@@ -46,19 +46,19 @@ IndexSet = TypedDict(
 )
 
 
-class DBBuild(BaseDatabase):
+class DatabaseBuild(DatabaseBase):
     """
     Database build type.
     """
 
 
-    def __init__(self, rdatabase: Database | DBConnection) -> None:
+    def __init__(self, rdatabase: Database | DatabaseConnection) -> None:
         """
         Build instance attributes.
 
         Parameters
         ----------
-        rdatabase : Database or DBConnection instance.
+        rdatabase : Database or DatabaseConnection instance.
         """
 
         # SQLite.
@@ -994,15 +994,18 @@ class DBBuild(BaseDatabase):
             self._schema = self.rdatabase.schema(False)
 
         # Judge.
-        judge = not (
-            (database_info := self._schema.get(database)) is None
-            or (
-                table is not None
-                and (table_info := database_info.get(table)) is None
+        judge = (
+            database in self._schema
+            and (
+                table is None
+                or (
+                    (database_info := self._schema.get(database)) is not None
+                    and (table_info := database_info.get(table)) is not None
+                )
             )
-            or (
-                column is not None
-                and column not in table_info
+            and (
+                column is None
+                or column in table_info
             )
         )
 

reydb/rconn.py

@@ -10,13 +10,9 @@
 
 
 from typing import Any, Self
-from types import TracebackType
-from sqlalchemy import text as sqlalchemy_text
 from sqlalchemy.engine.base import Connection
-from sqlalchemy.engine.cursor import CursorResult
 from sqlalchemy.sql.elements import TextClause
 from sqlalchemy.exc import OperationalError
-from pandas import DataFrame
 from reykit.rbase import get_first_notnone
 from reykit.rdata import objs_in
 from reykit.rstdout import echo
@@ -27,11 +23,11 @@ from .rdb import Result, Database
 
 
 __all__ = (
-    'DBConnection',
+    'DatabaseConnection',
 )
 
 
-class DBConnection(Database):
+class DatabaseConnection(Database):
     """
     Database connection type.
     """
@@ -177,7 +173,7 @@ class DBConnection(Database):
         ):
             text = 'Retrying...'
             title = 'Database Execute Operational Error'
-            handler = lambda exc_report, *_: echo(exc_report, text, title=title, frame='top')
+            handler = lambda exc_text, *_: echo(exc_text, text, title=title, frame='top')
             executor = wrap_retry(self.executor, handler=handler, exception=OperationalError)
             result = executor(self.connection, sql, data, report)
 
@@ -236,8 +232,7 @@ class DBConnection(Database):
     def __exit__(
         self,
         exc_type: type[BaseException] | None,
-        exc_instance: BaseException | None,
-        exc_traceback: TracebackType | None
+        *_
     ) -> None:
         """
         Exit syntax `with`.
@@ -245,8 +240,6 @@ class DBConnection(Database):
         Parameters
         ----------
         exc_type : Exception type.
-        exc_instance : Exception instance.
-        exc_traceback : Exception traceback instance.
         """
 
         # Commit.

reydb/rdb.py

@@ -27,7 +27,7 @@ from reykit.rtable import TableData, Table
 from reykit.rtext import join_data_text
 from reykit.rwrap import wrap_runtime, wrap_retry
 
-from .rbase import BaseDatabase
+from .rbase import DatabaseBase
 
 
 __all__ = (
@@ -42,7 +42,7 @@ Result = Result_
 monkey_sqlalchemy_row_index_field()
 
 
-class Database(BaseDatabase):
+class Database(DatabaseBase):
     """
     Database type.
 
@@ -885,7 +885,7 @@ class Database(BaseDatabase):
             ):
                 text = 'Retrying...'
                 title = 'Database Execute Operational Error'
-                handler = lambda exc_report, *_: echo(exc_report, text, title=title, frame='top')
+                handler = lambda exc_text, *_: echo(exc_text, text, title=title, frame='top')
                 executor = wrap_retry(self.executor, handler=handler, exception=OperationalError)
                 result = executor(self.connection, sql, data, report)
 
@@ -1687,7 +1687,7 @@ class Database(BaseDatabase):
 
     def connect(self):
         """
-        Build instance attributes.
+        Build `DatabaseConnection` instance.
 
         Returns
         -------
@@ -1695,10 +1695,10 @@ class Database(BaseDatabase):
         """
 
         # Import.
-        from .rconn import DBConnection
+        from .rconn import DatabaseConnection
 
         # Build.
-        dbconnection = DBConnection(
+        dbconnection = DatabaseConnection(
             self.engine.connect(),
             self
         )
@@ -1719,51 +1719,51 @@ class Database(BaseDatabase):
         --------
         Execute.
         >>> sql = 'select :value'
-        >>> result = DBExecute(sql, value=1)
+        >>> result = DatabaseExecute(sql, value=1)
 
         Select.
         >>> field = ['id', 'value']
         >>> where = '`id` = ids'
         >>> ids = (1, 2)
-        >>> result = DBExecute.database.table(field, where, ids=ids)
+        >>> result = DatabaseExecute.database.table(field, where, ids=ids)
 
         Insert.
         >>> data = [{'id': 1}, {'id': 2}]
         >>> duplicate = 'ignore'
-        >>> result = DBExecute.database.table + data
-        >>> result = DBExecute.database.table + (data, duplicate)
-        >>> result = DBExecute.database.table + {'data': data, 'duplicate': duplicate}
+        >>> result = DatabaseExecute.database.table + data
+        >>> result = DatabaseExecute.database.table + (data, duplicate)
+        >>> result = DatabaseExecute.database.table + {'data': data, 'duplicate': duplicate}
 
         Update.
         >>> data = [{'name': 'a', 'id': 1}, {'name': 'b', 'id': 2}]
         >>> where_fields = 'id'
-        >>> result = DBExecute.database.table & data
-        >>> result = DBExecute.database.table & (data, where_fields)
-        >>> result = DBExecute.database.table & {'data': data, 'where_fields': where_fields}
+        >>> result = DatabaseExecute.database.table & data
+        >>> result = DatabaseExecute.database.table & (data, where_fields)
+        >>> result = DatabaseExecute.database.table & {'data': data, 'where_fields': where_fields}
 
         Delete.
         >>> where = '`id` IN (1, 2)'
         >>> report = True
-        >>> result = DBExecute.database.table - where
-        >>> result = DBExecute.database.table - (where, report)
-        >>> result = DBExecute.database.table - {'where': where, 'report': report}
+        >>> result = DatabaseExecute.database.table - where
+        >>> result = DatabaseExecute.database.table - (where, report)
+        >>> result = DatabaseExecute.database.table - {'where': where, 'report': report}
 
         Copy.
         >>> where = '`id` IN (1, 2)'
         >>> limit = 1
-        >>> result = DBExecute.database.table * where
-        >>> result = DBExecute.database.table * (where, limit)
-        >>> result = DBExecute.database.table * {'where': where, 'limit': limit}
+        >>> result = DatabaseExecute.database.table * where
+        >>> result = DatabaseExecute.database.table * (where, limit)
+        >>> result = DatabaseExecute.database.table * {'where': where, 'limit': limit}
 
         Exist.
         >>> where = '`id` IN (1, 2)'
         >>> report = True
-        >>> result = where in DBExecute.database.table
-        >>> result = (where, report) in DBExecute.database.table
-        >>> result = {'where': where, 'report': report} in DBExecute.database.table
+        >>> result = where in DatabaseExecute.database.table
+        >>> result = (where, report) in DatabaseExecute.database.table
+        >>> result = {'where': where, 'report': report} in DatabaseExecute.database.table
 
         Count.
-        >>> result = len(DBExecute.database.table)
+        >>> result = len(DatabaseExecute.database.table)
 
         Default database.
         >>> field = ['id', 'value']
@@ -1772,10 +1772,10 @@ class Database(BaseDatabase):
         """
 
         # Import.
-        from .rexec import DBExecute
+        from .rexec import DatabaseExecute
 
         # Build.
-        dbexecute = DBExecute(self)
+        dbexecute = DatabaseExecute(self)
 
         return dbexecute
 
@@ -1857,7 +1857,7 @@ class Database(BaseDatabase):
     @property
     def info(self):
         """
-        Build instance attributes.
+        Build `DatabaseInformationSchema` instance.
 
         Returns
         -------
@@ -1866,29 +1866,29 @@ class Database(BaseDatabase):
         Examples
         --------
         Get databases information of server.
-        >>> databases_info = DBISchema()
+        >>> databases_info = DatabaseInformationSchema()
 
         Get tables information of database.
-        >>> tables_info = DBISchema.database()
+        >>> tables_info = DatabaseInformationSchema.database()
 
         Get columns information of table.
-        >>> columns_info = DBISchema.database.table()
+        >>> columns_info = DatabaseInformationSchema.database.table()
 
         Get database attribute.
-        >>> database_attr = DBISchema.database['attribute']
+        >>> database_attr = DatabaseInformationSchema.database['attribute']
 
         Get table attribute.
-        >>> database_attr = DBISchema.database.table['attribute']
+        >>> database_attr = DatabaseInformationSchema.database.table['attribute']
 
         Get column attribute.
-        >>> database_attr = DBISchema.database.table.column['attribute']
+        >>> database_attr = DatabaseInformationSchema.database.table.column['attribute']
         """
 
         # Import.
-        from .rinfo import DBISchema
+        from .rinfo import DatabaseInformationSchema
 
         # Build.
-        dbischema = DBISchema(self)
+        dbischema = DatabaseInformationSchema(self)
 
         return dbischema
 
@@ -1896,7 +1896,7 @@ class Database(BaseDatabase):
     @property
     def build(self):
         """
-        Build instance attributes.
+        Build `DatabaseBuild` instance.
 
         Returns
         -------
@@ -1904,10 +1904,10 @@ class Database(BaseDatabase):
         """
 
         # Import.
-        from .rbuild import DBBuild
+        from .rbuild import DatabaseBuild
 
         # Build.
-        dbbuild = DBBuild(self)
+        dbbuild = DatabaseBuild(self)
 
         return dbbuild
 
@@ -1915,7 +1915,7 @@ class Database(BaseDatabase):
     @property
     def file(self):
         """
-        Build instance attributes.
+        Build `DatabaseFile` instance.
 
         Returns
         -------
@@ -1923,10 +1923,29 @@ class Database(BaseDatabase):
         """
 
         # Import.
-        from .rfile import DBFile
+        from .rfile import DatabaseFile
 
         # Build.
-        dbfile = DBFile(self)
+        dbfile = DatabaseFile(self)
+
+        return dbfile
+
+
+    @property
+    def log(self):
+        """
+        Build `DatabaseLog` instance.
+
+        Returns
+        -------
+        Database file instance.
+        """
+
+        # Import.
+        from .rlog import DatabaseLog
+
+        # Build.
+        dbfile = DatabaseLog(self)
 
         return dbfile
 
@@ -1934,7 +1953,7 @@ class Database(BaseDatabase):
     @property
     def status(self):
         """
-        Build instance attributes.
+        Build `DatabaseParameterStatus` or `DatabaseParameterPragma` instance.
 
         Returns
         -------
@@ -1942,17 +1961,17 @@ class Database(BaseDatabase):
         """
 
         # Import.
-        from .rparam import DBPStatus, DBPPragma
+        from .rparam import DatabaseParameterStatus, DatabaseParameterPragma
 
         # Build.
 
         ## SQLite.
         if self.backend == 'sqlite':
-            dbp = DBPPragma(self)
+            dbp = DatabaseParameterPragma(self)
 
         ## Other.
         else:
-            dbp = DBPStatus(self, False)
+            dbp = DatabaseParameterStatus(self, False)
 
         return dbp
 
@@ -1960,7 +1979,7 @@ class Database(BaseDatabase):
     @property
     def global_status(self):
         """
-        Build global `database status parameters` instance.
+        Build `DatabaseParameterStatus` or `DatabaseParameterPragma` instance.
 
         Returns
         -------
@@ -1968,17 +1987,17 @@ class Database(BaseDatabase):
         """
 
         # Import.
-        from .rparam import DBPStatus, DBPPragma
+        from .rparam import DatabaseParameterStatus, DatabaseParameterPragma
 
         # Build.
 
         ## SQLite.
         if self.backend == 'sqlite':
-            dbp = DBPPragma(self)
+            dbp = DatabaseParameterPragma(self)
 
         ## Other.
         else:
-            dbp = DBPStatus(self, True)
+            dbp = DatabaseParameterStatus(self, True)
 
         return dbp
 
@@ -1986,7 +2005,7 @@ class Database(BaseDatabase):
     @property
     def variables(self):
         """
-        Build instance attributes.
+        Build `DatabaseParameterVariable` or `DatabaseParameterPragma` instance.
 
         Returns
         -------
@@ -1994,17 +2013,17 @@ class Database(BaseDatabase):
         """
 
         # Import.
-        from .rparam import DBPVariable, DBPPragma
+        from .rparam import DatabaseParameterVariable, DatabaseParameterPragma
 
         # Build.
 
         ## SQLite.
         if self.backend == 'sqlite':
-            dbp = DBPPragma(self)
+            dbp = DatabaseParameterPragma(self)
 
         ## Other.
         else:
-            dbp = DBPVariable(self, False)
+            dbp = DatabaseParameterVariable(self, False)
 
         return dbp
 
@@ -2020,17 +2039,17 @@ class Database(BaseDatabase):
         """
 
         # Import.
-        from .rparam import DBPVariable, DBPPragma
+        from .rparam import DatabaseParameterVariable, DatabaseParameterPragma
 
         # Build.
 
         ## SQLite.
         if self.backend == 'sqlite':
-            dbp = DBPPragma(self)
+            dbp = DatabaseParameterPragma(self)
 
         ## Other.
         else:
-            dbp = DBPVariable(self, True)
+            dbp = DatabaseParameterVariable(self, True)
 
         return dbp
 

reydb/rexec.py

@@ -13,17 +13,17 @@ from typing import Any, Self
 from reykit.rbase import throw
 from reykit.rtable import TableData
 
-from .rbase import BaseDatabase
-from .rconn import DBConnection
+from .rbase import DatabaseBase
+from .rconn import DatabaseConnection
 from .rdb import Database, Result
 
 
 __all__ = (
-    'DBExecute',
+    'DatabaseExecute',
 )
 
 
-class DBExecute(BaseDatabase):
+class DatabaseExecute(DatabaseBase):
     """
     Database execute type.
 
@@ -33,45 +33,45 @@ class DBExecute(BaseDatabase):
     >>> field = ['id', 'value']
     >>> where = '`id` = ids'
     >>> ids = (1, 2)
-    >>> result = DBExecute.database.table(field, where, ids=ids)
+    >>> result = DatabaseExecute.database.table(field, where, ids=ids)
 
     Insert.
     >>> data = [{'id': 1}, {'id': 2}]
     >>> duplicate = 'ignore'
-    >>> result = DBExecute.database.table + data
-    >>> result = DBExecute.database.table + (data, duplicate)
-    >>> result = DBExecute.database.table + {'data': data, 'duplicate': duplicate}
+    >>> result = DatabaseExecute.database.table + data
+    >>> result = DatabaseExecute.database.table + (data, duplicate)
+    >>> result = DatabaseExecute.database.table + {'data': data, 'duplicate': duplicate}
 
     Update.
     >>> data = [{'name': 'a', 'id': 1}, {'name': 'b', 'id': 2}]
     >>> where_fields = 'id'
-    >>> result = DBExecute.database.table & data
-    >>> result = DBExecute.database.table & (data, where_fields)
-    >>> result = DBExecute.database.table & {'data': data, 'where_fields': where_fields}
+    >>> result = DatabaseExecute.database.table & data
+    >>> result = DatabaseExecute.database.table & (data, where_fields)
+    >>> result = DatabaseExecute.database.table & {'data': data, 'where_fields': where_fields}
 
     Delete.
     >>> where = '`id` IN (1, 2)'
     >>> report = True
-    >>> result = DBExecute.database.table - where
-    >>> result = DBExecute.database.table - (where, report)
-    >>> result = DBExecute.database.table - {'where': where, 'report': report}
+    >>> result = DatabaseExecute.database.table - where
+    >>> result = DatabaseExecute.database.table - (where, report)
+    >>> result = DatabaseExecute.database.table - {'where': where, 'report': report}
 
     Copy.
     >>> where = '`id` IN (1, 2)'
     >>> limit = 1
-    >>> result = DBExecute.database.table * where
-    >>> result = DBExecute.database.table * (where, limit)
-    >>> result = DBExecute.database.table * {'where': where, 'limit': limit}
+    >>> result = DatabaseExecute.database.table * where
+    >>> result = DatabaseExecute.database.table * (where, limit)
+    >>> result = DatabaseExecute.database.table * {'where': where, 'limit': limit}
 
     Exist.
     >>> where = '`id` IN (1, 2)'
     >>> report = True
-    >>> result = where in DBExecute.database.table
-    >>> result = (where, report) in DBExecute.database.table
-    >>> result = {'where': where, 'report': report} in DBExecute.database.table
+    >>> result = where in DatabaseExecute.database.table
+    >>> result = (where, report) in DatabaseExecute.database.table
+    >>> result = {'where': where, 'report': report} in DatabaseExecute.database.table
 
     Count.
-    >>> result = len(DBExecute.database.table)
+    >>> result = len(DatabaseExecute.database.table)
 
     Default database.
     >>> engine = Database(**server, database)
@@ -79,13 +79,13 @@ class DBExecute(BaseDatabase):
     """
 
 
-    def __init__(self, rdatabase: Database | DBConnection) -> None:
+    def __init__(self, rdatabase: Database | DatabaseConnection) -> None:
         """
         Build instance attributes.
 
         Parameters
         ----------
-        rdatabase : Database or DBConnection instance.
+        rdatabase : Database or DatabaseConnection instance.
         """
 
         # Set parameter.