reydb 1.1.60__py3-none-any.whl → 1.2.0__py3-none-any.whl

reydb/rparam.py

@@ -9,7 +9,7 @@
 """
 
 
-from typing import TypeVar, Generic, overload
+from typing import Literal, TypeVar, Generic, Final, overload
 
 from . import rdb
 from .rbase import DatabaseBase
@@ -17,10 +17,20 @@ from .rexec import Result
 
 
 __all__ = (
+    'DatabaseSchemaSuper',
     'DatabaseSchema',
+    'DatabaseSchemaAsync',
+    'DatabaseParametersSuper',
     'DatabaseParameters',
+    'DatabaseParametersAsync',
+    'DatabaseParametersVariables',
     'DatabaseParametersStatus',
-    'DatabaseParametersVariable'
+    'DatabaseParametersVariablesGlobal',
+    'DatabaseParametersStatusGlobal',
+    'DatabaseParametersVariablesAsync',
+    'DatabaseParametersStatusAsync',
+    'DatabaseParametersVariablesGlobalAsync',
+    'DatabaseParametersStatusGlobalAsync'
 )
 
 
@@ -45,10 +55,9 @@ class DatabaseSchemaSuper(DatabaseBase, Generic[DatabaseT]):
         # Set parameter.
         self.db = db
 
-
-    def _call__before(self, filter_default: bool = True) -> tuple[str, tuple[str, ...]]:
+    def handle_before__call__(self, filter_default: bool = True) -> tuple[str, tuple[str, ...]]:
         """
-        Before handle of call method.
+        Before handle method of call method.
 
         Parameters
         ----------
@@ -88,9 +97,9 @@ class DatabaseSchemaSuper(DatabaseBase, Generic[DatabaseT]):
         return sql, filter_db
 
 
-    def _call__after(self, result: Result) -> dict[str, dict[str, list[str]]]:
+    def handle_after__call__(self, result: Result) -> dict[str, dict[str, list[str]]]:
         """
-        After handle of call method.
+        After handle method of call method.
 
         Parameters
         ----------
@@ -131,13 +140,80 @@ class DatabaseSchemaSuper(DatabaseBase, Generic[DatabaseT]):
         return schema_dict
 
 
+    @overload
+    def handle_exist(
+        self,
+        schema: dict[str, dict[str, list[str]]],
+        database: str
+    ) -> bool: ...
+
+    @overload
+    def handle_exist(
+        self,
+        schema: dict[str, dict[str, list[str]]],
+        database: str,
+        table: str
+    ) -> bool: ...
+
+    @overload
+    def handle_exist(
+        self,
+        schema: dict[str, dict[str, list[str]]],
+        database: str,
+        table: str,
+        column: str
+    ) -> bool: ...
+
+    def handle_exist(
+        self,
+        schema: dict[str, dict[str, list[str]]],
+        database: str,
+        table: str | None = None,
+        column: str | None = None
+    ) -> bool:
+        """
+        Handle method of judge database or table or column whether it exists.
+
+        Parameters
+        ----------
+        schema : Schemata of databases and tables and columns.
+        database : Database name.
+        table : Table name.
+        column : Column name.
+
+        Returns
+        -------
+        Judge result.
+        """
+
+        # Handle parameter.
+
+        # Judge.
+        judge = (
+            database in schema
+            and (
+                table is None
+                or (
+                    (database_info := schema.get(database)) is not None
+                    and (table_info := database_info.get(table)) is not None
+                )
+            )
+            and (
+                column is None
+                or column in table_info
+            )
+        )
+
+        return judge
+
+
 class DatabaseSchema(DatabaseSchemaSuper['rdb.Database']):
     """
     Database schema type.
     """
 
 
-    def __call__(self, filter_default: bool = True) -> dict[str, dict[str, list[str]]]:
+    def schema(self, filter_default: bool = True) -> dict[str, dict[str, list[str]]]:
         """
         Get schemata of databases and tables and columns.
 
