tencentcloud-sdk-python 3.1.13__py2.py3-none-any.whl → 3.1.33__py2.py3-none-any.whl

tencentcloud/dlc/v20210125/models.py

@@ -5259,6 +5259,227 @@ class CreateDatabaseResponse(AbstractModel):
         self._RequestId = params.get("RequestId")
 
 
+class CreateDatasourceConnectionRequest(AbstractModel):
+    r"""CreateDatasourceConnection请求参数结构体
+
+    """
+
+    def __init__(self):
+        r"""
+        :param _DatasourceConnectionName: 数据连接名称
+        :type DatasourceConnectionName: str
+        :param _DatasourceConnectionType: 数据连接类型
+        :type DatasourceConnectionType: str
+        :param _DatasourceConnectionConfig: 数据连接属性
+        :type DatasourceConnectionConfig: :class:`tencentcloud.dlc.v20210125.models.DatasourceConnectionConfig`
+        :param _ServiceType: 数据连接所属服务
+        :type ServiceType: str
+        :param _DatasourceConnectionDesc: 数据连接描述
+        :type DatasourceConnectionDesc: str
+        :param _DataEngineNames: 数据引擎名称数组
+        :type DataEngineNames: list of str
+        :param _NetworkConnectionName: 网络连接名称
+        :type NetworkConnectionName: str
+        :param _NetworkConnectionDesc: 网络连接描述
+        :type NetworkConnectionDesc: str
+        :param _NetworkConnectionType: 网络连接类型 （2-夸源型，4-增强型）
+        :type NetworkConnectionType: int
+        :param _CustomConfig: 自定义配置
+        :type CustomConfig: list of CustomConfig
+        """
+        self._DatasourceConnectionName = None
+        self._DatasourceConnectionType = None
+        self._DatasourceConnectionConfig = None
+        self._ServiceType = None
+        self._DatasourceConnectionDesc = None
+        self._DataEngineNames = None
+        self._NetworkConnectionName = None
+        self._NetworkConnectionDesc = None
+        self._NetworkConnectionType = None
+        self._CustomConfig = None
+
+    @property
+    def DatasourceConnectionName(self):
+        r"""数据连接名称
+        :rtype: str
+        """
+        return self._DatasourceConnectionName
+
+    @DatasourceConnectionName.setter
+    def DatasourceConnectionName(self, DatasourceConnectionName):
+        self._DatasourceConnectionName = DatasourceConnectionName
+
+    @property
+    def DatasourceConnectionType(self):
+        r"""数据连接类型
+        :rtype: str
+        """
+        return self._DatasourceConnectionType
+
+    @DatasourceConnectionType.setter
+    def DatasourceConnectionType(self, DatasourceConnectionType):
+        self._DatasourceConnectionType = DatasourceConnectionType
+
+    @property
+    def DatasourceConnectionConfig(self):
+        r"""数据连接属性
+        :rtype: :class:`tencentcloud.dlc.v20210125.models.DatasourceConnectionConfig`
+        """
+        return self._DatasourceConnectionConfig
+
+    @DatasourceConnectionConfig.setter
+    def DatasourceConnectionConfig(self, DatasourceConnectionConfig):
+        self._DatasourceConnectionConfig = DatasourceConnectionConfig
+
+    @property
+    def ServiceType(self):
+        r"""数据连接所属服务
+        :rtype: str
+        """
+        return self._ServiceType
+
+    @ServiceType.setter
+    def ServiceType(self, ServiceType):
+        self._ServiceType = ServiceType
+
+    @property
+    def DatasourceConnectionDesc(self):
+        r"""数据连接描述
+        :rtype: str
+        """
+        return self._DatasourceConnectionDesc
+
+    @DatasourceConnectionDesc.setter
+    def DatasourceConnectionDesc(self, DatasourceConnectionDesc):
+        self._DatasourceConnectionDesc = DatasourceConnectionDesc
+
+    @property
+    def DataEngineNames(self):
+        r"""数据引擎名称数组
+        :rtype: list of str
+        """
+        return self._DataEngineNames
+
+    @DataEngineNames.setter
+    def DataEngineNames(self, DataEngineNames):
+        self._DataEngineNames = DataEngineNames
+
+    @property
+    def NetworkConnectionName(self):
+        r"""网络连接名称
+        :rtype: str
+        """
+        return self._NetworkConnectionName
+
+    @NetworkConnectionName.setter
+    def NetworkConnectionName(self, NetworkConnectionName):
+        self._NetworkConnectionName = NetworkConnectionName
+
+    @property
+    def NetworkConnectionDesc(self):
+        r"""网络连接描述
+        :rtype: str
+        """
+        return self._NetworkConnectionDesc
+
+    @NetworkConnectionDesc.setter
+    def NetworkConnectionDesc(self, NetworkConnectionDesc):
+        self._NetworkConnectionDesc = NetworkConnectionDesc
+
+    @property
+    def NetworkConnectionType(self):
+        r"""网络连接类型 （2-夸源型，4-增强型）
+        :rtype: int
+        """
+        return self._NetworkConnectionType
+
+    @NetworkConnectionType.setter
+    def NetworkConnectionType(self, NetworkConnectionType):
+        self._NetworkConnectionType = NetworkConnectionType
+
+    @property
+    def CustomConfig(self):
+        r"""自定义配置
+        :rtype: list of CustomConfig
+        """
+        return self._CustomConfig
+
+    @CustomConfig.setter
+    def CustomConfig(self, CustomConfig):
+        self._CustomConfig = CustomConfig
+
+
+    def _deserialize(self, params):
+        self._DatasourceConnectionName = params.get("DatasourceConnectionName")
+        self._DatasourceConnectionType = params.get("DatasourceConnectionType")
+        if params.get("DatasourceConnectionConfig") is not None:
+            self._DatasourceConnectionConfig = DatasourceConnectionConfig()
+            self._DatasourceConnectionConfig._deserialize(params.get("DatasourceConnectionConfig"))
+        self._ServiceType = params.get("ServiceType")
+        self._DatasourceConnectionDesc = params.get("DatasourceConnectionDesc")
+        self._DataEngineNames = params.get("DataEngineNames")
+        self._NetworkConnectionName = params.get("NetworkConnectionName")
+        self._NetworkConnectionDesc = params.get("NetworkConnectionDesc")
+        self._NetworkConnectionType = params.get("NetworkConnectionType")
+        if params.get("CustomConfig") is not None:
+            self._CustomConfig = []
+            for item in params.get("CustomConfig"):
+                obj = CustomConfig()
+                obj._deserialize(item)
+                self._CustomConfig.append(obj)
+        memeber_set = set(params.keys())
+        for name, value in vars(self).items():
+            property_name = name[1:]
+            if property_name in memeber_set:
+                memeber_set.remove(property_name)
+        if len(memeber_set) > 0:
+            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
+        
+
+
+class CreateDatasourceConnectionResponse(AbstractModel):
+    r"""CreateDatasourceConnection返回参数结构体
+
+    """
+
+    def __init__(self):
+        r"""
+        :param _DatasourceConnectionId: 数据连接Id
+        :type DatasourceConnectionId: str
+        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
+        :type RequestId: str
+        """
+        self._DatasourceConnectionId = None
+        self._RequestId = None
+
+    @property
+    def DatasourceConnectionId(self):
+        r"""数据连接Id
+        :rtype: str
+        """
+        return self._DatasourceConnectionId
+
+    @DatasourceConnectionId.setter
+    def DatasourceConnectionId(self, DatasourceConnectionId):
+        self._DatasourceConnectionId = DatasourceConnectionId
+
+    @property
+    def RequestId(self):
+        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
+        :rtype: str
+        """
+        return self._RequestId
+
+    @RequestId.setter
+    def RequestId(self, RequestId):
+        self._RequestId = RequestId
+
+
+    def _deserialize(self, params):
+        self._DatasourceConnectionId = params.get("DatasourceConnectionId")
+        self._RequestId = params.get("RequestId")
+
+
 class CreateExportTaskRequest(AbstractModel):
     r"""CreateExportTask请求参数结构体
 
