reydb 1.1.56__py3-none-any.whl → 1.1.58__py3-none-any.whl

reydb/rdb.py

@@ -9,29 +9,36 @@
 """
 
 
-from typing import Literal, overload
+from typing import Generic
 from urllib.parse import quote as urllib_quote
 from pymysql.constants.CLIENT import MULTI_STATEMENTS
-from sqlalchemy import create_engine as sqlalchemy_create_engine
-from sqlalchemy.engine.base import Engine
+from sqlalchemy import Engine, create_engine as sqlalchemy_create_engine
 from sqlalchemy.ext.asyncio import AsyncEngine, create_async_engine as sqlalchemy_create_async_engine
 from reykit.rtext import join_data_text
 
-from .rbase import DatabaseBase, extract_url
+from . import rbase, rbuild, rconfig, rconn, rerror, rexec, rfile, rinfo, rorm, rparam
 
 
 __all__ = (
+    'DatabaseSuper',
     'Database',
+    'DatabaseAsync'
 )
 
 
-class Database(DatabaseBase):
+class DatabaseSuper(
+    rbase.DatabaseBase,
+    Generic[
+        rbase.EngineT,
+        rbase.DatabaseConnectionT,
+        rbase.DatabaseExecuteT,
+        rbase.DatabaseSchemaT
+    ]
+):
     """
-    Database type, based `MySQL`.
+    Database super type, based `MySQL`.
     """
 
-    default_report: bool = False
-
 
     def __init__(
         self,
@@ -44,6 +51,7 @@ class Database(DatabaseBase):
         max_overflow: int = 10,
         pool_timeout: float = 30.0,
         pool_recycle: int | None = 3600,
+        report: bool = False,
         **query: str
     ) -> None:
         """
@@ -62,6 +70,7 @@ class Database(DatabaseBase):
         pool_recycle : Number of seconds `recycle` connection.
             - `None | Literal[-1]`: No recycle.
             - `int`: Use this value.
+        report : Whether report SQL execute information.
         query : Remote server database parameters.
         """
 
@@ -82,53 +91,40 @@ class Database(DatabaseBase):
             self.pool_recycle = -1
         else:
             self.pool_recycle = pool_recycle
+        self.report = report
         self.query = query
 
-        # Create engine.
-        self.engine = self.__create_engine(False)
-        self.aengine = self.__create_engine(True)
-
-
-    @property
-    def backend(self) -> str:
-        """
-        Database backend name.
+        ## Create engine.
+        self.engine = self.__create_engine()
 
-        Returns
-        -------
-        Name.
-        """
-
-        # Get.
-        url = self.url(False)
-        url_params = extract_url(url)
-        backend = url_params['backend']
 
-        return backend
-
-
-    @property
-    def driver(self) -> str:
+    def __str__(self) -> str:
         """
-        Database driver name.
-
-        Returns
-        -------
-        Name.
+        Return connection information text.
         """
 
-        # Get.
-        url = self.url(False)
-        url_params = extract_url(url)
-        driver = url_params['driver']
+        # Generate.
+        filter_key = (
+            'engine',
+            'connection',
+            'rdatabase',
+            'begin'
+        )
+        info = {
+            key: value
+            for key, value in self.__dict__.items()
+            if key not in filter_key
+        }
+        info['conn_count'] = self.conn_count
+        text = join_data_text(info)
 
-        return driver
+        return text
 
 
     @property
-    def abackend(self) -> str:
+    def backend(self) -> str:
         """
-        Asynchronous database backend name.
+        Database backend name.
 
         Returns
         -------
@@ -136,17 +132,16 @@ class Database(DatabaseBase):
         """
 
         # Get.
-        url = self.url(True)
-        url_params = extract_url(url)
+        url_params = rbase.extract_url(self.url)
         backend = url_params['backend']
 
         return backend
 
 
     @property
-    def adriver(self) -> str:
+    def driver(self) -> str:
         """
-        Asynchronous database driver name.
+        Database driver name.
 
         Returns
         -------
@@ -154,21 +149,17 @@ class Database(DatabaseBase):
         """
 
         # Get.
-        url = self.url(True)
-        url_params = extract_url(url)
+        url_params = rbase.extract_url(self.url)
         driver = url_params['driver']
 
         return driver
 
 
-    def url(self, is_async: bool) -> str:
+    @property
+    def url(self) -> str:
         """
         Generate server URL.
 
-        Parameters
-        ----------
-        is_async : Whether to use asynchronous engine.
-
         Returns
         -------
         Server URL.
@@ -176,10 +167,11 @@ class Database(DatabaseBase):
 
         # Generate URL.
         password = urllib_quote(self.password)