@@ -151,11 +227,83 @@ class DatabaseSchema(DatabaseSchemaSuper['rdb.Database']):
         """
 
         # Get.
-        sql, filter_db = self._call__before(filter_default)
+        sql, filter_db = self.handle_before__call__(filter_default)
         result = self.db.execute(sql, filter_db=filter_db)
-        schema_dict = self._call__after(result)
+        schema = self.handle_after__call__(result)
 
-        return schema_dict
+        # Cache.
+        if self.db._schema is None:
+            self.db._schema = schema
+        else:
+            self.db._schema.update(schema)
+
+        return schema
+
+
+    __call__ = schema
+
+
+    @overload
+    def exist(
+        self,
+        database: str,
+        *,
+        refresh: bool = True
+    ) -> bool: ...
+
+    @overload
+    def exist(
+        self,
+        database: str,
+        *,
+        table: str,
+        refresh: bool = True
+    ) -> bool: ...
+
+    @overload
+    def exist(
+        self,
+        database: str,
+        table: str,
+        column: str,
+        refresh: bool = True
+    ) -> bool: ...
+
+    def exist(
+        self,
+        database: str,
+        table: str | None = None,
+        column: str | None = None,
+        refresh: bool = True
+    ) -> bool:
+        """
+        Judge database or table or column whether it exists.
+
+        Parameters
+        ----------
+        database : Database name.
+        table : Table name.
+        column : Column name.
+        refresh : Whether refresh cache data. Cache can improve efficiency.
+
+        Returns
+        -------
+        Judge result.
+        """
+
+        # Handle parameter.
+        if (
+            refresh
+            or self.db._schema is None
+        ):
+            schema = self.schema()
+        else:
+            schema = self.db._schema
+
+        # Judge.
+        result = self.handle_exist(schema, database, table, column)
+
+        return result
 
 
 class DatabaseSchemaAsync(DatabaseSchemaSuper['rdb.DatabaseAsync']):
@@ -164,7 +312,7 @@ class DatabaseSchemaAsync(DatabaseSchemaSuper['rdb.DatabaseAsync']):
     """
 
 
-    async def __call__(self, filter_default: bool = True) -> dict[str, dict[str, list[str]]]:
+    async def schema(self, filter_default: bool = True) -> dict[str, dict[str, list[str]]]:
         """
         Asynchronous get schemata of databases and tables and columns.
 
@@ -178,23 +326,95 @@ class DatabaseSchemaAsync(DatabaseSchemaSuper['rdb.DatabaseAsync']):
         """
 
         # Get.
-        sql, filter_db = self._call__before(filter_default)
+        sql, filter_db = self.handle_before__call__(filter_default)
         result = await self.db.execute(sql, filter_db=filter_db)
-        schema_dict = self._call__after(result)
+        schema = self.handle_after__call__(result)
 
-        return schema_dict
+        # Cache.
+        if self.db._schema is not None:
+            self.db._schema.update(schema)
+
+        return schema
+
+
+    __call__ = schema
+
+
+    @overload
+    async def exist(
+        self,
+        database: str,
+        *,
+        refresh: bool = True
+    ) -> bool: ...
+
+    @overload
+    async def exist(
+        self,
+        database: str,
+        *,
+        table: str,
+        refresh: bool = True
+    ) -> bool: ...
+
+    @overload
+    async def exist(
+        self,
+        database: str,
+        table: str,
+        column: str,
+        refresh: bool = True
+    ) -> bool: ...
+
+    async def exist(
+        self,
+        database: str,
+        table: str | None = None,
+        column: str | None = None,
+        refresh: bool = True
+    ) -> bool:
+        """
+        Asynchronous judge database or table or column whether it exists.
+
+        Parameters
+        ----------
+        database : Database name.
+        table : Table name.
+        column : Column name.
+        refresh : Whether refresh cache data. Cache can improve efficiency.
 
+        Returns
+        -------
+        Judge result.
+        """
+
+        # Handle parameter.
+        if (
+            refresh
+            or self.db._schema is None
+        ):
+            schema = await self.schema()
+        else:
+            schema = self.db._schema
+
+        # Judge.
+        result = self.handle_exist(schema, database, table, column)
 
-class DatabaseParameters(DatabaseBase):
+        return result
+
+
+class DatabaseParametersSuper(DatabaseBase, Generic[DatabaseT]):
     """
-    Database parameters type.
+    Database parameters super type.
     """
 
+    mode: Literal['VARIABLES', 'STATUS']
+    glob: bool
+
 
     def __init__(
         self,
-        db: 'rdb.Database',
-        global_: bool
+        db: DatabaseT
     ) -> None:
         """
         Build instance attributes.
@@ -202,12 +422,16 @@ class DatabaseParameters(DatabaseBase):
         Parameters
         ----------
         db: Database instance.
-        global\\_ : Whether base global.
         """
 
         # Set parameter.
         self.db = db
-        self.global_ = global_
+
+
+class DatabaseParameters(DatabaseParametersSuper['rdb.Database']):
+    """
+    Database parameters type.
+    """
 
 
     def __getitem__(self, key: str) -> str | None:
@@ -246,12 +470,6 @@ class DatabaseParameters(DatabaseBase):
         self.update(params)
 
 
