deepfos 1.1.5__tar.gz → 1.1.6__tar.gz

deepfos-1.1.6/MANIFEST.in

@@ -0,0 +1,5 @@
+include versioneer.py
+include deepfos/_version.py
+include *.pyi
+recursive-include deepfos/boost *.pyx
+recursive-include deepfos/boost *.c

{deepfos-1.1.5 → deepfos-1.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: deepfos
-Version: 1.1.5
+Version: 1.1.6
 Summary: Collecions of useful and handy tools for deepfos platform
 Home-page: http://py.deepfos.com
 Author: deepfos-python-team

{deepfos-1.1.5 → deepfos-1.1.6}/README.md

@@ -34,4 +34,5 @@ DeepFOS SDK for Python
 [@陈熙](https://e.gitee.com/proinnova/members/trend/axisarsae)
 [@陈思聪](https://e.gitee.com/proinnova/members/trend/proinnova_sicong_chen)
 [@杨璟](https://e.gitee.com/proinnova/members/trend/jyang-0506)
+[@李扬](https://e.gitee.com/proinnova/members/trend/ryan_li1384)
 [@陈文雍](https://e.gitee.com/proinnova/members/trend/calvinstk)

{deepfos-1.1.5 → deepfos-1.1.6}/deepfos/api/base.py

@@ -21,7 +21,7 @@ from deepfos.cache import Manager, AppSeperatedLRUCache
 from deepfos.lib.httpcli import AioHttpCli
 from deepfos.lib.utils import concat_url, retry, to_version_tuple, repr_version
 from deepfos.lib.asynchronous import evloop
-from deepfos.lib.eureka import Eureka
+from deepfos.lib.discovery import ServiceDiscovery
 from deepfos.lib.constant import UNSET, RE_SYS_SERVER_PARSER
 from deepfos.options import OPTION
 from deepfos.exceptions import APIResponseError, APIRequestError
@@ -352,6 +352,11 @@ class Route:
                 req.update_default(func(ins, *args, **kwargs))
                 url, body, ext_header = req.url, req.body, req.header
                 raw_result = model is None
+                has_req_callback = (
+                        isinstance(ins.root, _DynamicAPIMixin)
+                        and ins.root.on_success is not None
+                        and ins.root.on_failure is not None
+                )
 
                 if ext_header is None:
                     header = ins.header
@@ -416,6 +421,9 @@ class Route:
                 except OSError as e:  # pragma: no cover
                     if not OPTION.api.dump_always and OPTION.api.dump_on_failure:
                         req.to_curl(header)
+
+                    if has_req_callback:
+                        ins.root.on_failure()
                     raise APIRequestError(e) from None
 
                 # -----------------------------------------------------------------------------
@@ -433,7 +441,12 @@ class Route:
                     )
                     flag, obj, err = False, None, f"[code: {status_code}] ErrMsg from server: {text}"
 
+                    if has_req_callback:
+                        ins.root.on_failure()
+
                 else:
+                    if has_req_callback:
+                        ins.root.on_success()
                     try:
                         resp = json.loads(text)
                         if 'status' not in resp:
@@ -572,6 +585,8 @@ class _DynamicAPIMixin:
     module_type: str = UNSET
     server_known = False
     version = None
+    on_success = None
+    on_failure = None
 
     def get_module_id(self, version: Union[float, str], module_id: str):
         if (module_type := self.module_type) is UNSET:
@@ -626,10 +641,10 @@ class DynamicAPIBase(SyncAPIBase, _DynamicAPIMixin):
         return self._add_to_memo(server_meta)
 
     def set_url(self, server_name):
-        if OPTION.general.use_eureka:  # pragma: no cover
-            system_env = OPTION.general.task_info.get('system_env') or ''
-            server_name = f"{system_env}{server_name}"
-            self.base_url = concat_url(Eureka.sync_get_url(server_name), self.endpoint)
+        if OPTION.discovery.enabled:  # pragma: no cover
+            discovery = ServiceDiscovery.instantiate()
+            self.on_success, self.on_failure, base_url = discovery.sync_get_url(server_name, include_cb=True)
+            self.base_url = concat_url(base_url, self.endpoint)
             self.server_known = True
         else:
             super().set_url(server_name)
@@ -669,10 +684,10 @@ class ADynamicAPIBase(AsyncAPIBase, _DynamicAPIMixin):
         return self
 
     async def set_url(self, server_name):
-        if OPTION.general.use_eureka:  # pragma: no cover
-            system_env = OPTION.general.task_info.get('system_env') or ''
-            server_name = f"{system_env}{server_name}"
-            self.base_url = concat_url(await Eureka.get_url(server_name), self.endpoint)
+        if OPTION.discovery.enabled:  # pragma: no cover
+            discovery = ServiceDiscovery.instantiate()
+            self.on_success, self.on_failure, base_url = await discovery.get_url(server_name, include_cb=True)
+            self.base_url = concat_url(base_url, self.endpoint)
             self.server_known = True
         else:
             super().set_url(server_name)

{deepfos-1.1.5 → deepfos-1.1.6}/deepfos/core/cube/_base.py

@@ -1,6 +1,6 @@
 from collections import deque
 from contextlib import contextmanager
-from typing import Dict, List, Sequence, Optional, Union, Deque
+from typing import Dict, List, Sequence, Optional, Union, Deque, ContextManager
 
 import numpy as np
 import pandas as pd
@@ -299,7 +299,7 @@ class CubeBase:
         self,
         general_fix: str = None,
         on_dim: str = None,
-    ) -> CubeFixer:
+    ) -> ContextManager[CubeFixer]:
         """
         执行成员公式
 

{deepfos-1.1.5 → deepfos-1.1.6}/deepfos/core/logictable/tablemodel.py

@@ -7,12 +7,7 @@ from ._operator import OpCombineError
 from loguru import logger
 from deepfos.lib.decorator import cached_property
 from deepfos.element.datatable import (
-    DataTableMySQL, DataTableClickHouse,
-    DataTableOracle, DataTableSQLServer, DataTableDeepEngine, DataTablePostgreSQL, DataTableDaMeng,
-    DataTableGauss, DataTableKingBase,
-    AsyncDataTableMySQL, AsyncDataTableClickHouse, AsyncDataTableOracle, AsyncDataTableSQLServer,
-    AsyncDataTableKingBase, AsyncDataTableGauss, AsyncDataTableDaMeng, AsyncDataTablePostgreSQL,
-    AsyncDataTableDeepEngine, get_table_class
+    get_table_class, T_DatatableInstance, T_AsyncDatatableInstance
 )
 from deepfos.api.models.app import ConfirmElementInfoDto
 import pandas as pd
@@ -23,16 +18,6 @@ from contextlib import contextmanager
 from collections import defaultdict
 import copy
 
-T_AbsDataTable = Union[
-    DataTableMySQL, DataTableClickHouse, DataTableOracle, DataTableSQLServer,
-    DataTableKingBase, DataTableGauss, DataTableDaMeng, DataTablePostgreSQL, DataTableDeepEngine
-]
-T_AbsAsyncDataTable = Union[
-    AsyncDataTableMySQL, AsyncDataTableClickHouse, AsyncDataTableOracle, AsyncDataTableSQLServer,
-    AsyncDataTableKingBase, AsyncDataTableGauss, AsyncDataTableDaMeng, AsyncDataTablePostgreSQL,
-    AsyncDataTableDeepEngine
-]
-
 
 # -----------------------------------------------------------------------------
 # utils
@@ -41,7 +26,10 @@ class TableInfo(ConfirmElementInfoDto):
     serverName: Optional[str]
 
 
-def get_datatable(table_info: Union[TableInfo, dict], sync=True) -> Union[T_AbsDataTable, T_AbsAsyncDataTable]:
+def get_datatable(
+    table_info: Union[TableInfo, dict],
+    sync=True
+) -> Union[T_DatatableInstance, T_AsyncDatatableInstance]:
     if isinstance(table_info, TableInfo):
         init_args = {
             'element_name': table_info.elementName,
@@ -196,7 +184,7 @@ class MetaTable(MetaNodeMixin):
         super().__init__(cls_name, supercls, attrdict)
 
     @cached_property
-    def datatable(cls) -> T_AbsDataTable:
+    def datatable(cls) -> T_DatatableInstance:
         """数据表元素"""
         if cls.__datatable is not None:
             return cls.__datatable
@@ -207,7 +195,7 @@ class MetaTable(MetaNodeMixin):
         return tbl
 
     @cached_property
-    def async_datatable(cls) -> T_AbsAsyncDataTable:
+    def async_datatable(cls) -> T_AsyncDatatableInstance:
         """异步数据表元素"""
         if cls.__async_datatable is not None:
             return cls.__async_datatable

{deepfos-1.1.5 → deepfos-1.1.6}/deepfos/db/connector.py

@@ -59,6 +59,7 @@ class MySQLAPIConnector(AbstractConnector):
     ):
         self._v = version
 
+    @cache_async
     async def build_api(self) -> MySQLAPI:
         return await APIFinder().find_api(MySQLAPI, version=self._v)
 
@@ -89,6 +90,7 @@ class ClickHouseAPIConnector(MySQLAPIConnector):
     async def trxn_execute(self, sqls: List[str]):
         raise NotImplementedError('ClickHouse does not support transaction')
 
+    @cache_async
     async def build_api(self) -> ClickHouseAPI:
         return await APIFinder().find_api(ClickHouseAPI, version=self._v)
 
@@ -135,36 +137,43 @@ class ClickHouseDirectAccess(AbstractConnector):
 
 
 class SQLServerAPIConnector(MySQLAPIConnector):
+    @cache_async
     async def build_api(self) -> SQLServerAPI:
         return await APIFinder().find_api(SQLServerAPI, version=self._v)
 
 
 class OracleAPIConnector(MySQLAPIConnector):
+    @cache_async
     async def build_api(self) -> OracleAPI:
         return await APIFinder().find_api(OracleAPI, version=self._v)
 
 
 class KingBaseAPIConnector(MySQLAPIConnector):
+    @cache_async
     async def build_api(self) -> KingBaseAPI:
         return await APIFinder().find_api(KingBaseAPI, version=self._v)
 
 
 class GaussAPIConnector(MySQLAPIConnector):
+    @cache_async
     async def build_api(self) -> GaussAPI:
         return await APIFinder().find_api(GaussAPI, version=self._v)
 
 
 class DaMengAPIConnector(MySQLAPIConnector):
+    @cache_async
     async def build_api(self) -> DaMengAPI:
         return await APIFinder().find_api(DaMengAPI, version=self._v)
 
 
 class PostgreSQLAPIConnector(MySQLAPIConnector):
+    @cache_async
     async def build_api(self) -> PostgreSQLAPI:
         return await APIFinder().find_api(PostgreSQLAPI, version=self._v)
 
 
 class DeepEngineAPIConnector(ClickHouseAPIConnector):
+    @cache_async
     async def build_api(self) -> DeepEngineAPI:
         return await APIFinder().find_api(DeepEngineAPI, version=self._v)
 

{deepfos-1.1.5 → deepfos-1.1.6}/deepfos/db/dbkits.py

@@ -244,8 +244,9 @@ class DataframeSQLConvertor:
         Returns:
             sql语句生成器
 
-        See Also:
-            :func:`df_to_sql`
+        Attention:
+            当单个DataFrame生成的sql太长导致无法入库，可以指定 ``chuncksize`` ，
+            使DataFrame生成多条sql。
 
         """
         # 获取sql
@@ -262,11 +263,36 @@ class DataframeSQLConvertor:
 
     @classmethod
     def _quote_escape(cls, value):
-        if value is null:
-            return null
+        if pd.isna(value):
+            return value
         if not isinstance(value, str):
             return str(value)
         return f"'{cls.escape_string(value)}'"
+    
+    @staticmethod
+    def format_datetime(maybe_datetime: pd.Series) -> pd.Series:
+        return "'" + maybe_datetime.dt.strftime("%Y-%m-%d %H:%M:%S") + "'"
+
+    @classmethod
+    def format_series(cls, series: pd.Series) -> pd.Series:
+        """格式化Series以适合sql语句
+        
+        1. 日期型重置格式到秒级别
+        2. 字符串型列转义、加引号
+
+        Args:
+            series (pd.Series): 需要格式化的Series
+
+        Returns:
+            pd.Series: 格式化后的新的Series，不影响原Series
+        """
+        # 对日期型重置格式到秒级别
+        if is_datetime64_dtype(series.dtype):
+            return cls.format_datetime(series)
+        # 对字符串型列转义，加引号
+        elif not is_numeric_dtype(series.dtype):
+            return series.apply(cls._quote_escape)
+        return series.copy()
 
     def convert(
         self,
@@ -288,41 +314,20 @@ class DataframeSQLConvertor:
         Returns:
             sql语句
 
-        See Also:
-            如果单条sql语句太长导致无法入库，可以使用 :func:`gen_sql`，
-            指定 ``chuncksize`` ，该方法将把一条较大的sql拆分成多条执行。
-
         """
         if dataframe.empty:
             return ''
-
-        data_df = dataframe.copy()
-        # 获取日期型与非数字型的列
-        datetime_col = [is_datetime64_dtype(x) for x in data_df.dtypes]  # 获取日期型的列
-        # 对日期型重置格式到秒级别
-        data_df.loc[:, datetime_col] = data_df.loc[:, datetime_col] \
-            .apply(lambda x: np.where(x.isna(), np.NAN, self.format_datetime(x)))
-
+        # 格式化Series以适合sql语句
+        data_df = dataframe.apply(self.format_series)
         # 空值填充
         data_df = data_df.fillna(null)
-        # 获取非数字型的列
-        str_like_cols = [
-            (not (is_numeric_dtype(x) or is_datetime))
-            for x, is_datetime in zip(data_df.dtypes, datetime_col)
-        ]
-        # 对字符串型列转义，加引号
-        data_df.loc[:, str_like_cols] = data_df.loc[:, str_like_cols].applymap(self._quote_escape)
         # 全部转化为字符串类型
         data_df = data_df.astype(str, errors='ignore')
         values = "(" + pd.Series(data_df.values.tolist()).str.join(',') + ")"
         columns = self.build_column_string(dataframe.columns)
         return self.build_sql(columns, values, tablename, updatecol, **opts)
 
-    @staticmethod
-    def format_datetime(maybe_datetime):
-        return "'" + maybe_datetime.dt.strftime("%Y-%m-%d %H:%M:%S") + "'"
-
-    def build_column_string(self, columns):
+    def build_column_string(self, columns: pd.Index) -> str:
         if self.quote_char:
             columns = ','.join(columns.map(
                 lambda x: f'{self.quote_char}{x}{self.quote_char}'

{deepfos-1.1.5 → deepfos-1.1.6}/deepfos/element/apvlprocess.py

@@ -1,8 +1,8 @@
 from typing import List, Dict, Optional, Union, Tuple, TYPE_CHECKING, Any  # noqa
 
 from .base import ElementBase, SyncMeta
-from .datatable import (DataTableMySQL, DataTableClickHouse, get_table_class, AsyncDataTableMySQL,
-                        AsyncDataTableClickHouse)
+from .datatable import (DataTableMySQL, get_table_class, AsyncDataTableMySQL,
+                        T_AsyncDatatableInstance, T_DatatableInstance)
 from deepfos.lib.decorator import cached_property
 from deepfos.lib.constant import UNSET
 from deepfos.api.approval_process import ApprovalProcessAPI
@@ -34,20 +34,27 @@ class AsyncApprovalProcess(ElementBase[ApprovalProcessAPI]):
         return meta
 
     @cached_property
-    def record_table(self) -> Union[DataTableMySQL, DataTableClickHouse]:
+    def record_table(self) -> T_DatatableInstance:
         """审批记录表"""
         ctrl_info = self.meta.processInfo.controlInfo
-        cls = get_table_class(ctrl_info.approvalRecordTableElementType)
+        if (ele_type := ctrl_info.approvalRecordTableElementType) is None:
+            cls = DataTableMySQL
+        else:
+            cls = get_table_class(ele_type)
         return cls(
             element_name=ctrl_info.approvalRecordTableName,
             folder_id=ctrl_info.approvalRecordTableFolderId,
-            path=ctrl_info.approvalRecordTablePath)
+            path=ctrl_info.approvalRecordTablePath
+        )
 
     @cached_property
-    def async_record_table(self) -> Union[AsyncDataTableMySQL, AsyncDataTableClickHouse]:
+    def async_record_table(self) -> T_AsyncDatatableInstance:
         """审批记录表"""
         ctrl_info = self.meta.processInfo.controlInfo
-        cls = get_table_class(ctrl_info.approvalRecordTableElementType, sync=False)
+        if (ele_type := ctrl_info.approvalRecordTableElementType) is None:
+            cls = AsyncDataTableMySQL
+        else:
+            cls = get_table_class(ele_type, sync=False)
         return cls(
             element_name=ctrl_info.approvalRecordTableName,
             folder_id=ctrl_info.approvalRecordTableFolderId,

{deepfos-1.1.5 → deepfos-1.1.6}/deepfos/element/bizmodel.py

@@ -438,7 +438,7 @@ class AsyncBusinessModel(ElementBase[BusinessModelAPI]):
             primary_kv = {**primary_kv}
         return primary_kv
 
-    def copy_rows(
+    async def copy_rows(
         self,
         config: Union[CopyConfig, Dict]
     ):
@@ -485,8 +485,8 @@ class AsyncBusinessModel(ElementBase[BusinessModelAPI]):
             config = CopyConfig().load_config(config)
 
         for table, conf in config.items():
-            dt = self.logic_tables[table].datatable
-            dt.copy_rows(**conf)
+            dt = self.logic_tables[table].async_datatable
+            await dt.copy_rows(**conf)
 
     @deprecated(
         replacement='set_approval_ex',
@@ -1183,6 +1183,7 @@ class BusinessModel(AsyncBusinessModel, metaclass=SyncMeta):
         'set_approval_ex',
         'save',
         'attach',
+        'copy_rows'
     )
 
     if TYPE_CHECKING:  # pragma: no cover
@@ -1233,30 +1234,36 @@ class BusinessModel(AsyncBusinessModel, metaclass=SyncMeta):
             ...
 
         def save(
-                self,
-                data: Union[pd.DataFrame, Dict[str, pd.DataFrame]],
-                allow_detached_data: bool = True,
-                allow_detached_table: bool = False,
-                auto_format: bool = True,
-                check_db: bool = True,
-                check_logical: bool = True,
-                check_field: bool = True,
-                enable_pre_save: bool = True,
-                enable_post_save: bool = True,
+            self,
+            data: Union[pd.DataFrame, Dict[str, pd.DataFrame]],
+            allow_detached_data: bool = True,
+            allow_detached_table: bool = False,
+            auto_format: bool = True,
+            check_db: bool = True,
+            check_logical: bool = True,
+            check_field: bool = True,
+            enable_pre_save: bool = True,
+            enable_post_save: bool = True,
         ) -> List[ModelDataReturnDTO]:
             ...
 
         def attach(
-                self,
-                data: Union[pd.DataFrame, Dict[str, pd.DataFrame]],
-                primary_kv: Union[Any, Dict[str, Any]],
-                parent_kv: Union[Any, Dict[str, Any]] = None,
-                allow_detached_data: bool = True,
-                allow_detached_table: bool = False,
-                check_db: bool = True,
-                check_logical: bool = True,
-                check_field: bool = True,
-                enable_pre_save: bool = True,
-                enable_post_save: bool = True,
+            self,
+            data: Union[pd.DataFrame, Dict[str, pd.DataFrame]],
+            primary_kv: Union[Any, Dict[str, Any]],
+            parent_kv: Union[Any, Dict[str, Any]] = None,
+            allow_detached_data: bool = True,
+            allow_detached_table: bool = False,
+            check_db: bool = True,
+            check_logical: bool = True,
+            check_field: bool = True,
+            enable_pre_save: bool = True,
+            enable_post_save: bool = True,
         ) -> List[ModelDataReturnDTO]:
             ...
+
+        def copy_rows(
+            self,
+            config: Union[CopyConfig, Dict]
+        ):
+            ...

{deepfos-1.1.5 → deepfos-1.1.6}/deepfos/element/datatable.py

@@ -1,3 +1,4 @@
+import re
 import warnings
 from contextvars import ContextVar
 import pprint
@@ -58,6 +59,10 @@ __all__ = [
     'Skip',
     'Field',
     'get_table_class',
+    'T_DatatableClass',
+    'T_DatatableInstance',
+    'T_AsyncDatatableClass',
+    'T_AsyncDatatableInstance'
 ]
 
 SQL_LOG_MAX_LEN = 1024
@@ -933,7 +938,10 @@ class AsyncDataTableMySQL(ElementBase):
             if isinstance(c, str):
                 res.append(c)
             elif isinstance(c, Term):
-                res.append(c.get_sql(quote_char=''))
+                if c.alias is not None:
+                    res.append(c.alias)
+                else:
+                    res.append(c.get_sql(quote_char=''))
             else:
                 res.append(str(c))
         return res
@@ -1963,7 +1971,7 @@ class _OracleField(Field):
         quote_char = kwargs.pop("quote_char", '"')
 
         field_sql = format_quotes(self.name, quote_char)
-
+        field_sql = field_sql.upper()
         # Need to add namespace if the table has an alias
         if self.table and (with_namespace or self.table.alias):
             table_name = self.table.get_table_name()
@@ -1972,7 +1980,6 @@ class _OracleField(Field):
                 name=field_sql,
             )
 
-        field_sql = field_sql.upper()
         field_alias = getattr(self, "alias", None)
         if with_alias:
             return format_alias_sql(field_sql, field_alias, quote_char=quote_char, **kwargs)
@@ -1981,7 +1988,7 @@ class _OracleField(Field):
 
 class OracleTable(Table):
     def field(self, name: str) -> Field:
-        return _OracleField(name, table=self)
+        return _OracleField(name, table=self, alias=name)
 
 
 class AsyncDataTableOracle(AsyncDataTableMySQL):
@@ -2265,19 +2272,38 @@ class DataTableDeepEngine(
         raise NotImplementedError('DeepEngine does not support transaction.')
 
 
-def get_table_class(
-    element_type: str,
-    sync: bool = True
-) -> Union[
-    Type[AsyncDataTableMySQL],
-    Type[AsyncDataTableClickHouse],
-    Type[AsyncDataTableOracle],
-    Type[AsyncDataTableSQLServer],
-    Type[AsyncDataTableKingBase],
-    Type[AsyncDataTableGauss],
-    Type[AsyncDataTableDaMeng],
-    Type[AsyncDataTablePostgreSQL],
-    Type[AsyncDataTableDeepEngine],
+_RE_PARSE_SERVER = re.compile(r"data[-]?table-(.*?)-server[\d]-[\d]")
+
+
+TO_MODULE_TYPE = CaseInsensitiveDict(
+    {
+        'mysql': MySQLAPI.module_type,
+        'clickhouse': ClickHouseAPI.module_type,
+        'sqlserver': SQLServerAPI.module_type,
+        'oracle': OracleAPI.module_type,
+        'kingbase': KingBaseAPI.module_type,
+        'gauss': GaussAPI.module_type,
+        'dameng': DaMengAPI.module_type,
+        'postgresql': PostgreSQLAPI.module_type,
+        'deepengine': DeepEngineAPI.module_type,
+    }
+)
+
+TABLE = CaseInsensitiveDict(
+    {
+        MySQLAPI.module_type: (DataTableMySQL, AsyncDataTableMySQL),
+        ClickHouseAPI.module_type: (DataTableClickHouse, AsyncDataTableClickHouse),
+        SQLServerAPI.module_type: (DataTableSQLServer, AsyncDataTableSQLServer),
+        OracleAPI.module_type: (DataTableOracle, AsyncDataTableOracle),
+        KingBaseAPI.module_type: (DataTableKingBase, AsyncDataTableKingBase),
+        GaussAPI.module_type: (DataTableGauss, AsyncDataTableGauss),
+        DaMengAPI.module_type: (DataTableDaMeng, AsyncDataTableDaMeng),
+        PostgreSQLAPI.module_type: (DataTablePostgreSQL, AsyncDataTablePostgreSQL),
+        DeepEngineAPI.module_type: (DataTableDeepEngine, AsyncDataTableDeepEngine),
+    }
+)
+
+T_DatatableClass = Union[
     Type[DataTableMySQL],
     Type[DataTableClickHouse],
     Type[DataTableOracle],
@@ -2286,13 +2312,58 @@ def get_table_class(
     Type[DataTableGauss],
     Type[DataTableDaMeng],
     Type[DataTablePostgreSQL],
-    Type[DataTableDeepEngine],
+    Type[DataTableDeepEngine]
+]
+
+T_AsyncDatatableClass = Union[
+    Type[AsyncDataTableMySQL],
+    Type[AsyncDataTableClickHouse],
+    Type[AsyncDataTableOracle],
+    Type[AsyncDataTableSQLServer],
+    Type[AsyncDataTableKingBase],
+    Type[AsyncDataTableGauss],
+    Type[AsyncDataTableDaMeng],
+    Type[AsyncDataTablePostgreSQL],
+    Type[AsyncDataTableDeepEngine]
+]
+
+T_DatatableInstance = Union[
+    DataTableMySQL,
+    DataTableClickHouse,
+    DataTableOracle,
+    DataTableSQLServer,
+    DataTableKingBase,
+    DataTableGauss,
+    DataTableDaMeng,
+    DataTablePostgreSQL,
+    DataTableDeepEngine
+]
+
+T_AsyncDatatableInstance = Union[
+    AsyncDataTableMySQL,
+    AsyncDataTableClickHouse,
+    AsyncDataTableOracle,
+    AsyncDataTableSQLServer,
+    AsyncDataTableKingBase,
+    AsyncDataTableGauss,
+    AsyncDataTableDaMeng,
+    AsyncDataTablePostgreSQL,
+    AsyncDataTableDeepEngine
+]
+
+
+def get_table_class(
+    element_type: str,
+    sync: bool = True
+) -> Union[
+    T_DatatableClass,
+    T_AsyncDatatableClass
 ]:
     """
     根据元素类型获取对应的数据表元素类
 
     Args:
-        element_type: 元素类型
+        element_type: module type或server name
         sync: 同步或异步元素类，默认同步
 
     """
@@ -2301,19 +2372,21 @@ def get_table_class(
     else:
         index = 1
 
-    table = {
-        MySQLAPI.module_type: (DataTableMySQL, AsyncDataTableMySQL),
-        ClickHouseAPI.module_type: (DataTableClickHouse, AsyncDataTableClickHouse),
-        SQLServerAPI.module_type: (DataTableSQLServer, AsyncDataTableSQLServer),
-        OracleAPI.module_type: (DataTableOracle, AsyncDataTableOracle),
-        KingBaseAPI.module_type: (DataTableKingBase, AsyncDataTableKingBase),
-        GaussAPI.module_type: (DataTableGauss, AsyncDataTableGauss),
-        DaMengAPI.module_type: (DataTableDaMeng, AsyncDataTableDaMeng),
-        PostgreSQLAPI.module_type: (DataTablePostgreSQL, AsyncDataTablePostgreSQL),
-        DeepEngineAPI.module_type: (DataTableDeepEngine, AsyncDataTableDeepEngine),
-    }.get(element_type.upper())
+    if element_type is None:
+        raise ValueError("`element_type` should be a string value.")
+
+    module_type = element_type
+
+    if match := _RE_PARSE_SERVER.match(element_type):
+        server_name = match.group(1)
+        module_type = TO_MODULE_TYPE.get(server_name)
+
+        if module_type is None:
+            raise ValueError(f"{element_type} is not a known datatable server.")
+
+    table = TABLE.get(module_type)
 
     if table is None:
-        raise TypeError(f"Unknown element type: {element_type}")
-    else:
-        return table[index]
+        raise TypeError(f"Unknown datatable type: {element_type}")
+
+    return table[index]