reydb 1.1.61__py3-none-any.whl → 1.2.1__py3-none-any.whl

reydb/{rparam.py → rinfo.py}

@@ -5,7 +5,7 @@
 @Time    : 2022-12-05 14:10:02
 @Author  : Rey
 @Contact : reyxbo@163.com
-@Explain : Database parameter methods.
+@Explain : Database information methods.
 """
 
 
@@ -17,29 +17,36 @@ from .rexec import Result
 
 
 __all__ = (
-    'DatabaseSchemaSuper',
-    'DatabaseSchema',
-    'DatabaseSchemaAsync',
-    'DatabaseParametersSuper',
-    'DatabaseParameters',
-    'DatabaseParametersAsync',
-    'DatabaseParametersVariables',
-    'DatabaseParametersStatus',
-    'DatabaseParametersVariablesGlobal',
-    'DatabaseParametersStatusGlobal',
-    'DatabaseParametersVariablesAsync',
-    'DatabaseParametersStatusAsync',
-    'DatabaseParametersVariablesGlobalAsync',
-    'DatabaseParametersStatusGlobalAsync'
+    'DatabaseInformationBase',
+    'DatabaseInformationSchemaSuper',
+    'DatabaseInformationSchema',
+    'DatabaseInformationSchemaAsync',
+    'DatabaseInformationParameterSuper',
+    'DatabaseInformationParameter',
+    'DatabaseInformationParameterAsync',
+    'DatabaseInformationParameterVariables',
+    'DatabaseInformationParameterStatus',
+    'DatabaseInformationParameterVariablesGlobal',
+    'DatabaseInformationParameterStatusGlobal',
+    'DatabaseInformationParameterVariablesAsync',
+    'DatabaseInformationParameterStatusAsync',
+    'DatabaseInformationParameterVariablesGlobalAsync',
+    'DatabaseInformationParameterStatusGlobalAsync'
 )
 
 
 DatabaseT = TypeVar('DatabaseT', 'rdb.Database', 'rdb.DatabaseAsync')
 
 
-class DatabaseSchemaSuper(DatabaseBase, Generic[DatabaseT]):
+class DatabaseInformationBase(DatabaseBase):
     """
-    Database schema super type.
+    Database information base type.
+    """
+
+
+class DatabaseInformationSchemaSuper(DatabaseInformationBase, Generic[DatabaseT]):
+    """
+    Database information schema super type.
     """
 
 
@@ -55,10 +62,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
         ----------
@@ -98,9 +104,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
         ----------
@@ -141,13 +147,80 @@ class DatabaseSchemaSuper(DatabaseBase, Generic[DatabaseT]):
         return schema_dict
 
 
-class DatabaseSchema(DatabaseSchemaSuper['rdb.Database']):
+    @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 DatabaseInformationSchema(DatabaseInformationSchemaSuper['rdb.Database']):
     """
-    Database schema type.
+    Database information 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.
 
@@ -161,20 +234,92 @@ 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.
+        """
 
-class DatabaseSchemaAsync(DatabaseSchemaSuper['rdb.DatabaseAsync']):
+        # 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 DatabaseInformationSchemaAsync(DatabaseInformationSchemaSuper['rdb.DatabaseAsync']):
     """
-    Asynchronous database schema type.
+    Asynchronous database information schema type.
     """
 
 
-    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.
 
@@ -188,16 +333,86 @@ 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)
+
+        return result
 
 
-class DatabaseParametersSuper(DatabaseBase, Generic[DatabaseT]):
+class DatabaseInformationParameterSuper(DatabaseInformationBase, Generic[DatabaseT]):
     """
-    Database parameters super type.
+    Database information parameters super type.
     """
 
     mode: Literal['VARIABLES', 'STATUS']
@@ -220,9 +435,9 @@ class DatabaseParametersSuper(DatabaseBase, Generic[DatabaseT]):
         self.db = db
 
 
-class DatabaseParameters(DatabaseParametersSuper['rdb.Database']):
+class DatabaseInformationParameter(DatabaseInformationParameterSuper['rdb.Database']):
     """
-    Database parameters type.
+    Database information parameters type.
     """
 
 
@@ -342,9 +557,9 @@ class DatabaseParameters(DatabaseParametersSuper['rdb.Database']):
         self.db.execute(sql)
 
 
-class DatabaseParametersAsync(DatabaseParametersSuper['rdb.DatabaseAsync']):
+class DatabaseInformationParameterAsync(DatabaseInformationParameterSuper['rdb.DatabaseAsync']):
     """
-    Asynchrouous database parameters type.
+    Asynchrouous database information parameters type.
     """
 
 
@@ -468,72 +683,72 @@ class DatabaseParametersAsync(DatabaseParametersSuper['rdb.DatabaseAsync']):
         await self.db.execute(sql)
 
 
-class DatabaseParametersVariables(DatabaseParameters):
+class DatabaseInformationParameterVariables(DatabaseInformationParameter):
     """
-    Database variable parameters type.
+    Database information variable parameters type.
     """
 
     mode: Final = 'VARIABLES'
     glob: Final = False
 
 
-class DatabaseParametersStatus(DatabaseParameters):
+class DatabaseInformationParameterStatus(DatabaseInformationParameter):
     """
-    Database status parameters type.
+    Database information status parameters type.
     """
 
     mode: Final = 'STATUS'
     glob: Final = False
 
 
-class DatabaseParametersVariablesGlobal(DatabaseParameters):
+class DatabaseInformationParameterVariablesGlobal(DatabaseInformationParameter):
     """
-    Database global variable parameters type.
+    Database information global variable parameters type.
     """
 
     mode: Final = 'VARIABLES'
     glob: Final = True
 
 
-class DatabaseParametersStatusGlobal(DatabaseParameters):
+class DatabaseInformationParameterStatusGlobal(DatabaseInformationParameter):
     """
-    Database global status parameters type.
+    Database information global status parameters type.
     """
 
     mode: Final = 'STATUS'
     glob: Final = True
 
 
-class DatabaseParametersVariablesAsync(DatabaseParametersAsync):
+class DatabaseInformationParameterVariablesAsync(DatabaseInformationParameterAsync):
     """
-    Asynchrouous database variable parameters type.
+    Asynchrouous database information variable parameters type.
     """
 
     mode: Final = 'VARIABLES'
     glob: Final = False
 
 
-class DatabaseParametersStatusAsync(DatabaseParametersAsync):
+class DatabaseInformationParameterStatusAsync(DatabaseInformationParameterAsync):
     """
-    Asynchrouous database status parameters type.
+    Asynchrouous database information status parameters type.
     """
 
     mode: Final = 'STATUS'
     glob: Final = False
 
 
-class DatabaseParametersVariablesGlobalAsync(DatabaseParametersAsync):
+class DatabaseInformationParameterVariablesGlobalAsync(DatabaseInformationParameterAsync):
     """
-    Asynchrouous database global variable parameters type.
+    Asynchrouous database information global variable parameters type.
     """
 
     mode: Final = 'VARIABLES'
     glob: Final = True
 
 
-class DatabaseParametersStatusGlobalAsync(DatabaseParametersAsync):
+class DatabaseInformationParameterStatusGlobalAsync(DatabaseInformationParameterAsync):
     """
-    Asynchrouous database global status parameters type.
+    Asynchrouous database information global status parameters type.
     """
 
     mode: Final = 'STATUS'