-class DatabaseParametersStatus(DatabaseParameters):
-    """
-    Database parameters status type.
-    """
-
-
     @overload
     def get(self) -> dict[str, str]: ...
 
@@ -274,14 +492,11 @@ class DatabaseParametersStatus(DatabaseParameters):
         """
 
         # Generate SQL.
-
-        ## Global.
-        if self.global_:
-            sql = 'SHOW GLOBAL STATUS'
-
-        ## Not global.
-        else:
-            sql = 'SHOW STATUS'
+        sql = 'SHOW ' + (
+            'GLOBAL '
+            if self.glob
+            else ''
+        ) + self.mode
 
         # Execute SQL.
 
@@ -312,25 +527,80 @@ class DatabaseParametersStatus(DatabaseParameters):
         params : Update parameter key value pairs.
         """
 
-        # Throw exception.
-        raise AssertionError('database status not update')
+        # Generate SQL.
+        sql_set_list = [
+            '%s = %s' % (
+                key,
+                (
+                    value
+                    if type(value) in (int, float)
+                    else "'%s'" % value
+                )
+            )
+            for key, value in params.items()
+        ]
+        sql_set = ',\n    '.join(sql_set_list)
+        sql = 'SHOW ' + (
+            'GLOBAL '
+            if self.glob
+            else ''
+        ) + sql_set
+
+        # Execute SQL.
+        self.db.execute(sql)
 
 
-class DatabaseParametersVariable(DatabaseParameters):
+class DatabaseParametersAsync(DatabaseParametersSuper['rdb.DatabaseAsync']):
     """
-    Database parameters variable type.
+    Asynchrouous database parameters type.
     """
 
 
+    async def __getitem__(self, key: str) -> str | None:
+        """
+        Asynchrouous get item of parameter dictionary.
+
+        Parameters
+        ----------
+        key : Parameter key.
+
+        Returns
+        -------
+        Parameter value.
+        """
+
+        # Get.
+        value = await self.get(key)
+
+        return value
+
+
+    async def __setitem__(self, key: str, value: str | float) -> None:
+        """
+        Asynchrouous set item of parameter dictionary.
+
+        Parameters
+        ----------
+        key : Parameter key.
+        value : Parameter value.
+        """
+
+        # Set.
+        params = {key: value}
+
+        # Update.
+        await self.update(params)
+
+
     @overload
-    def get(self) -> dict[str, str]: ...
+    async def get(self) -> dict[str, str]: ...
 
     @overload
-    def get(self, key: str) -> str | None: ...
+    async def get(self, key: str) -> str | None: ...
 
-    def get(self, key: str | None = None) -> dict[str, str] | str | None:
+    async def get(self, key: str | None = None) -> dict[str, str] | str | None:
         """
-        Get parameter.
+        Asynchrouous get parameter.
 
         Parameters
         ----------
@@ -340,48 +610,49 @@ class DatabaseParametersVariable(DatabaseParameters):
 
         Returns
         -------
-        Variables of database.
+        Status of database.
         """
 
         # Generate SQL.
-
-        ## Global.
-        if self.global_:
-            sql = 'SHOW GLOBAL VARIABLES'
-
-        ## Not global.
-        else:
-            sql = 'SHOW VARIABLES'
+        sql = 'SHOW ' + (
+            'GLOBAL '
+            if self.glob
+            else ''
+        ) + self.mode
 
         # Execute SQL.
 
         ## Dictionary.
         if key is None:
-            result = self.db.execute(sql, key=key)
-            variables = result.to_dict(val_field=1)
+            result = await self.db.execute(sql, key=key)
+            status = result.to_dict(val_field=1)
 
         ## Value.
         else:
             sql += ' LIKE :key'
-            result = self.db.execute(sql, key=key)
+            result = await self.db.execute(sql, key=key)
             row = result.first()
             if row is None:
-                variables = None
+                status = None
             else:
-                variables = row['Value']
+                status = row['Value']
 
-        return variables
+        return status
 
 
-    def update(self, params: dict[str, str | float]) -> None:
+    async def update(self, params: dict[str, str | float]) -> None:
         """
-        Update parameter.
+        Asynchrouous update parameter.
 
         Parameters
         ----------
         params : Update parameter key value pairs.
         """
 