@@ -11649,6 +11870,20 @@ class DataEngineInfo(AbstractModel):
         :type IsAIEngine: int
         :param _ScheduleElasticityConf: 引擎资源弹性伸缩策略
         :type ScheduleElasticityConf: :class:`tencentcloud.dlc.v20210125.models.ScheduleElasticityConf`
+        :param _GPUInfo: GPU 信息
+        :type GPUInfo: :class:`tencentcloud.dlc.v20210125.models.GPUInfo`
+        :param _EngineResourceUsedGPU: GPU 使用量
+        :type EngineResourceUsedGPU: int
+        :param _GPUTotalSize: GPU 总规格
+        :type GPUTotalSize: int
+        :param _InstanceModel: GPU 机型
+        :type InstanceModel: str
+        :param _NodeNum: 节点数量
+        :type NodeNum: int
+        :param _SizeWithElastic: 引擎规格，包含负载弹性或分时弹性
+        :type SizeWithElastic: int
+        :param _MaxElasticSize: 最大弹性值，包含负载弹性或分时弹性
+        :type MaxElasticSize: int
         """
         self._DataEngineName = None
         self._EngineType = None
@@ -11710,6 +11945,13 @@ class DataEngineInfo(AbstractModel):
         self._IsAIGateway = None
         self._IsAIEngine = None
         self._ScheduleElasticityConf = None
+        self._GPUInfo = None
+        self._EngineResourceUsedGPU = None
+        self._GPUTotalSize = None
+        self._InstanceModel = None
+        self._NodeNum = None
+        self._SizeWithElastic = None
+        self._MaxElasticSize = None
 
     @property
     def DataEngineName(self):
@@ -12417,6 +12659,83 @@ class DataEngineInfo(AbstractModel):
     def ScheduleElasticityConf(self, ScheduleElasticityConf):
         self._ScheduleElasticityConf = ScheduleElasticityConf
 
+    @property
+    def GPUInfo(self):
+        r"""GPU 信息
+        :rtype: :class:`tencentcloud.dlc.v20210125.models.GPUInfo`
+        """
+        return self._GPUInfo
+
+    @GPUInfo.setter
+    def GPUInfo(self, GPUInfo):
+        self._GPUInfo = GPUInfo
+
+    @property
+    def EngineResourceUsedGPU(self):
+        r"""GPU 使用量
+        :rtype: int
+        """
+        return self._EngineResourceUsedGPU
+
+    @EngineResourceUsedGPU.setter
+    def EngineResourceUsedGPU(self, EngineResourceUsedGPU):
+        self._EngineResourceUsedGPU = EngineResourceUsedGPU
+
+    @property
+    def GPUTotalSize(self):
+        r"""GPU 总规格
+        :rtype: int
+        """
+        return self._GPUTotalSize
+
+    @GPUTotalSize.setter
+    def GPUTotalSize(self, GPUTotalSize):
+        self._GPUTotalSize = GPUTotalSize
+
+    @property
+    def InstanceModel(self):
+        r"""GPU 机型
+        :rtype: str
+        """
+        return self._InstanceModel
+
+    @InstanceModel.setter
+    def InstanceModel(self, InstanceModel):
+        self._InstanceModel = InstanceModel
+
+    @property
+    def NodeNum(self):
+        r"""节点数量
+        :rtype: int
+        """
+        return self._NodeNum
+
+    @NodeNum.setter
+    def NodeNum(self, NodeNum):
+        self._NodeNum = NodeNum
+
+    @property
+    def SizeWithElastic(self):
+        r"""引擎规格，包含负载弹性或分时弹性
+        :rtype: int
+        """
+        return self._SizeWithElastic
+
+    @SizeWithElastic.setter
+    def SizeWithElastic(self, SizeWithElastic):
+        self._SizeWithElastic = SizeWithElastic
+
+    @property
+    def MaxElasticSize(self):
+        r"""最大弹性值，包含负载弹性或分时弹性
+        :rtype: int
+        """
+        return self._MaxElasticSize
+
+    @MaxElasticSize.setter
+    def MaxElasticSize(self, MaxElasticSize):
+        self._MaxElasticSize = MaxElasticSize
+
 
     def _deserialize(self, params):
         self._DataEngineName = params.get("DataEngineName")
@@ -12500,6 +12819,15 @@ class DataEngineInfo(AbstractModel):
         if params.get("ScheduleElasticityConf") is not None:
             self._ScheduleElasticityConf = ScheduleElasticityConf()
             self._ScheduleElasticityConf._deserialize(params.get("ScheduleElasticityConf"))
+        if params.get("GPUInfo") is not None:
+            self._GPUInfo = GPUInfo()
+            self._GPUInfo._deserialize(params.get("GPUInfo"))
+        self._EngineResourceUsedGPU = params.get("EngineResourceUsedGPU")
+        self._GPUTotalSize = params.get("GPUTotalSize")
+        self._InstanceModel = params.get("InstanceModel")
+        self._NodeNum = params.get("NodeNum")
+        self._SizeWithElastic = params.get("SizeWithElastic")
+        self._MaxElasticSize = params.get("MaxElasticSize")
         memeber_set = set(params.keys())
         for name, value in vars(self).items():
             property_name = name[1:]
@@ -19263,9 +19591,15 @@ class DescribeNativeSparkSessionsRequest(AbstractModel):
         :type DataEngineId: str
         :param _ResourceGroupId: 资源组ID
         :type ResourceGroupId: str
+        :param _ProjectId: 项目ID
+        :type ProjectId: str
+        :param _UserUin: 用户Uin
+        :type UserUin: str
         """
         self._DataEngineId = None
         self._ResourceGroupId = None
