diff --git a/aliyun-java-sdk-oceanbasepro/ChangeLog.txt b/aliyun-java-sdk-oceanbasepro/ChangeLog.txt index 595690bd6a..614c230157 100644 --- a/aliyun-java-sdk-oceanbasepro/ChangeLog.txt +++ b/aliyun-java-sdk-oceanbasepro/ChangeLog.txt @@ -1,3 +1,6 @@ +2024-07-24 Version: 1.1.21 +- Generated 2019-09-01 for `OceanBasePro`. + 2024-07-04 Version: 1.1.20 - Generated 2019-09-01 for `OceanBasePro`. diff --git a/aliyun-java-sdk-oceanbasepro/pom.xml b/aliyun-java-sdk-oceanbasepro/pom.xml index 060ba5e621..0bb90951ea 100644 --- a/aliyun-java-sdk-oceanbasepro/pom.xml +++ b/aliyun-java-sdk-oceanbasepro/pom.xml @@ -4,7 +4,7 @@ com.aliyun aliyun-java-sdk-oceanbasepro jar - 1.1.20 + 1.1.21 aliyun-java-sdk-oceanbasepro http://www.aliyun.com Aliyun Open API SDK for Java diff --git a/aliyun-java-sdk-oceanbasepro/src/main/java/com/aliyuncs/oceanbasepro/model/v20190901/DescribeSQLTuningAdvicesRequest.java b/aliyun-java-sdk-oceanbasepro/src/main/java/com/aliyuncs/oceanbasepro/model/v20190901/DescribeSQLTuningAdvicesRequest.java new file mode 100644 index 0000000000..187f216994 --- /dev/null +++ b/aliyun-java-sdk-oceanbasepro/src/main/java/com/aliyuncs/oceanbasepro/model/v20190901/DescribeSQLTuningAdvicesRequest.java @@ -0,0 +1,132 @@ +/* + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.aliyuncs.oceanbasepro.model.v20190901; + +import com.aliyuncs.RpcAcsRequest; +import com.aliyuncs.http.MethodType; +import com.aliyuncs.oceanbasepro.Endpoint; + +/** + * @author auto create + * @version + */ +public class DescribeSQLTuningAdvicesRequest extends RpcAcsRequest { + + + private String startTime; + + private String tenantId; + + private String sqlId; + + private String endTime; + + private String instanceId; + + private String dbName; + + private String acceptLanguage; + public DescribeSQLTuningAdvicesRequest() { + super("OceanBasePro", "2019-09-01", "DescribeSQLTuningAdvices", "oceanbase"); + setMethod(MethodType.POST); + try { + com.aliyuncs.AcsRequest.class.getDeclaredField("productEndpointMap").set(this, Endpoint.endpointMap); + com.aliyuncs.AcsRequest.class.getDeclaredField("productEndpointRegional").set(this, Endpoint.endpointRegionalType); + } catch (Exception e) {} + } + + public String getStartTime() { + return this.startTime; + } + + public void setStartTime(String startTime) { + this.startTime = startTime; + if(startTime != null){ + putBodyParameter("StartTime", startTime); + } + } + + public String getTenantId() { + return this.tenantId; + } + + public void setTenantId(String tenantId) { + this.tenantId = tenantId; + if(tenantId != null){ + putBodyParameter("TenantId", tenantId); + } + } + + public String getSqlId() { + return this.sqlId; + } + + public void setSqlId(String sqlId) { + this.sqlId = sqlId; + if(sqlId != null){ + putBodyParameter("SqlId", sqlId); + } + } + + public String getEndTime() { + return this.endTime; + } + + public void setEndTime(String endTime) { + this.endTime = endTime; + if(endTime != null){ + putBodyParameter("EndTime", endTime); + } + } + + public String getInstanceId() { + return this.instanceId; + } + + public void setInstanceId(String instanceId) { + this.instanceId = instanceId; + if(instanceId != null){ + putBodyParameter("InstanceId", instanceId); + } + } + + public String getDbName() { + return this.dbName; + } + + public void setDbName(String dbName) { + this.dbName = dbName; + if(dbName != null){ + putBodyParameter("DbName", dbName); + } + } + + public String getAcceptLanguage() { + return this.acceptLanguage; + } + + public void setAcceptLanguage(String acceptLanguage) { + this.acceptLanguage = acceptLanguage; + if(acceptLanguage != null){ + putBodyParameter("AcceptLanguage", acceptLanguage); + } + } + + @Override + public Class getResponseClass() { + return DescribeSQLTuningAdvicesResponse.class; + } + +} diff --git a/aliyun-java-sdk-oceanbasepro/src/main/java/com/aliyuncs/oceanbasepro/model/v20190901/DescribeSQLTuningAdvicesResponse.java b/aliyun-java-sdk-oceanbasepro/src/main/java/com/aliyuncs/oceanbasepro/model/v20190901/DescribeSQLTuningAdvicesResponse.java new file mode 100644 index 0000000000..dbaf1c22be --- /dev/null +++ b/aliyun-java-sdk-oceanbasepro/src/main/java/com/aliyuncs/oceanbasepro/model/v20190901/DescribeSQLTuningAdvicesResponse.java @@ -0,0 +1,496 @@ +/* + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.aliyuncs.oceanbasepro.model.v20190901; + +import java.util.List; +import com.aliyuncs.AcsResponse; +import com.aliyuncs.oceanbasepro.transform.v20190901.DescribeSQLTuningAdvicesResponseUnmarshaller; +import com.aliyuncs.transform.UnmarshallerContext; + +/** + * @author auto create + * @version + */ +public class DescribeSQLTuningAdvicesResponse extends AcsResponse { + + private String requestId; + + private List data; + + public String getRequestId() { + return this.requestId; + } + + public void setRequestId(String requestId) { + this.requestId = requestId; + } + + public List getData() { + return this.data; + } + + public void setData(List data) { + this.data = data; + } + + public static class DataItem { + + private String type; + + private String columnNames; + + private String localityType; + + private String dbName; + + private String table; + + private List columns; + + private Plan plan; + + public String getType() { + return this.type; + } + + public void setType(String type) { + this.type = type; + } + + public String getColumnNames() { + return this.columnNames; + } + + public void setColumnNames(String columnNames) { + this.columnNames = columnNames; + } + + public String getLocalityType() { + return this.localityType; + } + + public void setLocalityType(String localityType) { + this.localityType = localityType; + } + + public String getDbName() { + return this.dbName; + } + + public void setDbName(String dbName) { + this.dbName = dbName; + } + + public String getTable() { + return this.table; + } + + public void setTable(String table) { + this.table = table; + } + + public List getColumns() { + return this.columns; + } + + public void setColumns(List columns) { + this.columns = columns; + } + + public Plan getPlan() { + return this.plan; + } + + public void setPlan(Plan plan) { + this.plan = plan; + } + + public static class ColumnsItem { + + private String columnName; + + private Float ndv; + + private String minValue; + + private String maxValue; + + public String getColumnName() { + return this.columnName; + } + + public void setColumnName(String columnName) { + this.columnName = columnName; + } + + public Float getNdv() { + return this.ndv; + } + + public void setNdv(Float ndv) { + this.ndv = ndv; + } + + public String getMinValue() { + return this.minValue; + } + + public void setMinValue(String minValue) { + this.minValue = minValue; + } + + public String getMaxValue() { + return this.maxValue; + } + + public void setMaxValue(String maxValue) { + this.maxValue = maxValue; + } + } + + public static class Plan { + + private Long executions; + + private Float avgCpuTime; + + private String planHash; + + private Float timeoutPercentage; + + private Float avgConcurrencyWaitTime; + + private Long firstLoadTimeUs; + + private Float avgDiskWrites; + + private Float avgUserIoWaitTime; + + private Long planSize; + + private String serverSn; + + private String outlineData; + + private String planType; + + private Long obDbId; + + private Float hitPercentage; + + private Float avgBufferGets; + + private Float execPs; + + private Float delayedLargeQueryPercentage; + + private Boolean tableScan; + + private Float largeQueryPercentage; + + private Long schemaVersion; + + private Long planId; + + private String firstLoadTime; + + private Float avgRowProcessed; + + private Long mergedVersion; + + private Boolean hitDiagnosis; + + private String uid; + + private Float avgApplicationWaitTime; + + private Long collectTimeUs; + + private Float avgElapsedTime; + + private Long obServerId; + + private Long outlineId; + + private Float avgDiskReads; + + public Long getExecutions() { + return this.executions; + } + + public void setExecutions(Long executions) { + this.executions = executions; + } + + public Float getAvgCpuTime() { + return this.avgCpuTime; + } + + public void setAvgCpuTime(Float avgCpuTime) { + this.avgCpuTime = avgCpuTime; + } + + public String getPlanHash() { + return this.planHash; + } + + public void setPlanHash(String planHash) { + this.planHash = planHash; + } + + public Float getTimeoutPercentage() { + return this.timeoutPercentage; + } + + public void setTimeoutPercentage(Float timeoutPercentage) { + this.timeoutPercentage = timeoutPercentage; + } + + public Float getAvgConcurrencyWaitTime() { + return this.avgConcurrencyWaitTime; + } + + public void setAvgConcurrencyWaitTime(Float avgConcurrencyWaitTime) { + this.avgConcurrencyWaitTime = avgConcurrencyWaitTime; + } + + public Long getFirstLoadTimeUs() { + return this.firstLoadTimeUs; + } + + public void setFirstLoadTimeUs(Long firstLoadTimeUs) { + this.firstLoadTimeUs = firstLoadTimeUs; + } + + public Float getAvgDiskWrites() { + return this.avgDiskWrites; + } + + public void setAvgDiskWrites(Float avgDiskWrites) { + this.avgDiskWrites = avgDiskWrites; + } + + public Float getAvgUserIoWaitTime() { + return this.avgUserIoWaitTime; + } + + public void setAvgUserIoWaitTime(Float avgUserIoWaitTime) { + this.avgUserIoWaitTime = avgUserIoWaitTime; + } + + public Long getPlanSize() { + return this.planSize; + } + + public void setPlanSize(Long planSize) { + this.planSize = planSize; + } + + public String getServerSn() { + return this.serverSn; + } + + public void setServerSn(String serverSn) { + this.serverSn = serverSn; + } + + public String getOutlineData() { + return this.outlineData; + } + + public void setOutlineData(String outlineData) { + this.outlineData = outlineData; + } + + public String getPlanType() { + return this.planType; + } + + public void setPlanType(String planType) { + this.planType = planType; + } + + public Long getObDbId() { + return this.obDbId; + } + + public void setObDbId(Long obDbId) { + this.obDbId = obDbId; + } + + public Float getHitPercentage() { + return this.hitPercentage; + } + + public void setHitPercentage(Float hitPercentage) { + this.hitPercentage = hitPercentage; + } + + public Float getAvgBufferGets() { + return this.avgBufferGets; + } + + public void setAvgBufferGets(Float avgBufferGets) { + this.avgBufferGets = avgBufferGets; + } + + public Float getExecPs() { + return this.execPs; + } + + public void setExecPs(Float execPs) { + this.execPs = execPs; + } + + public Float getDelayedLargeQueryPercentage() { + return this.delayedLargeQueryPercentage; + } + + public void setDelayedLargeQueryPercentage(Float delayedLargeQueryPercentage) { + this.delayedLargeQueryPercentage = delayedLargeQueryPercentage; + } + + public Boolean getTableScan() { + return this.tableScan; + } + + public void setTableScan(Boolean tableScan) { + this.tableScan = tableScan; + } + + public Float getLargeQueryPercentage() { + return this.largeQueryPercentage; + } + + public void setLargeQueryPercentage(Float largeQueryPercentage) { + this.largeQueryPercentage = largeQueryPercentage; + } + + public Long getSchemaVersion() { + return this.schemaVersion; + } + + public void setSchemaVersion(Long schemaVersion) { + this.schemaVersion = schemaVersion; + } + + public Long getPlanId() { + return this.planId; + } + + public void setPlanId(Long planId) { + this.planId = planId; + } + + public String getFirstLoadTime() { + return this.firstLoadTime; + } + + public void setFirstLoadTime(String firstLoadTime) { + this.firstLoadTime = firstLoadTime; + } + + public Float getAvgRowProcessed() { + return this.avgRowProcessed; + } + + public void setAvgRowProcessed(Float avgRowProcessed) { + this.avgRowProcessed = avgRowProcessed; + } + + public Long getMergedVersion() { + return this.mergedVersion; + } + + public void setMergedVersion(Long mergedVersion) { + this.mergedVersion = mergedVersion; + } + + public Boolean getHitDiagnosis() { + return this.hitDiagnosis; + } + + public void setHitDiagnosis(Boolean hitDiagnosis) { + this.hitDiagnosis = hitDiagnosis; + } + + public String getUid() { + return this.uid; + } + + public void setUid(String uid) { + this.uid = uid; + } + + public Float getAvgApplicationWaitTime() { + return this.avgApplicationWaitTime; + } + + public void setAvgApplicationWaitTime(Float avgApplicationWaitTime) { + this.avgApplicationWaitTime = avgApplicationWaitTime; + } + + public Long getCollectTimeUs() { + return this.collectTimeUs; + } + + public void setCollectTimeUs(Long collectTimeUs) { + this.collectTimeUs = collectTimeUs; + } + + public Float getAvgElapsedTime() { + return this.avgElapsedTime; + } + + public void setAvgElapsedTime(Float avgElapsedTime) { + this.avgElapsedTime = avgElapsedTime; + } + + public Long getObServerId() { + return this.obServerId; + } + + public void setObServerId(Long obServerId) { + this.obServerId = obServerId; + } + + public Long getOutlineId() { + return this.outlineId; + } + + public void setOutlineId(Long outlineId) { + this.outlineId = outlineId; + } + + public Float getAvgDiskReads() { + return this.avgDiskReads; + } + + public void setAvgDiskReads(Float avgDiskReads) { + this.avgDiskReads = avgDiskReads; + } + } + } + + @Override + public DescribeSQLTuningAdvicesResponse getInstance(UnmarshallerContext context) { + return DescribeSQLTuningAdvicesResponseUnmarshaller.unmarshall(this, context); + } + + @Override + public boolean checkShowJsonItemName() { + return false; + } +} diff --git a/aliyun-java-sdk-oceanbasepro/src/main/java/com/aliyuncs/oceanbasepro/transform/v20190901/DescribeSQLTuningAdvicesResponseUnmarshaller.java b/aliyun-java-sdk-oceanbasepro/src/main/java/com/aliyuncs/oceanbasepro/transform/v20190901/DescribeSQLTuningAdvicesResponseUnmarshaller.java new file mode 100644 index 0000000000..10d2067e33 --- /dev/null +++ b/aliyun-java-sdk-oceanbasepro/src/main/java/com/aliyuncs/oceanbasepro/transform/v20190901/DescribeSQLTuningAdvicesResponseUnmarshaller.java @@ -0,0 +1,95 @@ +/* + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.aliyuncs.oceanbasepro.transform.v20190901; + +import java.util.ArrayList; +import java.util.List; + +import com.aliyuncs.oceanbasepro.model.v20190901.DescribeSQLTuningAdvicesResponse; +import com.aliyuncs.oceanbasepro.model.v20190901.DescribeSQLTuningAdvicesResponse.DataItem; +import com.aliyuncs.oceanbasepro.model.v20190901.DescribeSQLTuningAdvicesResponse.DataItem.ColumnsItem; +import com.aliyuncs.oceanbasepro.model.v20190901.DescribeSQLTuningAdvicesResponse.DataItem.Plan; +import com.aliyuncs.transform.UnmarshallerContext; + + +public class DescribeSQLTuningAdvicesResponseUnmarshaller { + + public static DescribeSQLTuningAdvicesResponse unmarshall(DescribeSQLTuningAdvicesResponse describeSQLTuningAdvicesResponse, UnmarshallerContext _ctx) { + + describeSQLTuningAdvicesResponse.setRequestId(_ctx.stringValue("DescribeSQLTuningAdvicesResponse.RequestId")); + + List data = new ArrayList(); + for (int i = 0; i < _ctx.lengthValue("DescribeSQLTuningAdvicesResponse.Data.Length"); i++) { + DataItem dataItem = new DataItem(); + dataItem.setType(_ctx.stringValue("DescribeSQLTuningAdvicesResponse.Data["+ i +"].Type")); + dataItem.setColumnNames(_ctx.stringValue("DescribeSQLTuningAdvicesResponse.Data["+ i +"].ColumnNames")); + dataItem.setLocalityType(_ctx.stringValue("DescribeSQLTuningAdvicesResponse.Data["+ i +"].LocalityType")); + dataItem.setDbName(_ctx.stringValue("DescribeSQLTuningAdvicesResponse.Data["+ i +"].DbName")); + dataItem.setTable(_ctx.stringValue("DescribeSQLTuningAdvicesResponse.Data["+ i +"].Table")); + + Plan plan = new Plan(); + plan.setExecutions(_ctx.longValue("DescribeSQLTuningAdvicesResponse.Data["+ i +"].Plan.Executions")); + plan.setAvgCpuTime(_ctx.floatValue("DescribeSQLTuningAdvicesResponse.Data["+ i +"].Plan.AvgCpuTime")); + plan.setPlanHash(_ctx.stringValue("DescribeSQLTuningAdvicesResponse.Data["+ i +"].Plan.PlanHash")); + plan.setTimeoutPercentage(_ctx.floatValue("DescribeSQLTuningAdvicesResponse.Data["+ i +"].Plan.TimeoutPercentage")); + plan.setAvgConcurrencyWaitTime(_ctx.floatValue("DescribeSQLTuningAdvicesResponse.Data["+ i +"].Plan.AvgConcurrencyWaitTime")); + plan.setFirstLoadTimeUs(_ctx.longValue("DescribeSQLTuningAdvicesResponse.Data["+ i +"].Plan.FirstLoadTimeUs")); + plan.setAvgDiskWrites(_ctx.floatValue("DescribeSQLTuningAdvicesResponse.Data["+ i +"].Plan.AvgDiskWrites")); + plan.setAvgUserIoWaitTime(_ctx.floatValue("DescribeSQLTuningAdvicesResponse.Data["+ i +"].Plan.AvgUserIoWaitTime")); + plan.setPlanSize(_ctx.longValue("DescribeSQLTuningAdvicesResponse.Data["+ i +"].Plan.PlanSize")); + plan.setServerSn(_ctx.stringValue("DescribeSQLTuningAdvicesResponse.Data["+ i +"].Plan.ServerSn")); + plan.setOutlineData(_ctx.stringValue("DescribeSQLTuningAdvicesResponse.Data["+ i +"].Plan.OutlineData")); + plan.setPlanType(_ctx.stringValue("DescribeSQLTuningAdvicesResponse.Data["+ i +"].Plan.PlanType")); + plan.setObDbId(_ctx.longValue("DescribeSQLTuningAdvicesResponse.Data["+ i +"].Plan.ObDbId")); + plan.setHitPercentage(_ctx.floatValue("DescribeSQLTuningAdvicesResponse.Data["+ i +"].Plan.HitPercentage")); + plan.setAvgBufferGets(_ctx.floatValue("DescribeSQLTuningAdvicesResponse.Data["+ i +"].Plan.AvgBufferGets")); + plan.setExecPs(_ctx.floatValue("DescribeSQLTuningAdvicesResponse.Data["+ i +"].Plan.ExecPs")); + plan.setDelayedLargeQueryPercentage(_ctx.floatValue("DescribeSQLTuningAdvicesResponse.Data["+ i +"].Plan.DelayedLargeQueryPercentage")); + plan.setTableScan(_ctx.booleanValue("DescribeSQLTuningAdvicesResponse.Data["+ i +"].Plan.TableScan")); + plan.setLargeQueryPercentage(_ctx.floatValue("DescribeSQLTuningAdvicesResponse.Data["+ i +"].Plan.LargeQueryPercentage")); + plan.setSchemaVersion(_ctx.longValue("DescribeSQLTuningAdvicesResponse.Data["+ i +"].Plan.SchemaVersion")); + plan.setPlanId(_ctx.longValue("DescribeSQLTuningAdvicesResponse.Data["+ i +"].Plan.PlanId")); + plan.setFirstLoadTime(_ctx.stringValue("DescribeSQLTuningAdvicesResponse.Data["+ i +"].Plan.FirstLoadTime")); + plan.setAvgRowProcessed(_ctx.floatValue("DescribeSQLTuningAdvicesResponse.Data["+ i +"].Plan.AvgRowProcessed")); + plan.setMergedVersion(_ctx.longValue("DescribeSQLTuningAdvicesResponse.Data["+ i +"].Plan.MergedVersion")); + plan.setHitDiagnosis(_ctx.booleanValue("DescribeSQLTuningAdvicesResponse.Data["+ i +"].Plan.HitDiagnosis")); + plan.setUid(_ctx.stringValue("DescribeSQLTuningAdvicesResponse.Data["+ i +"].Plan.Uid")); + plan.setAvgApplicationWaitTime(_ctx.floatValue("DescribeSQLTuningAdvicesResponse.Data["+ i +"].Plan.AvgApplicationWaitTime")); + plan.setCollectTimeUs(_ctx.longValue("DescribeSQLTuningAdvicesResponse.Data["+ i +"].Plan.CollectTimeUs")); + plan.setAvgElapsedTime(_ctx.floatValue("DescribeSQLTuningAdvicesResponse.Data["+ i +"].Plan.AvgElapsedTime")); + plan.setObServerId(_ctx.longValue("DescribeSQLTuningAdvicesResponse.Data["+ i +"].Plan.ObServerId")); + plan.setOutlineId(_ctx.longValue("DescribeSQLTuningAdvicesResponse.Data["+ i +"].Plan.OutlineId")); + plan.setAvgDiskReads(_ctx.floatValue("DescribeSQLTuningAdvicesResponse.Data["+ i +"].Plan.AvgDiskReads")); + dataItem.setPlan(plan); + + List columns = new ArrayList(); + for (int j = 0; j < _ctx.lengthValue("DescribeSQLTuningAdvicesResponse.Data["+ i +"].Columns.Length"); j++) { + ColumnsItem columnsItem = new ColumnsItem(); + columnsItem.setColumnName(_ctx.stringValue("DescribeSQLTuningAdvicesResponse.Data["+ i +"].Columns["+ j +"].ColumnName")); + columnsItem.setNdv(_ctx.floatValue("DescribeSQLTuningAdvicesResponse.Data["+ i +"].Columns["+ j +"].Ndv")); + columnsItem.setMinValue(_ctx.stringValue("DescribeSQLTuningAdvicesResponse.Data["+ i +"].Columns["+ j +"].MinValue")); + columnsItem.setMaxValue(_ctx.stringValue("DescribeSQLTuningAdvicesResponse.Data["+ i +"].Columns["+ j +"].MaxValue")); + + columns.add(columnsItem); + } + dataItem.setColumns(columns); + + data.add(dataItem); + } + describeSQLTuningAdvicesResponse.setData(data); + + return describeSQLTuningAdvicesResponse; + } +} \ No newline at end of file