+        # Check.
+        if self.mode == 'STATUS':
+            raise AssertionError('database status not update')
+
         # Generate SQL.
         sql_set_list = [
             '%s = %s' % (
@@ -395,14 +666,83 @@ class DatabaseParametersVariable(DatabaseParameters):
             for key, value in params.items()
         ]
         sql_set = ',\n    '.join(sql_set_list)
+        sql = 'SHOW ' + (
+            'GLOBAL '
+            if self.glob
+            else ''
+        ) + sql_set
 
-        ## Global.
-        if self.global_:
-            sql = f'SET GLOBAL {sql_set}'
+        # Execute SQL.
+        await self.db.execute(sql)
 
-        ## Not global.
-        else:
-            sql = f'SET {sql_set}'
 
-        # Execute SQL.
-        self.db.execute(sql)
+class DatabaseParametersVariables(DatabaseParameters):
+    """
+    Database variable parameters type.
+    """
+
+    mode: Final = 'VARIABLES'
+    glob: Final = False
+
+
+class DatabaseParametersStatus(DatabaseParameters):
+    """
+    Database status parameters type.
+    """
+
+    mode: Final = 'STATUS'
+    glob: Final = False
+
+
+class DatabaseParametersVariablesGlobal(DatabaseParameters):
+    """
+    Database global variable parameters type.
+    """
+
+    mode: Final = 'VARIABLES'
+    glob: Final = True
+
+
+class DatabaseParametersStatusGlobal(DatabaseParameters):
+    """
+    Database global status parameters type.
+    """
+
+    mode: Final = 'STATUS'
+    glob: Final = True
+
+
+class DatabaseParametersVariablesAsync(DatabaseParametersAsync):
+    """
+    Asynchrouous database variable parameters type.
+    """
+
+    mode: Final = 'VARIABLES'
+    glob: Final = False
+
+
+class DatabaseParametersStatusAsync(DatabaseParametersAsync):
+    """
+    Asynchrouous database status parameters type.
+    """
+
+    mode: Final = 'STATUS'
+    glob: Final = False
+
+
+class DatabaseParametersVariablesGlobalAsync(DatabaseParametersAsync):
+    """
+    Asynchrouous database global variable parameters type.
+    """
+
+    mode: Final = 'VARIABLES'
+    glob: Final = True
+
+
+class DatabaseParametersStatusGlobalAsync(DatabaseParametersAsync):
+    """
+    Asynchrouous database global status parameters type.
+    """
+
+    mode: Final = 'STATUS'
+    glob: Final = True

{reydb-1.1.60.dist-info → reydb-1.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reydb
-Version: 1.1.60
+Version: 1.2.0
 Summary: Database method set.
 Project-URL: homepage, https://github.com/reyxbo/reydb/
 Author-email: Rey <reyxbo@163.com>

reydb-1.2.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+reydb/__init__.py,sha256=G2U0uiNjk2koYxIZjf9zvHoiQFO485XMnfQBMYSUdRc,549
+reydb/rall.py,sha256=sOeiVXSIo2voFiiZaRx8h7_wWrx8fFjXkRQRSYHQccA,365
+reydb/rbase.py,sha256=0QGHxbdrcyDTY6BK7zMCTM9cRDkZyVNlL7S1j7A4Zp0,8260
+reydb/rbuild.py,sha256=R_WQNpp67oHZFZlRuui_vaZAlJL4s_y5NX0gJXZY1yA,40320
+reydb/rconfig.py,sha256=mVRrkWa35stM5_sB0rD7VtgqLkVDv0BDnV_u2AGh0kI,18962
+reydb/rconn.py,sha256=guRaR8N6RuzZzujwaeq7HhKWTizF9SrUBqEAFjfjpoo,6909
+reydb/rdb.py,sha256=QB9het4tAPnJo4urWJ4oePI1g1avNI8O1P0-VPJLDEo,13809
+reydb/rerror.py,sha256=LlEmKREe88QKLU3xf4mF88nXnGSQodrUruQAm9ifUeQ,14781
+reydb/rexec.py,sha256=NLSvwwFhf60OndW3pjffzyMbWcLykhTbBbfI1YSueQ8,53223
+reydb/rorm.py,sha256=IipUvaFnS0gfHxzYkNSuM60skYsIGNBA9DvD8DnTpCc,40885
+reydb/rparam.py,sha256=S32dAKrCM0c4Qm-fhZkIRRhshsK1MmI12NgavNBfvJg,17443
+reydb-1.2.0.dist-info/METADATA,sha256=0wocK72W-r7ZRvnaiZ4JFfJ9RLVCkXs2u6yrx1foDFw,1621
+reydb-1.2.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+reydb-1.2.0.dist-info/licenses/LICENSE,sha256=UYLPqp7BvPiH8yEZduJqmmyEl6hlM3lKrFIefiD4rvk,1059
+reydb-1.2.0.dist-info/RECORD,,