-        if is_async:
-            url_ = f'mysql+aiomysql://{self.username}:{password}@{self.host}:{self.port}/{self.database}'
-        else:
-            url_ = f'mysql+pymysql://{self.username}:{password}@{self.host}:{self.port}/{self.database}'
+        match self:
+            case Database():
+                url_ = f'mysql+pymysql://{self.username}:{password}@{self.host}:{self.port}/{self.database}'
+            case DatabaseAsync():
+                url_ = f'mysql+aiomysql://{self.username}:{password}@{self.host}:{self.port}/{self.database}'
 
         # Add Server parameter.
         if self.query != {}:
@@ -194,29 +186,18 @@ class Database(DatabaseBase):
         return url_
 
 
-    @overload
-    def __create_engine(self, is_async: Literal[False]) -> Engine: ...
-
-    @overload
-    def __create_engine(self, is_async: Literal[True]) -> AsyncEngine: ...
-
-    def __create_engine(self, is_async: bool) -> Engine | AsyncEngine:
+    def __create_engine(self) -> rbase.EngineT:
         """
         Create database `Engine` object.
 
-        Parameters
-        ----------
-        is_async : Whether to use asynchronous engine.
-
         Returns
         -------
         Engine object.
         """
 
         # Handle parameter.
-        url = self.url(is_async)
         engine_params = {
-            'url': url,
+            'url': self.url,
             'pool_size': self.pool_size,
             'max_overflow': self.max_overflow,
             'pool_timeout': self.pool_timeout,
@@ -225,44 +206,27 @@ class Database(DatabaseBase):
         }
 
         # Create Engine.
-        if is_async:
-            engine = sqlalchemy_create_async_engine(**engine_params)
-        else:
-            engine = sqlalchemy_create_engine(**engine_params)
+        match self:
+            case Database():
+                engine = sqlalchemy_create_engine(**engine_params)
+            case DatabaseAsync():
+                engine = sqlalchemy_create_async_engine(**engine_params)
 
         return engine
 
 
-    async def dispose(self) -> None:
-        """
-        Dispose asynchronous connections.
-        """
-
-        # Dispose.
-        await self.aengine.dispose()
-
-
-    def __conn_count(self, is_async: bool) -> tuple[int, int]:
+    @property
+    def conn_count(self) -> tuple[int, int]:
         """
         Count number of keep open and allowed overflow connection.
 
-        Parameters
-        ----------
-        is_async : Whether to use asynchronous engine.
-
         Returns
         -------
         Number of keep open and allowed overflow connection.
         """
 
-        # Handle parameter.
-        if is_async:
-            engine = self.aengine
-        else:
-            engine = self.engine
-
         # Count.
-        _overflow: int = engine.pool._overflow
+        _overflow: int = self.engine.pool._overflow
         if _overflow < 0:
             keep_n = self.pool_size + _overflow
             overflow_n = 0
@@ -273,134 +237,66 @@ class Database(DatabaseBase):
         return keep_n, overflow_n
 
 
-    @property
-    def conn_count(self) -> tuple[int, int]:
-        """
-        Count number of keep open and allowed overflow connection.
-
-        Returns
-        -------
-        Number of keep open and allowed overflow connection.
+    def connect(self, autocommit: bool = False) -> rbase.DatabaseConnectionT:
         """
+        Build database connection instance.
 
-        # Count.
-        keep_n, overflow_n = self.__conn_count(False)
-
-        return keep_n, overflow_n
-
-
-    @property
-    def aconn_count(self) -> tuple[int, int]:
-        """
-        Count number of keep open and allowed overflow asynchronous connection.
+        Parameters
+        ----------
+        autocommit: Whether automatic commit execute.
 
         Returns
         -------
-        Number of keep open and allowed overflow asynchronous connection.
+        Database connection instance.
         """
 
-        # Count.
-        keep_n, overflow_n = self.__conn_count(True)
+        # Build.
+        match self:
+            case Database():
+                conn = rconn.DatabaseConnection(self, autocommit)
+            case DatabaseAsync():
+                conn = rconn.DatabaseConnectionAsync(self, autocommit)
 
-        return keep_n, overflow_n
+        return conn
 
 
-    def schema(self, filter_default: bool = True) -> dict[str, dict[str, list[str]]]:
+    @property
+    def execute(self) -> rbase.DatabaseExecuteT:
         """
-        Get schemata of databases and tables and columns.
-
-        Parameters
-        ----------
-        filter_default : Whether filter default database.
+        Build database execute instance.
 
         Returns
         -------
-        Schemata of databases and tables and columns.
+        Instance.
         """
 