+        self._ProjectId = None
+        self._UserUin = None
 
     @property
     def DataEngineId(self):
@@ -19289,10 +19623,34 @@ class DescribeNativeSparkSessionsRequest(AbstractModel):
     def ResourceGroupId(self, ResourceGroupId):
         self._ResourceGroupId = ResourceGroupId
 
+    @property
+    def ProjectId(self):
+        r"""项目ID
+        :rtype: str
+        """
+        return self._ProjectId
+
+    @ProjectId.setter
+    def ProjectId(self, ProjectId):
+        self._ProjectId = ProjectId
+
+    @property
+    def UserUin(self):
+        r"""用户Uin
+        :rtype: str
+        """
+        return self._UserUin
+
+    @UserUin.setter
+    def UserUin(self, UserUin):
+        self._UserUin = UserUin
+
 
     def _deserialize(self, params):
         self._DataEngineId = params.get("DataEngineId")
         self._ResourceGroupId = params.get("ResourceGroupId")
+        self._ProjectId = params.get("ProjectId")
+        self._UserUin = params.get("UserUin")
         memeber_set = set(params.keys())
         for name, value in vars(self).items():
             property_name = name[1:]
@@ -20584,6 +20942,115 @@ class DescribeOtherCHDFSBindingListResponse(AbstractModel):
         self._RequestId = params.get("RequestId")
 
 
+class DescribeResourceGroupUsageInfoRequest(AbstractModel):
+    r"""DescribeResourceGroupUsageInfo请求参数结构体
+
+    """
+
+    def __init__(self):
+        r"""
+        :param _SessionId: 资源组ID
+        :type SessionId: str
+        """
+        self._SessionId = None
+
+    @property
+    def SessionId(self):
+        r"""资源组ID
+        :rtype: str
+        """
+        return self._SessionId
+
+    @SessionId.setter
+    def SessionId(self, SessionId):
+        self._SessionId = SessionId
+
+
+    def _deserialize(self, params):
+        self._SessionId = params.get("SessionId")
+        memeber_set = set(params.keys())
+        for name, value in vars(self).items():
+            property_name = name[1:]
+            if property_name in memeber_set:
+                memeber_set.remove(property_name)
+        if len(memeber_set) > 0:
+            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
+        
+
+
+class DescribeResourceGroupUsageInfoResponse(AbstractModel):
+    r"""DescribeResourceGroupUsageInfo返回参数结构体
+
+    """
+
+    def __init__(self):
+        r"""
+        :param _Total: 资源上限
+        :type Total: int
+        :param _Used: 已占用资源
+        :type Used: int
+        :param _Available: 剩余可用资源
+        :type Available: int
+        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
+        :type RequestId: str
+        """
+        self._Total = None
+        self._Used = None
+        self._Available = None
+        self._RequestId = None
+
+    @property
+    def Total(self):
+        r"""资源上限
+        :rtype: int
+        """
+        return self._Total
+
+    @Total.setter
+    def Total(self, Total):
+        self._Total = Total
+
+    @property
+    def Used(self):
+        r"""已占用资源
+        :rtype: int
+        """
+        return self._Used
+
+    @Used.setter
+    def Used(self, Used):
+        self._Used = Used
+
+    @property
+    def Available(self):
+        r"""剩余可用资源
+        :rtype: int
+        """
+        return self._Available
+
+    @Available.setter
+    def Available(self, Available):
+        self._Available = Available
+
+    @property
+    def RequestId(self):
+        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
+        :rtype: str
+        """
+        return self._RequestId
+
+    @RequestId.setter
+    def RequestId(self, RequestId):
+        self._RequestId = RequestId
+
+
+    def _deserialize(self, params):
+        self._Total = params.get("Total")
+        self._Used = params.get("Used")
+        self._Available = params.get("Available")
+        self._RequestId = params.get("RequestId")
+
+
 class DescribeResultDownloadRequest(AbstractModel):
     r"""DescribeResultDownload请求参数结构体
 
@@ -27395,12 +27862,15 @@ class ElasticPlan(AbstractModel):
         :type StartTime: str
         :param _EndTime: 结束时间，Once格式：yyyy-MM-dd HH:mm:ss; 非Once格式： HH:mm:ss
         :type EndTime: str