-        # Handle parameter.
-        filter_db = (
-            'information_schema',
-            'performance_schema',
-            'mysql',
-            'sys'
-        )
-        if filter_default:
-            where_database = 'WHERE `SCHEMA_NAME` NOT IN :filter_db\n'
-            where_column = '    WHERE `TABLE_SCHEMA` NOT IN :filter_db\n'
-        else:
-            where_database = where_column = ''
-
-        # Select.
-        sql = (
-            'SELECT GROUP_CONCAT(`SCHEMA_NAME`) AS `TABLE_SCHEMA`, NULL AS `TABLE_NAME`, NULL AS `COLUMN_NAME`\n'
-            'FROM `information_schema`.`SCHEMATA`\n'
-            f'{where_database}'
-            'UNION ALL (\n'
-            '    SELECT `TABLE_SCHEMA`, `TABLE_NAME`, `COLUMN_NAME`\n'
-            '    FROM `information_schema`.`COLUMNS`\n'
-            f'{where_column}'
-            '    ORDER BY `TABLE_SCHEMA`, `TABLE_NAME`, `ORDINAL_POSITION`\n'
-            ')'
-        )
-        result = self.execute(sql, filter_db=filter_db)
-
-        # Convert.
-        database_names, *_ = result.fetchone()
-        database_names: list[str] = database_names.split(',')
-        schema_dict = {}
-        for database, table, column in result:
-            if database in database_names:
-                database_names.remove(database)
-
-            ## Index database.
-            if database not in schema_dict:
-                schema_dict[database] = {table: [column]}
-                continue
-            table_dict: dict = schema_dict[database]
-
-            ## Index table. 
-            if table not in table_dict:
-                table_dict[table] = [column]
-                continue
-            column_list: list = table_dict[table]
-
-            ## Add column.
-            column_list.append(column)
-
-        ## Add empty database.
-        for name in database_names:
-            schema_dict[name] = None
+        # Build.
+        conn = self.connect(True)
+        exec = conn.execute
 
-        return schema_dict
+        return exec
 
 
-    def connect(self, autocommit: bool = False):
+    @property
+    def orm(self):
         """
-        Build `DatabaseConnection` instance.
-
-        Parameters
-        ----------
-        autocommit: Whether automatic commit execute.
+        Build database ORM instance.
 
         Returns
         -------
-        Database connection instance.
+        Instance.
         """
 
-        # Import.
-        from .rconn import DatabaseConnection
-
         # Build.
-        conn = DatabaseConnection(self, autocommit)
+        orm = rorm.DatabaseORM(self)
 
-        return conn
+        return orm
 
 
     @property
-    def execute(self):
+    def build(self):
         """
-        Build `DatabaseExecute` instance.
+        Build database build instance.
 
         Returns
         -------
@@ -408,38 +304,31 @@ class Database(DatabaseBase):
         """
 
         # Build.
-        dbconn = self.connect(True)
-        exec = dbconn.execute
+        dbbuild = rbuild.DatabaseBuild(self)
 
-        return exec
+        return dbbuild
 
 
-    def aconnect(self, autocommit: bool = False):
+    @property
+    def file(self):
         """
-        Build `DatabaseConnectionAsync` instance.
-
-        Parameters
-        ----------
-        autocommit: Whether automatic commit execute.
+        Build database file instance.
 
         Returns
         -------
-        Database connection instance.
+        Instance.
         """
 
-        # Import.
-        from .rconn import DatabaseConnectionAsync
-
         # Build.
-        conn = DatabaseConnectionAsync(self, autocommit)
+        dbfile = rfile.DatabaseFile(self)
 
-        return conn
+        return dbfile
 
 
     @property
-    def aexecute(self):
+    def error(self):
         """
-        Build `DatabaseConnectionAsync` instance.
+        Build database error instance.
 
         Returns
         -------
@@ -447,35 +336,31 @@ class Database(DatabaseBase):
         """
 
         # Build.
-        dbconn = self.aconnect(True)
-        exec = dbconn.aexecute
+        dbfile = rerror.DatabaseError(self)
 
-        return exec
+        return dbfile
 
 
     @property
-    def orm(self):
+    def config(self):
         """
-        Build `DatabaseORM` instance.
+        Build database config instance.
 
         Returns
         -------
         Instance.
         """
 
-        # Import.
-        from .rorm import DatabaseORM
-
         # Build.
-        orm = DatabaseORM(self)
+        dbconfig = rconfig.DatabaseConfig(self)
 
-        return orm
+        return dbconfig
 
 
     @property
     def info(self):
         """
-        Build `DatabaseInformationSchema` instance.
+        Build database information schema instance.
 
         Returns
         -------
@@ -502,125 +387,60 @@ class Database(DatabaseBase):
         >>> database_attr = DatabaseInformationSchema.database.table.column['attribute']
         """
 
-        # Import.
-        from .rinfo import DatabaseInformationSchema
-
         # Build.