+        :param _ElasticLimit: 分时弹性上限
+        :type ElasticLimit: int
         """
         self._MinElasticClusters = None
         self._MaxElasticClusters = None
         self._TolerableQueueTime = None
         self._StartTime = None
         self._EndTime = None
+        self._ElasticLimit = None
 
     @property
     def MinElasticClusters(self):
@@ -27457,6 +27927,17 @@ class ElasticPlan(AbstractModel):
     def EndTime(self, EndTime):
         self._EndTime = EndTime
 
+    @property
+    def ElasticLimit(self):
+        r"""分时弹性上限
+        :rtype: int
+        """
+        return self._ElasticLimit
+
+    @ElasticLimit.setter
+    def ElasticLimit(self, ElasticLimit):
+        self._ElasticLimit = ElasticLimit
+
 
     def _deserialize(self, params):
         self._MinElasticClusters = params.get("MinElasticClusters")
@@ -27464,6 +27945,7 @@ class ElasticPlan(AbstractModel):
         self._TolerableQueueTime = params.get("TolerableQueueTime")
         self._StartTime = params.get("StartTime")
         self._EndTime = params.get("EndTime")
+        self._ElasticLimit = params.get("ElasticLimit")
         memeber_set = set(params.keys())
         for name, value in vars(self).items():
             property_name = name[1:]
@@ -28114,6 +28596,147 @@ class Filter(AbstractModel):
         
 
 
+class GPUInfo(AbstractModel):
+    r"""GPU 机型
+
+    """
+
+    def __init__(self):
+        r"""
+        :param _BillingItem: 计费项
+        :type BillingItem: str
+        :param _Model: 机型
+        :type Model: str
+        :param _CU: cu
+        :type CU: int
+        :param _Type: gpu 机型
+        :type Type: str
+        :param _Num: 数量
+        :type Num: int
+        :param _GPUMemory: 显存
+        :type GPUMemory: int
+        :param _InstanceType: 机型
+        :type InstanceType: str
+        :param _SaleStatus: 售卖情况（1-缺货，2-低库存，3-充足）
+        :type SaleStatus: int
+        """
+        self._BillingItem = None
+        self._Model = None
+        self._CU = None
+        self._Type = None
+        self._Num = None
+        self._GPUMemory = None
+        self._InstanceType = None
+        self._SaleStatus = None
+
+    @property
+    def BillingItem(self):
+        r"""计费项
+        :rtype: str
+        """
+        return self._BillingItem
+
+    @BillingItem.setter
+    def BillingItem(self, BillingItem):
+        self._BillingItem = BillingItem
+
+    @property
+    def Model(self):
+        r"""机型
+        :rtype: str
+        """
+        return self._Model
+
+    @Model.setter
+    def Model(self, Model):
+        self._Model = Model
+
+    @property
+    def CU(self):
+        r"""cu
+        :rtype: int
+        """
+        return self._CU
+
+    @CU.setter
+    def CU(self, CU):
+        self._CU = CU
+
+    @property
+    def Type(self):
+        r"""gpu 机型
+        :rtype: str
+        """
+        return self._Type
+
+    @Type.setter
+    def Type(self, Type):
+        self._Type = Type
+
+    @property
+    def Num(self):
+        r"""数量
+        :rtype: int
+        """
+        return self._Num
+
+    @Num.setter
+    def Num(self, Num):
+        self._Num = Num
+
+    @property
+    def GPUMemory(self):
+        r"""显存
+        :rtype: int
+        """
+        return self._GPUMemory
+
+    @GPUMemory.setter
+    def GPUMemory(self, GPUMemory):
+        self._GPUMemory = GPUMemory
+
+    @property
+    def InstanceType(self):
+        r"""机型
+        :rtype: str
+        """
+        return self._InstanceType
+
+    @InstanceType.setter
+    def InstanceType(self, InstanceType):
+        self._InstanceType = InstanceType
+
+    @property
+    def SaleStatus(self):
+        r"""售卖情况（1-缺货，2-低库存，3-充足）
+        :rtype: int
+        """
+        return self._SaleStatus
+
+    @SaleStatus.setter
+    def SaleStatus(self, SaleStatus):
+        self._SaleStatus = SaleStatus
+
+
+    def _deserialize(self, params):
+        self._BillingItem = params.get("BillingItem")
+        self._Model = params.get("Model")
+        self._CU = params.get("CU")
+        self._Type = params.get("Type")
+        self._Num = params.get("Num")
+        self._GPUMemory = params.get("GPUMemory")
+        self._InstanceType = params.get("InstanceType")
+        self._SaleStatus = params.get("SaleStatus")
+        memeber_set = set(params.keys())
+        for name, value in vars(self).items():
+            property_name = name[1:]
+            if property_name in memeber_set:
+                memeber_set.remove(property_name)
+        if len(memeber_set) > 0:
+            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
+        
+
+
 class GatewayInfo(AbstractModel):
     r"""网关基础信息，包括id，名称，规格和状态
 
@@ -34656,9 +35279,12 @@ class QueryInternalTableWarehouseRequest(AbstractModel):
         :type DatabaseName: str
         :param _TableName: 表名
         :type TableName: str
+        :param _DatasourceConnectionName: catalog名称
+        :type DatasourceConnectionName: str
         """
         self._DatabaseName = None
         self._TableName = None
+        self._DatasourceConnectionName = None
 
     @property
     def DatabaseName(self):
@@ -34682,10 +35308,22 @@ class QueryInternalTableWarehouseRequest(AbstractModel):
     def TableName(self, TableName):
         self._TableName = TableName
 
+    @property
+    def DatasourceConnectionName(self):
+        r"""catalog名称
+        :rtype: str
+        """
+        return self._DatasourceConnectionName
+
+    @DatasourceConnectionName.setter
+    def DatasourceConnectionName(self, DatasourceConnectionName):
+        self._DatasourceConnectionName = DatasourceConnectionName
+
 
     def _deserialize(self, params):
         self._DatabaseName = params.get("DatabaseName")
         self._TableName = params.get("TableName")
+        self._DatasourceConnectionName = params.get("DatasourceConnectionName")
         memeber_set = set(params.keys())
         for name, value in vars(self).items():
             property_name = name[1:]
@@ -36113,6 +36751,72 @@ class SessionResourceTemplate(AbstractModel):
         
 
 
+class SetOptimizerPolicyRequest(AbstractModel):
+    r"""SetOptimizerPolicy请求参数结构体
+
+    """
+
+    def __init__(self):
+        r"""
+        :param _SmartPolicy: 优化策略
+        :type SmartPolicy: :class:`tencentcloud.dlc.v20210125.models.SmartPolicy`
+        """
+        self._SmartPolicy = None
+
+    @property
+    def SmartPolicy(self):
+        r"""优化策略
+        :rtype: :class:`tencentcloud.dlc.v20210125.models.SmartPolicy`
+        """
+        return self._SmartPolicy
+
+    @SmartPolicy.setter
+    def SmartPolicy(self, SmartPolicy):
+        self._SmartPolicy = SmartPolicy
+
+
+    def _deserialize(self, params):
+        if params.get("SmartPolicy") is not None:
+            self._SmartPolicy = SmartPolicy()
+            self._SmartPolicy._deserialize(params.get("SmartPolicy"))
+        memeber_set = set(params.keys())
+        for name, value in vars(self).items():
+            property_name = name[1:]
+            if property_name in memeber_set:
+                memeber_set.remove(property_name)
+        if len(memeber_set) > 0:
+            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
+        
+
+
+class SetOptimizerPolicyResponse(AbstractModel):
+    r"""SetOptimizerPolicy返回参数结构体
+
+    """
+
+    def __init__(self):
+        r"""
+        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
+        :type RequestId: str
+        """
+        self._RequestId = None
+
+    @property
+    def RequestId(self):
+        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
+        :rtype: str
+        """
+        return self._RequestId
+
+    @RequestId.setter
+    def RequestId(self, RequestId):
+        self._RequestId = RequestId
+
+
+    def _deserialize(self, params):
+        self._RequestId = params.get("RequestId")
+
+
 class SmartOptimizerChangeTablePolicy(AbstractModel):
     r"""混合表中，change表的数据保存时间，单位为天
 
@@ -36424,8 +37128,12 @@ class SmartOptimizerWrittenPolicy(AbstractModel):
         r"""
         :param _WrittenEnable: none/enable/disable/default
         :type WrittenEnable: str
+        :param _AdvancePolicy: 用户自定义高级参数
+注意：此字段可能返回 null，表示取不到有效值。
+        :type AdvancePolicy: :class:`tencentcloud.dlc.v20210125.models.WrittenAdvancePolicy`
         """
         self._WrittenEnable = None
+        self._AdvancePolicy = None
 
     @property
     def WrittenEnable(self):
@@ -36438,9 +37146,24 @@ class SmartOptimizerWrittenPolicy(AbstractModel):
     def WrittenEnable(self, WrittenEnable):
         self._WrittenEnable = WrittenEnable
 
+    @property
+    def AdvancePolicy(self):
+        r"""用户自定义高级参数
+注意：此字段可能返回 null，表示取不到有效值。
+        :rtype: :class:`tencentcloud.dlc.v20210125.models.WrittenAdvancePolicy`
+        """
+        return self._AdvancePolicy
+
+    @AdvancePolicy.setter
+    def AdvancePolicy(self, AdvancePolicy):
+        self._AdvancePolicy = AdvancePolicy
+
 
     def _deserialize(self, params):
         self._WrittenEnable = params.get("WrittenEnable")
+        if params.get("AdvancePolicy") is not None:
+            self._AdvancePolicy = WrittenAdvancePolicy()
+            self._AdvancePolicy._deserialize(params.get("AdvancePolicy"))
         memeber_set = set(params.keys())
         for name, value in vars(self).items():
             property_name = name[1:]
@@ -36672,6 +37395,72 @@ class Sort(AbstractModel):
         
 
 
+class SortOrder(AbstractModel):
+    r"""合并策略sort类型的规则定义
+
+    """
+
+    def __init__(self):
+        r"""
+        :param _Column: sort的数据表列名称
+        :type Column: str
+        :param _SortDirection: 按照升序或者降序进行排序
+        :type SortDirection: str
+        :param _NullOrder: null值放在开头或者末尾
+        :type NullOrder: str
+        """
+        self._Column = None
+        self._SortDirection = None
+        self._NullOrder = None
+
+    @property
+    def Column(self):
+        r"""sort的数据表列名称
+        :rtype: str
+        """
+        return self._Column
+
+    @Column.setter
+    def Column(self, Column):
+        self._Column = Column
+
+    @property
+    def SortDirection(self):
+        r"""按照升序或者降序进行排序
+        :rtype: str
+        """
+        return self._SortDirection
+
+    @SortDirection.setter
+    def SortDirection(self, SortDirection):
+        self._SortDirection = SortDirection
+
+    @property
+    def NullOrder(self):
+        r"""null值放在开头或者末尾
+        :rtype: str
+        """
+        return self._NullOrder
+
+    @NullOrder.setter
+    def NullOrder(self, NullOrder):
+        self._NullOrder = NullOrder
+
+
+    def _deserialize(self, params):
+        self._Column = params.get("Column")
+        self._SortDirection = params.get("SortDirection")
+        self._NullOrder = params.get("NullOrder")
+        memeber_set = set(params.keys())
+        for name, value in vars(self).items():
+            property_name = name[1:]
+            if property_name in memeber_set:
+                memeber_set.remove(property_name)
+        if len(memeber_set) > 0:
+            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
+        
+
+
 class SparkJobInfo(AbstractModel):
     r"""spark作业详情。
 