-        dbischema = DatabaseInformationSchema(self)
+        dbischema = rinfo.DatabaseInformationSchema(self)
 
         return dbischema
 
 
     @property
-    def build(self):
+    def schema(self) -> rbase.DatabaseSchemaT:
         """
-        Build `DatabaseBuild` instance.
+        Build database schema instance.
 
         Returns
         -------
         Instance.
         """
 
-        # Import.
-        from .rbuild import DatabaseBuild
-
         # Build.
-        dbbuild = DatabaseBuild(self)
+        match self:
+            case Database():
+                schema = rparam.DatabaseSchema(self)
+            case DatabaseAsync():
+                schema = rparam.DatabaseSchemaAsync(self)
 
-        return dbbuild
-
-
-    @property
-    def file(self):
-        """
-        Build `DatabaseFile` instance.
-
-        Returns
-        -------
-        Instance.
-        """
-
-        # Import.
-        from .rfile import DatabaseFile
-
-        # Build.
-        dbfile = DatabaseFile(self)
-
-        return dbfile
-
-
-    @property
-    def error(self):
-        """
-        Build `DatabaseError` instance.
-
-        Returns
-        -------
-        Instance.
-        """
-
-        # Import.
-        from .rerror import DatabaseError
-
-        # Build.
-        dbfile = DatabaseError(self)
-
-        return dbfile
-
-
-    @property
-    def config(self):
-        """
-        Build `DatabaseConfig` instance.
-
-        Returns
-        -------
-        Instance.
-        """
-
-        # Import.
-        from .rconfig import DatabaseConfig
-
-        # Build.
-        dbconfig = DatabaseConfig(self)
-
-        return dbconfig
+        return schema
 
 
     @property
     def status(self):
         """
-        Build `DatabaseParametersStatus` instance.
+        Build database parameters status instance.
 
         Returns
         -------
         Instance.
         """
 
-        # Import.
-        from .rparam import DatabaseParametersStatus
-
         # Build.
-        dbps = DatabaseParametersStatus(self, False)
+        dbps = rparam.DatabaseParametersStatus(self, False)
 
         return dbps
 
 
     @property
-    def global_status(self):
+    def status_global(self):
         """
-        Build global `DatabaseParametersStatus` instance.
+        Build global database parameters status instance.
 
         Returns
         -------
         Instance.
         """
 
-        # Import.
-        from .rparam import DatabaseParametersStatus
-
         # Build.
-        dbps = DatabaseParametersStatus(self, True)
+        dbps = rparam.DatabaseParametersStatus(self, True)
 
         return dbps
 
@@ -628,62 +448,67 @@ class Database(DatabaseBase):
     @property
     def variables(self):
         """
-        Build `DatabaseParametersVariable` instance.
+        Build database parameters variable instance.
 
         Returns
         -------
         Instance.
         """
 
-        # Import.
-        from .rparam import DatabaseParametersVariable
-
         # Build.
-        dbpv = DatabaseParametersVariable(self, False)
+        dbpv = rparam.DatabaseParametersVariable(self, False)
 
         return dbpv
 
 
     @property
-    def global_variables(self):
+    def variables_global(self):
         """
-        Build global `DatabaseParametersVariable` instance.
+        Build global database parameters variable instance.
 
         Returns
         -------
         Instance.
         """
 
-        # Import.
-        from .rparam import DatabaseParametersVariable
-
         # Build.
 
         ## SQLite.
-        dbpv = DatabaseParametersVariable(self, True)
+        dbpv = rparam.DatabaseParametersVariable(self, True)
 
         return dbpv
 
 
-    def __str__(self) -> str:
+class Database(
+    DatabaseSuper[
+        Engine,
+        'rconn.DatabaseConnection',
+        'rexec.DatabaseExecute',
+        'rparam.DatabaseSchema'
+    ]
+):
+    """
+    Database type, based `MySQL`.
+    """
+
+
+class DatabaseAsync(
+    DatabaseSuper[
+        AsyncEngine,
+        'rconn.DatabaseConnectionAsync',
+        'rexec.DatabaseExecuteAsync',
+        'rparam.DatabaseSchemaAsync'
+    ]
+):
+    """
+    Asynchronous database type, based `MySQL`.
+    """
+
+
+    async def dispose(self) -> None:
         """
-        Return connection information text.
+        Dispose asynchronous connections.
         """
 
-        # Generate.
-        filter_key = (
-            'engine',
-            'connection',
-            'rdatabase',
-            'begin'
-        )
-        info = {
-            key: value
-            for key, value in self.__dict__.items()
-            if key not in filter_key
-        }
-        info['conn_count'] = self.conn_count
-        info['aconn_count'] = self.aconn_count
-        text = join_data_text(info)
-
-        return text
+        # Dispose.
+        await self.engine.dispose()