@@ -46272,6 +47061,10 @@ class WorkGroupDetailInfo(AbstractModel):
         :param _CatalogPolicyInfo: 数据目录权限集
 注意：此字段可能返回 null，表示取不到有效值。
         :type CatalogPolicyInfo: :class:`tencentcloud.dlc.v20210125.models.Policy`
+        :param _DataCatalogPolicyInfo: 数据目录权限
+        :type DataCatalogPolicyInfo: :class:`tencentcloud.dlc.v20210125.models.Policys`
+        :param _ModelPolicyInfo: 模型权限
+        :type ModelPolicyInfo: :class:`tencentcloud.dlc.v20210125.models.Policys`
         """
         self._WorkGroupId = None
         self._WorkGroupName = None
@@ -46282,6 +47075,8 @@ class WorkGroupDetailInfo(AbstractModel):
         self._WorkGroupDescription = None
         self._RowFilterInfo = None
         self._CatalogPolicyInfo = None
+        self._DataCatalogPolicyInfo = None
+        self._ModelPolicyInfo = None
 
     @property
     def WorkGroupId(self):
@@ -46383,6 +47178,28 @@ class WorkGroupDetailInfo(AbstractModel):
     def CatalogPolicyInfo(self, CatalogPolicyInfo):
         self._CatalogPolicyInfo = CatalogPolicyInfo
 
+    @property
+    def DataCatalogPolicyInfo(self):
+        r"""数据目录权限
+        :rtype: :class:`tencentcloud.dlc.v20210125.models.Policys`
+        """
+        return self._DataCatalogPolicyInfo
+
+    @DataCatalogPolicyInfo.setter
+    def DataCatalogPolicyInfo(self, DataCatalogPolicyInfo):
+        self._DataCatalogPolicyInfo = DataCatalogPolicyInfo
+
+    @property
+    def ModelPolicyInfo(self):
+        r"""模型权限
+        :rtype: :class:`tencentcloud.dlc.v20210125.models.Policys`
+        """
+        return self._ModelPolicyInfo
+
+    @ModelPolicyInfo.setter
+    def ModelPolicyInfo(self, ModelPolicyInfo):
+        self._ModelPolicyInfo = ModelPolicyInfo
+
 
     def _deserialize(self, params):
         self._WorkGroupId = params.get("WorkGroupId")
@@ -46404,6 +47221,12 @@ class WorkGroupDetailInfo(AbstractModel):
         if params.get("CatalogPolicyInfo") is not None:
             self._CatalogPolicyInfo = Policy()
             self._CatalogPolicyInfo._deserialize(params.get("CatalogPolicyInfo"))
+        if params.get("DataCatalogPolicyInfo") is not None:
+            self._DataCatalogPolicyInfo = Policys()
+            self._DataCatalogPolicyInfo._deserialize(params.get("DataCatalogPolicyInfo"))
+        if params.get("ModelPolicyInfo") is not None:
+            self._ModelPolicyInfo = Policys()
+            self._ModelPolicyInfo._deserialize(params.get("ModelPolicyInfo"))
         memeber_set = set(params.keys())
         for name, value in vars(self).items():
             property_name = name[1:]
@@ -46771,4 +47594,197 @@ class WorkGroups(AbstractModel):
                 memeber_set.remove(property_name)
         if len(memeber_set) > 0:
             warnings.warn("%s fileds are useless." % ",".join(memeber_set))
+        
+
+
+class WrittenAdvancePolicy(AbstractModel):
+    r"""Smart Optimizer高级参数配置数据结构
+
+    """
+
+    def __init__(self):
+        r"""
+        :param _CompactEnable: 是否启用合并
+        :type CompactEnable: str
+        :param _DeleteEnable: 是否启用历史数据清理
+        :type DeleteEnable: str
+        :param _MinInputFiles: 合并最新文件数量
+        :type MinInputFiles: int
+        :param _TargetFileSizeBytes: 合并文件目录文件大小
+        :type TargetFileSizeBytes: int
+        :param _RetainLast: 保留过期时间的快照数量
+        :type RetainLast: int
+        :param _BeforeDays: 快照过期时间
+        :type BeforeDays: int
+        :param _ExpiredSnapshotsIntervalMin: 快照过期执行周期
+        :type ExpiredSnapshotsIntervalMin: int
+        :param _RemoveOrphanIntervalMin: 移除孤立文件执行周期
+        :type RemoveOrphanIntervalMin: int
+        :param _CowCompactEnable: 是否开启COW表合并
+        :type CowCompactEnable: str
+        :param _CompactStrategy: 文件合并策略
+        :type CompactStrategy: str
+        :param _SortOrders: sort合并策略的规则定义
+注意：此字段可能返回 null，表示取不到有效值。
+        :type SortOrders: list of SortOrder
+        """
+        self._CompactEnable = None
+        self._DeleteEnable = None
+        self._MinInputFiles = None
+        self._TargetFileSizeBytes = None
+        self._RetainLast = None
+        self._BeforeDays = None
+        self._ExpiredSnapshotsIntervalMin = None
+        self._RemoveOrphanIntervalMin = None
+        self._CowCompactEnable = None
+        self._CompactStrategy = None
+        self._SortOrders = None
+
+    @property
+    def CompactEnable(self):
+        r"""是否启用合并
+        :rtype: str
+        """
+        return self._CompactEnable
+
+    @CompactEnable.setter
+    def CompactEnable(self, CompactEnable):
+        self._CompactEnable = CompactEnable
+
+    @property
+    def DeleteEnable(self):
+        r"""是否启用历史数据清理
+        :rtype: str
+        """
+        return self._DeleteEnable
+
+    @DeleteEnable.setter
+    def DeleteEnable(self, DeleteEnable):
+        self._DeleteEnable = DeleteEnable
+
+    @property
+    def MinInputFiles(self):
+        r"""合并最新文件数量
+        :rtype: int
+        """
+        return self._MinInputFiles
+
+    @MinInputFiles.setter
+    def MinInputFiles(self, MinInputFiles):
+        self._MinInputFiles = MinInputFiles
+
+    @property
+    def TargetFileSizeBytes(self):
+        r"""合并文件目录文件大小
+        :rtype: int
+        """
+        return self._TargetFileSizeBytes
+
+    @TargetFileSizeBytes.setter
+    def TargetFileSizeBytes(self, TargetFileSizeBytes):
+        self._TargetFileSizeBytes = TargetFileSizeBytes
+
+    @property
+    def RetainLast(self):
+        r"""保留过期时间的快照数量
+        :rtype: int
+        """
+        return self._RetainLast
+
+    @RetainLast.setter
+    def RetainLast(self, RetainLast):
+        self._RetainLast = RetainLast
+
+    @property
+    def BeforeDays(self):
+        r"""快照过期时间
+        :rtype: int
+        """
+        return self._BeforeDays
+
+    @BeforeDays.setter
+    def BeforeDays(self, BeforeDays):
+        self._BeforeDays = BeforeDays
+
+    @property
+    def ExpiredSnapshotsIntervalMin(self):
+        r"""快照过期执行周期
+        :rtype: int
+        """
+        return self._ExpiredSnapshotsIntervalMin
+
+    @ExpiredSnapshotsIntervalMin.setter
+    def ExpiredSnapshotsIntervalMin(self, ExpiredSnapshotsIntervalMin):
+        self._ExpiredSnapshotsIntervalMin = ExpiredSnapshotsIntervalMin
+
+    @property
+    def RemoveOrphanIntervalMin(self):
+        r"""移除孤立文件执行周期
+        :rtype: int
+        """
+        return self._RemoveOrphanIntervalMin
+
+    @RemoveOrphanIntervalMin.setter
+    def RemoveOrphanIntervalMin(self, RemoveOrphanIntervalMin):
+        self._RemoveOrphanIntervalMin = RemoveOrphanIntervalMin
+
+    @property
+    def CowCompactEnable(self):
+        r"""是否开启COW表合并
+        :rtype: str
+        """
+        return self._CowCompactEnable
+
+    @CowCompactEnable.setter
+    def CowCompactEnable(self, CowCompactEnable):
+        self._CowCompactEnable = CowCompactEnable
+
+    @property
+    def CompactStrategy(self):
+        r"""文件合并策略
+        :rtype: str
+        """
+        return self._CompactStrategy
+
+    @CompactStrategy.setter
+    def CompactStrategy(self, CompactStrategy):
+        self._CompactStrategy = CompactStrategy
+
+    @property
+    def SortOrders(self):
+        r"""sort合并策略的规则定义
+注意：此字段可能返回 null，表示取不到有效值。
+        :rtype: list of SortOrder
+        """
+        return self._SortOrders
+
+    @SortOrders.setter
+    def SortOrders(self, SortOrders):
+        self._SortOrders = SortOrders
+
+
+    def _deserialize(self, params):
+        self._CompactEnable = params.get("CompactEnable")
+        self._DeleteEnable = params.get("DeleteEnable")
+        self._MinInputFiles = params.get("MinInputFiles")
+        self._TargetFileSizeBytes = params.get("TargetFileSizeBytes")
+        self._RetainLast = params.get("RetainLast")
+        self._BeforeDays = params.get("BeforeDays")
+        self._ExpiredSnapshotsIntervalMin = params.get("ExpiredSnapshotsIntervalMin")
+        self._RemoveOrphanIntervalMin = params.get("RemoveOrphanIntervalMin")
+        self._CowCompactEnable = params.get("CowCompactEnable")
+        self._CompactStrategy = params.get("CompactStrategy")
+        if params.get("SortOrders") is not None:
+            self._SortOrders = []
+            for item in params.get("SortOrders"):
+                obj = SortOrder()
+                obj._deserialize(item)
+                self._SortOrders.append(obj)
+        memeber_set = set(params.keys())
+        for name, value in vars(self).items():
+            property_name = name[1:]
+            if property_name in memeber_set:
+                memeber_set.remove(property_name)
+        if len(memeber_set) > 0:
+            warnings.warn("%s fileds are useless." % ",".join(memeber_set))