1585346868/aliyun-openapi-cpp-sdk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Support restart node list and re-elect zookeeper.

Browse Source
This commit is contained in:
sdk-team
2025-06-12 12:44:51 +00:00
parent 2616afb389
commit 692a2a3429
257 changed files with 21623 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
VERSION
View File

@@ -1 +1 @@
1.36.2076 1.36.2077

334
clickhouse/CMakeLists.txt Normal file
View File

@@ -0,0 +1,334 @@
#
# Copyright 2009-2017 Alibaba Cloud All rights reserved.
#
# 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.
#
set(public_header_dir ${CMAKE_CURRENT_SOURCE_DIR}/../include)
set(clickhouse_public_header
include/alibabacloud/clickhouse/ClickhouseClient.h
include/alibabacloud/clickhouse/ClickhouseExport.h )
set(clickhouse_public_header_model
include/alibabacloud/clickhouse/model/AllocateClusterPublicConnectionRequest.h
include/alibabacloud/clickhouse/model/AllocateClusterPublicConnectionResult.h
include/alibabacloud/clickhouse/model/CheckClickhouseToRDSRequest.h
include/alibabacloud/clickhouse/model/CheckClickhouseToRDSResult.h
include/alibabacloud/clickhouse/model/CheckModifyConfigNeedRestartRequest.h
include/alibabacloud/clickhouse/model/CheckModifyConfigNeedRestartResult.h
include/alibabacloud/clickhouse/model/CheckMonitorAlertRequest.h
include/alibabacloud/clickhouse/model/CheckMonitorAlertResult.h
include/alibabacloud/clickhouse/model/CheckScaleOutBalancedRequest.h
include/alibabacloud/clickhouse/model/CheckScaleOutBalancedResult.h
include/alibabacloud/clickhouse/model/CheckServiceLinkedRoleRequest.h
include/alibabacloud/clickhouse/model/CheckServiceLinkedRoleResult.h
include/alibabacloud/clickhouse/model/CreateAccountRequest.h
include/alibabacloud/clickhouse/model/CreateAccountResult.h
include/alibabacloud/clickhouse/model/CreateAccountAndAuthorityRequest.h
include/alibabacloud/clickhouse/model/CreateAccountAndAuthorityResult.h
include/alibabacloud/clickhouse/model/CreateBackupPolicyRequest.h
include/alibabacloud/clickhouse/model/CreateBackupPolicyResult.h
include/alibabacloud/clickhouse/model/CreateDBInstanceRequest.h
include/alibabacloud/clickhouse/model/CreateDBInstanceResult.h
include/alibabacloud/clickhouse/model/CreateMonitorDataReportRequest.h
include/alibabacloud/clickhouse/model/CreateMonitorDataReportResult.h
include/alibabacloud/clickhouse/model/CreateOSSStorageRequest.h
include/alibabacloud/clickhouse/model/CreateOSSStorageResult.h
include/alibabacloud/clickhouse/model/CreatePortsForClickHouseRequest.h
include/alibabacloud/clickhouse/model/CreatePortsForClickHouseResult.h
include/alibabacloud/clickhouse/model/CreateRDSToClickhouseDbRequest.h
include/alibabacloud/clickhouse/model/CreateRDSToClickhouseDbResult.h
include/alibabacloud/clickhouse/model/CreateSQLAccountRequest.h
include/alibabacloud/clickhouse/model/CreateSQLAccountResult.h
include/alibabacloud/clickhouse/model/CreateServiceLinkedRoleRequest.h
include/alibabacloud/clickhouse/model/CreateServiceLinkedRoleResult.h
include/alibabacloud/clickhouse/model/DeleteAccountRequest.h
include/alibabacloud/clickhouse/model/DeleteAccountResult.h
include/alibabacloud/clickhouse/model/DeleteDBClusterRequest.h
include/alibabacloud/clickhouse/model/DeleteDBClusterResult.h
include/alibabacloud/clickhouse/model/DeleteSyndbRequest.h
include/alibabacloud/clickhouse/model/DeleteSyndbResult.h
include/alibabacloud/clickhouse/model/DescribeAccountAuthorityRequest.h
include/alibabacloud/clickhouse/model/DescribeAccountAuthorityResult.h
include/alibabacloud/clickhouse/model/DescribeAccountsRequest.h
include/alibabacloud/clickhouse/model/DescribeAccountsResult.h
include/alibabacloud/clickhouse/model/DescribeAllDataSourceRequest.h
include/alibabacloud/clickhouse/model/DescribeAllDataSourceResult.h
include/alibabacloud/clickhouse/model/DescribeAllDataSourcesRequest.h
include/alibabacloud/clickhouse/model/DescribeAllDataSourcesResult.h
include/alibabacloud/clickhouse/model/DescribeBackupPolicyRequest.h
include/alibabacloud/clickhouse/model/DescribeBackupPolicyResult.h
include/alibabacloud/clickhouse/model/DescribeBackupsRequest.h
include/alibabacloud/clickhouse/model/DescribeBackupsResult.h
include/alibabacloud/clickhouse/model/DescribeColumnsRequest.h
include/alibabacloud/clickhouse/model/DescribeColumnsResult.h
include/alibabacloud/clickhouse/model/DescribeConfigHistoryRequest.h
include/alibabacloud/clickhouse/model/DescribeConfigHistoryResult.h
include/alibabacloud/clickhouse/model/DescribeConfigVersionDifferenceRequest.h
include/alibabacloud/clickhouse/model/DescribeConfigVersionDifferenceResult.h
include/alibabacloud/clickhouse/model/DescribeDBClusterAccessWhiteListRequest.h
include/alibabacloud/clickhouse/model/DescribeDBClusterAccessWhiteListResult.h
include/alibabacloud/clickhouse/model/DescribeDBClusterAttributeRequest.h
include/alibabacloud/clickhouse/model/DescribeDBClusterAttributeResult.h
include/alibabacloud/clickhouse/model/DescribeDBClusterConfigRequest.h
include/alibabacloud/clickhouse/model/DescribeDBClusterConfigResult.h
include/alibabacloud/clickhouse/model/DescribeDBClusterConfigInXMLRequest.h
include/alibabacloud/clickhouse/model/DescribeDBClusterConfigInXMLResult.h
include/alibabacloud/clickhouse/model/DescribeDBClusterNetInfoItemsRequest.h
include/alibabacloud/clickhouse/model/DescribeDBClusterNetInfoItemsResult.h
include/alibabacloud/clickhouse/model/DescribeDBClusterPerformanceRequest.h
include/alibabacloud/clickhouse/model/DescribeDBClusterPerformanceResult.h
include/alibabacloud/clickhouse/model/DescribeDBClustersRequest.h
include/alibabacloud/clickhouse/model/DescribeDBClustersResult.h
include/alibabacloud/clickhouse/model/DescribeDBConfigRequest.h
include/alibabacloud/clickhouse/model/DescribeDBConfigResult.h
include/alibabacloud/clickhouse/model/DescribeOSSStorageRequest.h
include/alibabacloud/clickhouse/model/DescribeOSSStorageResult.h
include/alibabacloud/clickhouse/model/DescribeProcessListRequest.h
include/alibabacloud/clickhouse/model/DescribeProcessListResult.h
include/alibabacloud/clickhouse/model/DescribeRegionsRequest.h
include/alibabacloud/clickhouse/model/DescribeRegionsResult.h
include/alibabacloud/clickhouse/model/DescribeSchemasRequest.h
include/alibabacloud/clickhouse/model/DescribeSchemasResult.h
include/alibabacloud/clickhouse/model/DescribeSlowLogRecordsRequest.h
include/alibabacloud/clickhouse/model/DescribeSlowLogRecordsResult.h
include/alibabacloud/clickhouse/model/DescribeSynDbTablesRequest.h
include/alibabacloud/clickhouse/model/DescribeSynDbTablesResult.h
include/alibabacloud/clickhouse/model/DescribeSynDbsRequest.h
include/alibabacloud/clickhouse/model/DescribeSynDbsResult.h
include/alibabacloud/clickhouse/model/DescribeTablesRequest.h
include/alibabacloud/clickhouse/model/DescribeTablesResult.h
include/alibabacloud/clickhouse/model/DescribeTransferHistoryRequest.h
include/alibabacloud/clickhouse/model/DescribeTransferHistoryResult.h
include/alibabacloud/clickhouse/model/KillProcessRequest.h
include/alibabacloud/clickhouse/model/KillProcessResult.h
include/alibabacloud/clickhouse/model/ModifyAccountAuthorityRequest.h
include/alibabacloud/clickhouse/model/ModifyAccountAuthorityResult.h
include/alibabacloud/clickhouse/model/ModifyAccountDescriptionRequest.h
include/alibabacloud/clickhouse/model/ModifyAccountDescriptionResult.h
include/alibabacloud/clickhouse/model/ModifyBackupPolicyRequest.h
include/alibabacloud/clickhouse/model/ModifyBackupPolicyResult.h
include/alibabacloud/clickhouse/model/ModifyDBClusterRequest.h
include/alibabacloud/clickhouse/model/ModifyDBClusterResult.h
include/alibabacloud/clickhouse/model/ModifyDBClusterAccessWhiteListRequest.h
include/alibabacloud/clickhouse/model/ModifyDBClusterAccessWhiteListResult.h
include/alibabacloud/clickhouse/model/ModifyDBClusterConfigRequest.h
include/alibabacloud/clickhouse/model/ModifyDBClusterConfigResult.h
include/alibabacloud/clickhouse/model/ModifyDBClusterConfigInXMLRequest.h
include/alibabacloud/clickhouse/model/ModifyDBClusterConfigInXMLResult.h
include/alibabacloud/clickhouse/model/ModifyDBClusterDescriptionRequest.h
include/alibabacloud/clickhouse/model/ModifyDBClusterDescriptionResult.h
include/alibabacloud/clickhouse/model/ModifyDBClusterMaintainTimeRequest.h
include/alibabacloud/clickhouse/model/ModifyDBClusterMaintainTimeResult.h
include/alibabacloud/clickhouse/model/ModifyDBConfigRequest.h
include/alibabacloud/clickhouse/model/ModifyDBConfigResult.h
include/alibabacloud/clickhouse/model/ModifyMinorVersionGreadeTypeRequest.h
include/alibabacloud/clickhouse/model/ModifyMinorVersionGreadeTypeResult.h
include/alibabacloud/clickhouse/model/ModifyRDSToClickhouseDbRequest.h
include/alibabacloud/clickhouse/model/ModifyRDSToClickhouseDbResult.h
include/alibabacloud/clickhouse/model/ReleaseClusterPublicConnectionRequest.h
include/alibabacloud/clickhouse/model/ReleaseClusterPublicConnectionResult.h
include/alibabacloud/clickhouse/model/ResetAccountPasswordRequest.h
include/alibabacloud/clickhouse/model/ResetAccountPasswordResult.h
include/alibabacloud/clickhouse/model/RestartInstanceRequest.h
include/alibabacloud/clickhouse/model/RestartInstanceResult.h
include/alibabacloud/clickhouse/model/TransferVersionRequest.h
include/alibabacloud/clickhouse/model/TransferVersionResult.h
include/alibabacloud/clickhouse/model/UpgradeMinorVersionRequest.h
include/alibabacloud/clickhouse/model/UpgradeMinorVersionResult.h )
set(clickhouse_src
src/ClickhouseClient.cc
src/model/AllocateClusterPublicConnectionRequest.cc
src/model/AllocateClusterPublicConnectionResult.cc
src/model/CheckClickhouseToRDSRequest.cc
src/model/CheckClickhouseToRDSResult.cc
src/model/CheckModifyConfigNeedRestartRequest.cc
src/model/CheckModifyConfigNeedRestartResult.cc
src/model/CheckMonitorAlertRequest.cc
src/model/CheckMonitorAlertResult.cc
src/model/CheckScaleOutBalancedRequest.cc
src/model/CheckScaleOutBalancedResult.cc
src/model/CheckServiceLinkedRoleRequest.cc
src/model/CheckServiceLinkedRoleResult.cc
src/model/CreateAccountRequest.cc
src/model/CreateAccountResult.cc
src/model/CreateAccountAndAuthorityRequest.cc
src/model/CreateAccountAndAuthorityResult.cc
src/model/CreateBackupPolicyRequest.cc
src/model/CreateBackupPolicyResult.cc
src/model/CreateDBInstanceRequest.cc
src/model/CreateDBInstanceResult.cc
src/model/CreateMonitorDataReportRequest.cc
src/model/CreateMonitorDataReportResult.cc
src/model/CreateOSSStorageRequest.cc
src/model/CreateOSSStorageResult.cc
src/model/CreatePortsForClickHouseRequest.cc
src/model/CreatePortsForClickHouseResult.cc
src/model/CreateRDSToClickhouseDbRequest.cc
src/model/CreateRDSToClickhouseDbResult.cc
src/model/CreateSQLAccountRequest.cc
src/model/CreateSQLAccountResult.cc
src/model/CreateServiceLinkedRoleRequest.cc
src/model/CreateServiceLinkedRoleResult.cc
src/model/DeleteAccountRequest.cc
src/model/DeleteAccountResult.cc
src/model/DeleteDBClusterRequest.cc
src/model/DeleteDBClusterResult.cc
src/model/DeleteSyndbRequest.cc
src/model/DeleteSyndbResult.cc
src/model/DescribeAccountAuthorityRequest.cc
src/model/DescribeAccountAuthorityResult.cc
src/model/DescribeAccountsRequest.cc
src/model/DescribeAccountsResult.cc
src/model/DescribeAllDataSourceRequest.cc
src/model/DescribeAllDataSourceResult.cc
src/model/DescribeAllDataSourcesRequest.cc
src/model/DescribeAllDataSourcesResult.cc
src/model/DescribeBackupPolicyRequest.cc
src/model/DescribeBackupPolicyResult.cc
src/model/DescribeBackupsRequest.cc
src/model/DescribeBackupsResult.cc
src/model/DescribeColumnsRequest.cc
src/model/DescribeColumnsResult.cc
src/model/DescribeConfigHistoryRequest.cc
src/model/DescribeConfigHistoryResult.cc
src/model/DescribeConfigVersionDifferenceRequest.cc
src/model/DescribeConfigVersionDifferenceResult.cc
src/model/DescribeDBClusterAccessWhiteListRequest.cc
src/model/DescribeDBClusterAccessWhiteListResult.cc
src/model/DescribeDBClusterAttributeRequest.cc
src/model/DescribeDBClusterAttributeResult.cc
src/model/DescribeDBClusterConfigRequest.cc
src/model/DescribeDBClusterConfigResult.cc
src/model/DescribeDBClusterConfigInXMLRequest.cc
src/model/DescribeDBClusterConfigInXMLResult.cc
src/model/DescribeDBClusterNetInfoItemsRequest.cc
src/model/DescribeDBClusterNetInfoItemsResult.cc
src/model/DescribeDBClusterPerformanceRequest.cc
src/model/DescribeDBClusterPerformanceResult.cc
src/model/DescribeDBClustersRequest.cc
src/model/DescribeDBClustersResult.cc
src/model/DescribeDBConfigRequest.cc
src/model/DescribeDBConfigResult.cc
src/model/DescribeOSSStorageRequest.cc
src/model/DescribeOSSStorageResult.cc
src/model/DescribeProcessListRequest.cc
src/model/DescribeProcessListResult.cc
src/model/DescribeRegionsRequest.cc
src/model/DescribeRegionsResult.cc
src/model/DescribeSchemasRequest.cc
src/model/DescribeSchemasResult.cc
src/model/DescribeSlowLogRecordsRequest.cc
src/model/DescribeSlowLogRecordsResult.cc
src/model/DescribeSynDbTablesRequest.cc
src/model/DescribeSynDbTablesResult.cc
src/model/DescribeSynDbsRequest.cc
src/model/DescribeSynDbsResult.cc
src/model/DescribeTablesRequest.cc
src/model/DescribeTablesResult.cc
src/model/DescribeTransferHistoryRequest.cc
src/model/DescribeTransferHistoryResult.cc
src/model/KillProcessRequest.cc
src/model/KillProcessResult.cc
src/model/ModifyAccountAuthorityRequest.cc
src/model/ModifyAccountAuthorityResult.cc
src/model/ModifyAccountDescriptionRequest.cc
src/model/ModifyAccountDescriptionResult.cc
src/model/ModifyBackupPolicyRequest.cc
src/model/ModifyBackupPolicyResult.cc
src/model/ModifyDBClusterRequest.cc
src/model/ModifyDBClusterResult.cc
src/model/ModifyDBClusterAccessWhiteListRequest.cc
src/model/ModifyDBClusterAccessWhiteListResult.cc
src/model/ModifyDBClusterConfigRequest.cc
src/model/ModifyDBClusterConfigResult.cc
src/model/ModifyDBClusterConfigInXMLRequest.cc
src/model/ModifyDBClusterConfigInXMLResult.cc
src/model/ModifyDBClusterDescriptionRequest.cc
src/model/ModifyDBClusterDescriptionResult.cc
src/model/ModifyDBClusterMaintainTimeRequest.cc
src/model/ModifyDBClusterMaintainTimeResult.cc
src/model/ModifyDBConfigRequest.cc
src/model/ModifyDBConfigResult.cc
src/model/ModifyMinorVersionGreadeTypeRequest.cc
src/model/ModifyMinorVersionGreadeTypeResult.cc
src/model/ModifyRDSToClickhouseDbRequest.cc
src/model/ModifyRDSToClickhouseDbResult.cc
src/model/ReleaseClusterPublicConnectionRequest.cc
src/model/ReleaseClusterPublicConnectionResult.cc
src/model/ResetAccountPasswordRequest.cc
src/model/ResetAccountPasswordResult.cc
src/model/RestartInstanceRequest.cc
src/model/RestartInstanceResult.cc
src/model/TransferVersionRequest.cc
src/model/TransferVersionResult.cc
src/model/UpgradeMinorVersionRequest.cc
src/model/UpgradeMinorVersionResult.cc )
add_library(clickhouse ${LIB_TYPE}
${clickhouse_public_header}
${clickhouse_public_header_model}
${clickhouse_src})
set_target_properties(clickhouse
PROPERTIES
LINKER_LANGUAGE CXX
ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib
LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib
RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin
OUTPUT_NAME ${TARGET_OUTPUT_NAME_PREFIX}clickhouse
)
if(${LIB_TYPE} STREQUAL "SHARED")
set_target_properties(clickhouse
PROPERTIES
DEFINE_SYMBOL ALIBABACLOUD_CLICKHOUSE_LIBRARY)
endif()
target_include_directories(clickhouse
PRIVATE include
${CMAKE_SOURCE_DIR}/core/include
)
target_link_libraries(clickhouse
core)
if(CMAKE_HOST_WIN32)
ExternalProject_Get_Property(jsoncpp INSTALL_DIR)
set(jsoncpp_install_dir ${INSTALL_DIR})
add_dependencies(clickhouse
jsoncpp)
target_include_directories(clickhouse
PRIVATE ${jsoncpp_install_dir}/include)
target_link_libraries(clickhouse
${jsoncpp_install_dir}/lib/jsoncpp.lib)
set_target_properties(clickhouse
PROPERTIES
COMPILE_OPTIONS "/bigobj")
else()
target_include_directories(clickhouse
PRIVATE /usr/include/jsoncpp)
target_link_libraries(clickhouse
jsoncpp)
endif()
install(FILES ${clickhouse_public_header}
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/clickhouse)
install(FILES ${clickhouse_public_header_model}
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/clickhouse/model)
install(TARGETS clickhouse
ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
)

550
clickhouse/include/alibabacloud/clickhouse/ClickhouseClient.h Normal file
View File

@@ -0,0 +1,550 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_CLICKHOUSECLIENT_H_
#define ALIBABACLOUD_CLICKHOUSE_CLICKHOUSECLIENT_H_
#include <future>
#include <alibabacloud/core/AsyncCallerContext.h>
#include <alibabacloud/core/EndpointProvider.h>
#include <alibabacloud/core/RpcServiceClient.h>
#include "ClickhouseExport.h"
#include "model/AllocateClusterPublicConnectionRequest.h"
#include "model/AllocateClusterPublicConnectionResult.h"
#include "model/CheckClickhouseToRDSRequest.h"
#include "model/CheckClickhouseToRDSResult.h"
#include "model/CheckModifyConfigNeedRestartRequest.h"
#include "model/CheckModifyConfigNeedRestartResult.h"
#include "model/CheckMonitorAlertRequest.h"
#include "model/CheckMonitorAlertResult.h"
#include "model/CheckScaleOutBalancedRequest.h"
#include "model/CheckScaleOutBalancedResult.h"
#include "model/CheckServiceLinkedRoleRequest.h"
#include "model/CheckServiceLinkedRoleResult.h"
#include "model/CreateAccountRequest.h"
#include "model/CreateAccountResult.h"
#include "model/CreateAccountAndAuthorityRequest.h"
#include "model/CreateAccountAndAuthorityResult.h"
#include "model/CreateBackupPolicyRequest.h"
#include "model/CreateBackupPolicyResult.h"
#include "model/CreateDBInstanceRequest.h"
#include "model/CreateDBInstanceResult.h"
#include "model/CreateMonitorDataReportRequest.h"
#include "model/CreateMonitorDataReportResult.h"
#include "model/CreateOSSStorageRequest.h"
#include "model/CreateOSSStorageResult.h"
#include "model/CreatePortsForClickHouseRequest.h"
#include "model/CreatePortsForClickHouseResult.h"
#include "model/CreateRDSToClickhouseDbRequest.h"
#include "model/CreateRDSToClickhouseDbResult.h"
#include "model/CreateSQLAccountRequest.h"
#include "model/CreateSQLAccountResult.h"
#include "model/CreateServiceLinkedRoleRequest.h"
#include "model/CreateServiceLinkedRoleResult.h"
#include "model/DeleteAccountRequest.h"
#include "model/DeleteAccountResult.h"
#include "model/DeleteDBClusterRequest.h"
#include "model/DeleteDBClusterResult.h"
#include "model/DeleteSyndbRequest.h"
#include "model/DeleteSyndbResult.h"
#include "model/DescribeAccountAuthorityRequest.h"
#include "model/DescribeAccountAuthorityResult.h"
#include "model/DescribeAccountsRequest.h"
#include "model/DescribeAccountsResult.h"
#include "model/DescribeAllDataSourceRequest.h"
#include "model/DescribeAllDataSourceResult.h"
#include "model/DescribeAllDataSourcesRequest.h"
#include "model/DescribeAllDataSourcesResult.h"
#include "model/DescribeBackupPolicyRequest.h"
#include "model/DescribeBackupPolicyResult.h"
#include "model/DescribeBackupsRequest.h"
#include "model/DescribeBackupsResult.h"
#include "model/DescribeColumnsRequest.h"
#include "model/DescribeColumnsResult.h"
#include "model/DescribeConfigHistoryRequest.h"
#include "model/DescribeConfigHistoryResult.h"
#include "model/DescribeConfigVersionDifferenceRequest.h"
#include "model/DescribeConfigVersionDifferenceResult.h"
#include "model/DescribeDBClusterAccessWhiteListRequest.h"
#include "model/DescribeDBClusterAccessWhiteListResult.h"
#include "model/DescribeDBClusterAttributeRequest.h"
#include "model/DescribeDBClusterAttributeResult.h"
#include "model/DescribeDBClusterConfigRequest.h"
#include "model/DescribeDBClusterConfigResult.h"
#include "model/DescribeDBClusterConfigInXMLRequest.h"
#include "model/DescribeDBClusterConfigInXMLResult.h"
#include "model/DescribeDBClusterNetInfoItemsRequest.h"
#include "model/DescribeDBClusterNetInfoItemsResult.h"
#include "model/DescribeDBClusterPerformanceRequest.h"
#include "model/DescribeDBClusterPerformanceResult.h"
#include "model/DescribeDBClustersRequest.h"
#include "model/DescribeDBClustersResult.h"
#include "model/DescribeDBConfigRequest.h"
#include "model/DescribeDBConfigResult.h"
#include "model/DescribeOSSStorageRequest.h"
#include "model/DescribeOSSStorageResult.h"
#include "model/DescribeProcessListRequest.h"
#include "model/DescribeProcessListResult.h"
#include "model/DescribeRegionsRequest.h"
#include "model/DescribeRegionsResult.h"
#include "model/DescribeSchemasRequest.h"
#include "model/DescribeSchemasResult.h"
#include "model/DescribeSlowLogRecordsRequest.h"
#include "model/DescribeSlowLogRecordsResult.h"
#include "model/DescribeSynDbTablesRequest.h"
#include "model/DescribeSynDbTablesResult.h"
#include "model/DescribeSynDbsRequest.h"
#include "model/DescribeSynDbsResult.h"
#include "model/DescribeTablesRequest.h"
#include "model/DescribeTablesResult.h"
#include "model/DescribeTransferHistoryRequest.h"
#include "model/DescribeTransferHistoryResult.h"
#include "model/KillProcessRequest.h"
#include "model/KillProcessResult.h"
#include "model/ModifyAccountAuthorityRequest.h"
#include "model/ModifyAccountAuthorityResult.h"
#include "model/ModifyAccountDescriptionRequest.h"
#include "model/ModifyAccountDescriptionResult.h"
#include "model/ModifyBackupPolicyRequest.h"
#include "model/ModifyBackupPolicyResult.h"
#include "model/ModifyDBClusterRequest.h"
#include "model/ModifyDBClusterResult.h"
#include "model/ModifyDBClusterAccessWhiteListRequest.h"
#include "model/ModifyDBClusterAccessWhiteListResult.h"
#include "model/ModifyDBClusterConfigRequest.h"
#include "model/ModifyDBClusterConfigResult.h"
#include "model/ModifyDBClusterConfigInXMLRequest.h"
#include "model/ModifyDBClusterConfigInXMLResult.h"
#include "model/ModifyDBClusterDescriptionRequest.h"
#include "model/ModifyDBClusterDescriptionResult.h"
#include "model/ModifyDBClusterMaintainTimeRequest.h"
#include "model/ModifyDBClusterMaintainTimeResult.h"
#include "model/ModifyDBConfigRequest.h"
#include "model/ModifyDBConfigResult.h"
#include "model/ModifyMinorVersionGreadeTypeRequest.h"
#include "model/ModifyMinorVersionGreadeTypeResult.h"
#include "model/ModifyRDSToClickhouseDbRequest.h"
#include "model/ModifyRDSToClickhouseDbResult.h"
#include "model/ReleaseClusterPublicConnectionRequest.h"
#include "model/ReleaseClusterPublicConnectionResult.h"
#include "model/ResetAccountPasswordRequest.h"
#include "model/ResetAccountPasswordResult.h"
#include "model/RestartInstanceRequest.h"
#include "model/RestartInstanceResult.h"
#include "model/TransferVersionRequest.h"
#include "model/TransferVersionResult.h"
#include "model/UpgradeMinorVersionRequest.h"
#include "model/UpgradeMinorVersionResult.h"
namespace AlibabaCloud
{
namespace Clickhouse
{
class ALIBABACLOUD_CLICKHOUSE_EXPORT ClickhouseClient : public RpcServiceClient
{
public:
typedef Outcome<Error, Model::AllocateClusterPublicConnectionResult> AllocateClusterPublicConnectionOutcome;
typedef std::future<AllocateClusterPublicConnectionOutcome> AllocateClusterPublicConnectionOutcomeCallable;
typedef std::function<void(const ClickhouseClient*, const Model::AllocateClusterPublicConnectionRequest&, const AllocateClusterPublicConnectionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AllocateClusterPublicConnectionAsyncHandler;
typedef Outcome<Error, Model::CheckClickhouseToRDSResult> CheckClickhouseToRDSOutcome;
typedef std::future<CheckClickhouseToRDSOutcome> CheckClickhouseToRDSOutcomeCallable;
typedef std::function<void(const ClickhouseClient*, const Model::CheckClickhouseToRDSRequest&, const CheckClickhouseToRDSOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CheckClickhouseToRDSAsyncHandler;
typedef Outcome<Error, Model::CheckModifyConfigNeedRestartResult> CheckModifyConfigNeedRestartOutcome;
typedef std::future<CheckModifyConfigNeedRestartOutcome> CheckModifyConfigNeedRestartOutcomeCallable;
typedef std::function<void(const ClickhouseClient*, const Model::CheckModifyConfigNeedRestartRequest&, const CheckModifyConfigNeedRestartOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CheckModifyConfigNeedRestartAsyncHandler;
typedef Outcome<Error, Model::CheckMonitorAlertResult> CheckMonitorAlertOutcome;
typedef std::future<CheckMonitorAlertOutcome> CheckMonitorAlertOutcomeCallable;
typedef std::function<void(const ClickhouseClient*, const Model::CheckMonitorAlertRequest&, const CheckMonitorAlertOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CheckMonitorAlertAsyncHandler;
typedef Outcome<Error, Model::CheckScaleOutBalancedResult> CheckScaleOutBalancedOutcome;
typedef std::future<CheckScaleOutBalancedOutcome> CheckScaleOutBalancedOutcomeCallable;
typedef std::function<void(const ClickhouseClient*, const Model::CheckScaleOutBalancedRequest&, const CheckScaleOutBalancedOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CheckScaleOutBalancedAsyncHandler;
typedef Outcome<Error, Model::CheckServiceLinkedRoleResult> CheckServiceLinkedRoleOutcome;
typedef std::future<CheckServiceLinkedRoleOutcome> CheckServiceLinkedRoleOutcomeCallable;
typedef std::function<void(const ClickhouseClient*, const Model::CheckServiceLinkedRoleRequest&, const CheckServiceLinkedRoleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CheckServiceLinkedRoleAsyncHandler;
typedef Outcome<Error, Model::CreateAccountResult> CreateAccountOutcome;
typedef std::future<CreateAccountOutcome> CreateAccountOutcomeCallable;
typedef std::function<void(const ClickhouseClient*, const Model::CreateAccountRequest&, const CreateAccountOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateAccountAsyncHandler;
typedef Outcome<Error, Model::CreateAccountAndAuthorityResult> CreateAccountAndAuthorityOutcome;
typedef std::future<CreateAccountAndAuthorityOutcome> CreateAccountAndAuthorityOutcomeCallable;
typedef std::function<void(const ClickhouseClient*, const Model::CreateAccountAndAuthorityRequest&, const CreateAccountAndAuthorityOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateAccountAndAuthorityAsyncHandler;
typedef Outcome<Error, Model::CreateBackupPolicyResult> CreateBackupPolicyOutcome;
typedef std::future<CreateBackupPolicyOutcome> CreateBackupPolicyOutcomeCallable;
typedef std::function<void(const ClickhouseClient*, const Model::CreateBackupPolicyRequest&, const CreateBackupPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateBackupPolicyAsyncHandler;
typedef Outcome<Error, Model::CreateDBInstanceResult> CreateDBInstanceOutcome;
typedef std::future<CreateDBInstanceOutcome> CreateDBInstanceOutcomeCallable;
typedef std::function<void(const ClickhouseClient*, const Model::CreateDBInstanceRequest&, const CreateDBInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateDBInstanceAsyncHandler;
typedef Outcome<Error, Model::CreateMonitorDataReportResult> CreateMonitorDataReportOutcome;
typedef std::future<CreateMonitorDataReportOutcome> CreateMonitorDataReportOutcomeCallable;
typedef std::function<void(const ClickhouseClient*, const Model::CreateMonitorDataReportRequest&, const CreateMonitorDataReportOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateMonitorDataReportAsyncHandler;
typedef Outcome<Error, Model::CreateOSSStorageResult> CreateOSSStorageOutcome;
typedef std::future<CreateOSSStorageOutcome> CreateOSSStorageOutcomeCallable;
typedef std::function<void(const ClickhouseClient*, const Model::CreateOSSStorageRequest&, const CreateOSSStorageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateOSSStorageAsyncHandler;
typedef Outcome<Error, Model::CreatePortsForClickHouseResult> CreatePortsForClickHouseOutcome;
typedef std::future<CreatePortsForClickHouseOutcome> CreatePortsForClickHouseOutcomeCallable;
typedef std::function<void(const ClickhouseClient*, const Model::CreatePortsForClickHouseRequest&, const CreatePortsForClickHouseOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreatePortsForClickHouseAsyncHandler;
typedef Outcome<Error, Model::CreateRDSToClickhouseDbResult> CreateRDSToClickhouseDbOutcome;
typedef std::future<CreateRDSToClickhouseDbOutcome> CreateRDSToClickhouseDbOutcomeCallable;
typedef std::function<void(const ClickhouseClient*, const Model::CreateRDSToClickhouseDbRequest&, const CreateRDSToClickhouseDbOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateRDSToClickhouseDbAsyncHandler;
typedef Outcome<Error, Model::CreateSQLAccountResult> CreateSQLAccountOutcome;
typedef std::future<CreateSQLAccountOutcome> CreateSQLAccountOutcomeCallable;
typedef std::function<void(const ClickhouseClient*, const Model::CreateSQLAccountRequest&, const CreateSQLAccountOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateSQLAccountAsyncHandler;
typedef Outcome<Error, Model::CreateServiceLinkedRoleResult> CreateServiceLinkedRoleOutcome;
typedef std::future<CreateServiceLinkedRoleOutcome> CreateServiceLinkedRoleOutcomeCallable;
typedef std::function<void(const ClickhouseClient*, const Model::CreateServiceLinkedRoleRequest&, const CreateServiceLinkedRoleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateServiceLinkedRoleAsyncHandler;
typedef Outcome<Error, Model::DeleteAccountResult> DeleteAccountOutcome;
typedef std::future<DeleteAccountOutcome> DeleteAccountOutcomeCallable;
typedef std::function<void(const ClickhouseClient*, const Model::DeleteAccountRequest&, const DeleteAccountOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteAccountAsyncHandler;
typedef Outcome<Error, Model::DeleteDBClusterResult> DeleteDBClusterOutcome;
typedef std::future<DeleteDBClusterOutcome> DeleteDBClusterOutcomeCallable;
typedef std::function<void(const ClickhouseClient*, const Model::DeleteDBClusterRequest&, const DeleteDBClusterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteDBClusterAsyncHandler;
typedef Outcome<Error, Model::DeleteSyndbResult> DeleteSyndbOutcome;
typedef std::future<DeleteSyndbOutcome> DeleteSyndbOutcomeCallable;
typedef std::function<void(const ClickhouseClient*, const Model::DeleteSyndbRequest&, const DeleteSyndbOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteSyndbAsyncHandler;
typedef Outcome<Error, Model::DescribeAccountAuthorityResult> DescribeAccountAuthorityOutcome;
typedef std::future<DescribeAccountAuthorityOutcome> DescribeAccountAuthorityOutcomeCallable;
typedef std::function<void(const ClickhouseClient*, const Model::DescribeAccountAuthorityRequest&, const DescribeAccountAuthorityOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeAccountAuthorityAsyncHandler;
typedef Outcome<Error, Model::DescribeAccountsResult> DescribeAccountsOutcome;
typedef std::future<DescribeAccountsOutcome> DescribeAccountsOutcomeCallable;
typedef std::function<void(const ClickhouseClient*, const Model::DescribeAccountsRequest&, const DescribeAccountsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeAccountsAsyncHandler;
typedef Outcome<Error, Model::DescribeAllDataSourceResult> DescribeAllDataSourceOutcome;
typedef std::future<DescribeAllDataSourceOutcome> DescribeAllDataSourceOutcomeCallable;
typedef std::function<void(const ClickhouseClient*, const Model::DescribeAllDataSourceRequest&, const DescribeAllDataSourceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeAllDataSourceAsyncHandler;
typedef Outcome<Error, Model::DescribeAllDataSourcesResult> DescribeAllDataSourcesOutcome;
typedef std::future<DescribeAllDataSourcesOutcome> DescribeAllDataSourcesOutcomeCallable;
typedef std::function<void(const ClickhouseClient*, const Model::DescribeAllDataSourcesRequest&, const DescribeAllDataSourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeAllDataSourcesAsyncHandler;
typedef Outcome<Error, Model::DescribeBackupPolicyResult> DescribeBackupPolicyOutcome;
typedef std::future<DescribeBackupPolicyOutcome> DescribeBackupPolicyOutcomeCallable;
typedef std::function<void(const ClickhouseClient*, const Model::DescribeBackupPolicyRequest&, const DescribeBackupPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeBackupPolicyAsyncHandler;
typedef Outcome<Error, Model::DescribeBackupsResult> DescribeBackupsOutcome;
typedef std::future<DescribeBackupsOutcome> DescribeBackupsOutcomeCallable;
typedef std::function<void(const ClickhouseClient*, const Model::DescribeBackupsRequest&, const DescribeBackupsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeBackupsAsyncHandler;
typedef Outcome<Error, Model::DescribeColumnsResult> DescribeColumnsOutcome;
typedef std::future<DescribeColumnsOutcome> DescribeColumnsOutcomeCallable;
typedef std::function<void(const ClickhouseClient*, const Model::DescribeColumnsRequest&, const DescribeColumnsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeColumnsAsyncHandler;
typedef Outcome<Error, Model::DescribeConfigHistoryResult> DescribeConfigHistoryOutcome;
typedef std::future<DescribeConfigHistoryOutcome> DescribeConfigHistoryOutcomeCallable;
typedef std::function<void(const ClickhouseClient*, const Model::DescribeConfigHistoryRequest&, const DescribeConfigHistoryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeConfigHistoryAsyncHandler;
typedef Outcome<Error, Model::DescribeConfigVersionDifferenceResult> DescribeConfigVersionDifferenceOutcome;
typedef std::future<DescribeConfigVersionDifferenceOutcome> DescribeConfigVersionDifferenceOutcomeCallable;
typedef std::function<void(const ClickhouseClient*, const Model::DescribeConfigVersionDifferenceRequest&, const DescribeConfigVersionDifferenceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeConfigVersionDifferenceAsyncHandler;
typedef Outcome<Error, Model::DescribeDBClusterAccessWhiteListResult> DescribeDBClusterAccessWhiteListOutcome;
typedef std::future<DescribeDBClusterAccessWhiteListOutcome> DescribeDBClusterAccessWhiteListOutcomeCallable;
typedef std::function<void(const ClickhouseClient*, const Model::DescribeDBClusterAccessWhiteListRequest&, const DescribeDBClusterAccessWhiteListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDBClusterAccessWhiteListAsyncHandler;
typedef Outcome<Error, Model::DescribeDBClusterAttributeResult> DescribeDBClusterAttributeOutcome;
typedef std::future<DescribeDBClusterAttributeOutcome> DescribeDBClusterAttributeOutcomeCallable;
typedef std::function<void(const ClickhouseClient*, const Model::DescribeDBClusterAttributeRequest&, const DescribeDBClusterAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDBClusterAttributeAsyncHandler;
typedef Outcome<Error, Model::DescribeDBClusterConfigResult> DescribeDBClusterConfigOutcome;
typedef std::future<DescribeDBClusterConfigOutcome> DescribeDBClusterConfigOutcomeCallable;
typedef std::function<void(const ClickhouseClient*, const Model::DescribeDBClusterConfigRequest&, const DescribeDBClusterConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDBClusterConfigAsyncHandler;
typedef Outcome<Error, Model::DescribeDBClusterConfigInXMLResult> DescribeDBClusterConfigInXMLOutcome;
typedef std::future<DescribeDBClusterConfigInXMLOutcome> DescribeDBClusterConfigInXMLOutcomeCallable;
typedef std::function<void(const ClickhouseClient*, const Model::DescribeDBClusterConfigInXMLRequest&, const DescribeDBClusterConfigInXMLOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDBClusterConfigInXMLAsyncHandler;
typedef Outcome<Error, Model::DescribeDBClusterNetInfoItemsResult> DescribeDBClusterNetInfoItemsOutcome;
typedef std::future<DescribeDBClusterNetInfoItemsOutcome> DescribeDBClusterNetInfoItemsOutcomeCallable;
typedef std::function<void(const ClickhouseClient*, const Model::DescribeDBClusterNetInfoItemsRequest&, const DescribeDBClusterNetInfoItemsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDBClusterNetInfoItemsAsyncHandler;
typedef Outcome<Error, Model::DescribeDBClusterPerformanceResult> DescribeDBClusterPerformanceOutcome;
typedef std::future<DescribeDBClusterPerformanceOutcome> DescribeDBClusterPerformanceOutcomeCallable;
typedef std::function<void(const ClickhouseClient*, const Model::DescribeDBClusterPerformanceRequest&, const DescribeDBClusterPerformanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDBClusterPerformanceAsyncHandler;
typedef Outcome<Error, Model::DescribeDBClustersResult> DescribeDBClustersOutcome;
typedef std::future<DescribeDBClustersOutcome> DescribeDBClustersOutcomeCallable;
typedef std::function<void(const ClickhouseClient*, const Model::DescribeDBClustersRequest&, const DescribeDBClustersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDBClustersAsyncHandler;
typedef Outcome<Error, Model::DescribeDBConfigResult> DescribeDBConfigOutcome;
typedef std::future<DescribeDBConfigOutcome> DescribeDBConfigOutcomeCallable;
typedef std::function<void(const ClickhouseClient*, const Model::DescribeDBConfigRequest&, const DescribeDBConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDBConfigAsyncHandler;
typedef Outcome<Error, Model::DescribeOSSStorageResult> DescribeOSSStorageOutcome;
typedef std::future<DescribeOSSStorageOutcome> DescribeOSSStorageOutcomeCallable;
typedef std::function<void(const ClickhouseClient*, const Model::DescribeOSSStorageRequest&, const DescribeOSSStorageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeOSSStorageAsyncHandler;
typedef Outcome<Error, Model::DescribeProcessListResult> DescribeProcessListOutcome;
typedef std::future<DescribeProcessListOutcome> DescribeProcessListOutcomeCallable;
typedef std::function<void(const ClickhouseClient*, const Model::DescribeProcessListRequest&, const DescribeProcessListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeProcessListAsyncHandler;
typedef Outcome<Error, Model::DescribeRegionsResult> DescribeRegionsOutcome;
typedef std::future<DescribeRegionsOutcome> DescribeRegionsOutcomeCallable;
typedef std::function<void(const ClickhouseClient*, const Model::DescribeRegionsRequest&, const DescribeRegionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeRegionsAsyncHandler;
typedef Outcome<Error, Model::DescribeSchemasResult> DescribeSchemasOutcome;
typedef std::future<DescribeSchemasOutcome> DescribeSchemasOutcomeCallable;
typedef std::function<void(const ClickhouseClient*, const Model::DescribeSchemasRequest&, const DescribeSchemasOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeSchemasAsyncHandler;
typedef Outcome<Error, Model::DescribeSlowLogRecordsResult> DescribeSlowLogRecordsOutcome;
typedef std::future<DescribeSlowLogRecordsOutcome> DescribeSlowLogRecordsOutcomeCallable;
typedef std::function<void(const ClickhouseClient*, const Model::DescribeSlowLogRecordsRequest&, const DescribeSlowLogRecordsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeSlowLogRecordsAsyncHandler;
typedef Outcome<Error, Model::DescribeSynDbTablesResult> DescribeSynDbTablesOutcome;
typedef std::future<DescribeSynDbTablesOutcome> DescribeSynDbTablesOutcomeCallable;
typedef std::function<void(const ClickhouseClient*, const Model::DescribeSynDbTablesRequest&, const DescribeSynDbTablesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeSynDbTablesAsyncHandler;
typedef Outcome<Error, Model::DescribeSynDbsResult> DescribeSynDbsOutcome;
typedef std::future<DescribeSynDbsOutcome> DescribeSynDbsOutcomeCallable;
typedef std::function<void(const ClickhouseClient*, const Model::DescribeSynDbsRequest&, const DescribeSynDbsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeSynDbsAsyncHandler;
typedef Outcome<Error, Model::DescribeTablesResult> DescribeTablesOutcome;
typedef std::future<DescribeTablesOutcome> DescribeTablesOutcomeCallable;
typedef std::function<void(const ClickhouseClient*, const Model::DescribeTablesRequest&, const DescribeTablesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeTablesAsyncHandler;
typedef Outcome<Error, Model::DescribeTransferHistoryResult> DescribeTransferHistoryOutcome;
typedef std::future<DescribeTransferHistoryOutcome> DescribeTransferHistoryOutcomeCallable;
typedef std::function<void(const ClickhouseClient*, const Model::DescribeTransferHistoryRequest&, const DescribeTransferHistoryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeTransferHistoryAsyncHandler;
typedef Outcome<Error, Model::KillProcessResult> KillProcessOutcome;
typedef std::future<KillProcessOutcome> KillProcessOutcomeCallable;
typedef std::function<void(const ClickhouseClient*, const Model::KillProcessRequest&, const KillProcessOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> KillProcessAsyncHandler;
typedef Outcome<Error, Model::ModifyAccountAuthorityResult> ModifyAccountAuthorityOutcome;
typedef std::future<ModifyAccountAuthorityOutcome> ModifyAccountAuthorityOutcomeCallable;
typedef std::function<void(const ClickhouseClient*, const Model::ModifyAccountAuthorityRequest&, const ModifyAccountAuthorityOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyAccountAuthorityAsyncHandler;
typedef Outcome<Error, Model::ModifyAccountDescriptionResult> ModifyAccountDescriptionOutcome;
typedef std::future<ModifyAccountDescriptionOutcome> ModifyAccountDescriptionOutcomeCallable;
typedef std::function<void(const ClickhouseClient*, const Model::ModifyAccountDescriptionRequest&, const ModifyAccountDescriptionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyAccountDescriptionAsyncHandler;
typedef Outcome<Error, Model::ModifyBackupPolicyResult> ModifyBackupPolicyOutcome;
typedef std::future<ModifyBackupPolicyOutcome> ModifyBackupPolicyOutcomeCallable;
typedef std::function<void(const ClickhouseClient*, const Model::ModifyBackupPolicyRequest&, const ModifyBackupPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyBackupPolicyAsyncHandler;
typedef Outcome<Error, Model::ModifyDBClusterResult> ModifyDBClusterOutcome;
typedef std::future<ModifyDBClusterOutcome> ModifyDBClusterOutcomeCallable;
typedef std::function<void(const ClickhouseClient*, const Model::ModifyDBClusterRequest&, const ModifyDBClusterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyDBClusterAsyncHandler;
typedef Outcome<Error, Model::ModifyDBClusterAccessWhiteListResult> ModifyDBClusterAccessWhiteListOutcome;
typedef std::future<ModifyDBClusterAccessWhiteListOutcome> ModifyDBClusterAccessWhiteListOutcomeCallable;
typedef std::function<void(const ClickhouseClient*, const Model::ModifyDBClusterAccessWhiteListRequest&, const ModifyDBClusterAccessWhiteListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyDBClusterAccessWhiteListAsyncHandler;
typedef Outcome<Error, Model::ModifyDBClusterConfigResult> ModifyDBClusterConfigOutcome;
typedef std::future<ModifyDBClusterConfigOutcome> ModifyDBClusterConfigOutcomeCallable;
typedef std::function<void(const ClickhouseClient*, const Model::ModifyDBClusterConfigRequest&, const ModifyDBClusterConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyDBClusterConfigAsyncHandler;
typedef Outcome<Error, Model::ModifyDBClusterConfigInXMLResult> ModifyDBClusterConfigInXMLOutcome;
typedef std::future<ModifyDBClusterConfigInXMLOutcome> ModifyDBClusterConfigInXMLOutcomeCallable;
typedef std::function<void(const ClickhouseClient*, const Model::ModifyDBClusterConfigInXMLRequest&, const ModifyDBClusterConfigInXMLOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyDBClusterConfigInXMLAsyncHandler;
typedef Outcome<Error, Model::ModifyDBClusterDescriptionResult> ModifyDBClusterDescriptionOutcome;
typedef std::future<ModifyDBClusterDescriptionOutcome> ModifyDBClusterDescriptionOutcomeCallable;
typedef std::function<void(const ClickhouseClient*, const Model::ModifyDBClusterDescriptionRequest&, const ModifyDBClusterDescriptionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyDBClusterDescriptionAsyncHandler;
typedef Outcome<Error, Model::ModifyDBClusterMaintainTimeResult> ModifyDBClusterMaintainTimeOutcome;
typedef std::future<ModifyDBClusterMaintainTimeOutcome> ModifyDBClusterMaintainTimeOutcomeCallable;
typedef std::function<void(const ClickhouseClient*, const Model::ModifyDBClusterMaintainTimeRequest&, const ModifyDBClusterMaintainTimeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyDBClusterMaintainTimeAsyncHandler;
typedef Outcome<Error, Model::ModifyDBConfigResult> ModifyDBConfigOutcome;
typedef std::future<ModifyDBConfigOutcome> ModifyDBConfigOutcomeCallable;
typedef std::function<void(const ClickhouseClient*, const Model::ModifyDBConfigRequest&, const ModifyDBConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyDBConfigAsyncHandler;
typedef Outcome<Error, Model::ModifyMinorVersionGreadeTypeResult> ModifyMinorVersionGreadeTypeOutcome;
typedef std::future<ModifyMinorVersionGreadeTypeOutcome> ModifyMinorVersionGreadeTypeOutcomeCallable;
typedef std::function<void(const ClickhouseClient*, const Model::ModifyMinorVersionGreadeTypeRequest&, const ModifyMinorVersionGreadeTypeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyMinorVersionGreadeTypeAsyncHandler;
typedef Outcome<Error, Model::ModifyRDSToClickhouseDbResult> ModifyRDSToClickhouseDbOutcome;
typedef std::future<ModifyRDSToClickhouseDbOutcome> ModifyRDSToClickhouseDbOutcomeCallable;
typedef std::function<void(const ClickhouseClient*, const Model::ModifyRDSToClickhouseDbRequest&, const ModifyRDSToClickhouseDbOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyRDSToClickhouseDbAsyncHandler;
typedef Outcome<Error, Model::ReleaseClusterPublicConnectionResult> ReleaseClusterPublicConnectionOutcome;
typedef std::future<ReleaseClusterPublicConnectionOutcome> ReleaseClusterPublicConnectionOutcomeCallable;
typedef std::function<void(const ClickhouseClient*, const Model::ReleaseClusterPublicConnectionRequest&, const ReleaseClusterPublicConnectionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ReleaseClusterPublicConnectionAsyncHandler;
typedef Outcome<Error, Model::ResetAccountPasswordResult> ResetAccountPasswordOutcome;
typedef std::future<ResetAccountPasswordOutcome> ResetAccountPasswordOutcomeCallable;
typedef std::function<void(const ClickhouseClient*, const Model::ResetAccountPasswordRequest&, const ResetAccountPasswordOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ResetAccountPasswordAsyncHandler;
typedef Outcome<Error, Model::RestartInstanceResult> RestartInstanceOutcome;
typedef std::future<RestartInstanceOutcome> RestartInstanceOutcomeCallable;
typedef std::function<void(const ClickhouseClient*, const Model::RestartInstanceRequest&, const RestartInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RestartInstanceAsyncHandler;
typedef Outcome<Error, Model::TransferVersionResult> TransferVersionOutcome;
typedef std::future<TransferVersionOutcome> TransferVersionOutcomeCallable;
typedef std::function<void(const ClickhouseClient*, const Model::TransferVersionRequest&, const TransferVersionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> TransferVersionAsyncHandler;
typedef Outcome<Error, Model::UpgradeMinorVersionResult> UpgradeMinorVersionOutcome;
typedef std::future<UpgradeMinorVersionOutcome> UpgradeMinorVersionOutcomeCallable;
typedef std::function<void(const ClickhouseClient*, const Model::UpgradeMinorVersionRequest&, const UpgradeMinorVersionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpgradeMinorVersionAsyncHandler;
ClickhouseClient(const Credentials &credentials, const ClientConfiguration &configuration);
ClickhouseClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
ClickhouseClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
~ClickhouseClient();
AllocateClusterPublicConnectionOutcome allocateClusterPublicConnection(const Model::AllocateClusterPublicConnectionRequest &request)const;
void allocateClusterPublicConnectionAsync(const Model::AllocateClusterPublicConnectionRequest& request, const AllocateClusterPublicConnectionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AllocateClusterPublicConnectionOutcomeCallable allocateClusterPublicConnectionCallable(const Model::AllocateClusterPublicConnectionRequest& request) const;
CheckClickhouseToRDSOutcome checkClickhouseToRDS(const Model::CheckClickhouseToRDSRequest &request)const;
void checkClickhouseToRDSAsync(const Model::CheckClickhouseToRDSRequest& request, const CheckClickhouseToRDSAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CheckClickhouseToRDSOutcomeCallable checkClickhouseToRDSCallable(const Model::CheckClickhouseToRDSRequest& request) const;
CheckModifyConfigNeedRestartOutcome checkModifyConfigNeedRestart(const Model::CheckModifyConfigNeedRestartRequest &request)const;
void checkModifyConfigNeedRestartAsync(const Model::CheckModifyConfigNeedRestartRequest& request, const CheckModifyConfigNeedRestartAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CheckModifyConfigNeedRestartOutcomeCallable checkModifyConfigNeedRestartCallable(const Model::CheckModifyConfigNeedRestartRequest& request) const;
CheckMonitorAlertOutcome checkMonitorAlert(const Model::CheckMonitorAlertRequest &request)const;
void checkMonitorAlertAsync(const Model::CheckMonitorAlertRequest& request, const CheckMonitorAlertAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CheckMonitorAlertOutcomeCallable checkMonitorAlertCallable(const Model::CheckMonitorAlertRequest& request) const;
CheckScaleOutBalancedOutcome checkScaleOutBalanced(const Model::CheckScaleOutBalancedRequest &request)const;
void checkScaleOutBalancedAsync(const Model::CheckScaleOutBalancedRequest& request, const CheckScaleOutBalancedAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CheckScaleOutBalancedOutcomeCallable checkScaleOutBalancedCallable(const Model::CheckScaleOutBalancedRequest& request) const;
CheckServiceLinkedRoleOutcome checkServiceLinkedRole(const Model::CheckServiceLinkedRoleRequest &request)const;
void checkServiceLinkedRoleAsync(const Model::CheckServiceLinkedRoleRequest& request, const CheckServiceLinkedRoleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CheckServiceLinkedRoleOutcomeCallable checkServiceLinkedRoleCallable(const Model::CheckServiceLinkedRoleRequest& request) const;
CreateAccountOutcome createAccount(const Model::CreateAccountRequest &request)const;
void createAccountAsync(const Model::CreateAccountRequest& request, const CreateAccountAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateAccountOutcomeCallable createAccountCallable(const Model::CreateAccountRequest& request) const;
CreateAccountAndAuthorityOutcome createAccountAndAuthority(const Model::CreateAccountAndAuthorityRequest &request)const;
void createAccountAndAuthorityAsync(const Model::CreateAccountAndAuthorityRequest& request, const CreateAccountAndAuthorityAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateAccountAndAuthorityOutcomeCallable createAccountAndAuthorityCallable(const Model::CreateAccountAndAuthorityRequest& request) const;
CreateBackupPolicyOutcome createBackupPolicy(const Model::CreateBackupPolicyRequest &request)const;
void createBackupPolicyAsync(const Model::CreateBackupPolicyRequest& request, const CreateBackupPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateBackupPolicyOutcomeCallable createBackupPolicyCallable(const Model::CreateBackupPolicyRequest& request) const;
CreateDBInstanceOutcome createDBInstance(const Model::CreateDBInstanceRequest &request)const;
void createDBInstanceAsync(const Model::CreateDBInstanceRequest& request, const CreateDBInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateDBInstanceOutcomeCallable createDBInstanceCallable(const Model::CreateDBInstanceRequest& request) const;
CreateMonitorDataReportOutcome createMonitorDataReport(const Model::CreateMonitorDataReportRequest &request)const;
void createMonitorDataReportAsync(const Model::CreateMonitorDataReportRequest& request, const CreateMonitorDataReportAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateMonitorDataReportOutcomeCallable createMonitorDataReportCallable(const Model::CreateMonitorDataReportRequest& request) const;
CreateOSSStorageOutcome createOSSStorage(const Model::CreateOSSStorageRequest &request)const;
void createOSSStorageAsync(const Model::CreateOSSStorageRequest& request, const CreateOSSStorageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateOSSStorageOutcomeCallable createOSSStorageCallable(const Model::CreateOSSStorageRequest& request) const;
CreatePortsForClickHouseOutcome createPortsForClickHouse(const Model::CreatePortsForClickHouseRequest &request)const;
void createPortsForClickHouseAsync(const Model::CreatePortsForClickHouseRequest& request, const CreatePortsForClickHouseAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreatePortsForClickHouseOutcomeCallable createPortsForClickHouseCallable(const Model::CreatePortsForClickHouseRequest& request) const;
CreateRDSToClickhouseDbOutcome createRDSToClickhouseDb(const Model::CreateRDSToClickhouseDbRequest &request)const;
void createRDSToClickhouseDbAsync(const Model::CreateRDSToClickhouseDbRequest& request, const CreateRDSToClickhouseDbAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateRDSToClickhouseDbOutcomeCallable createRDSToClickhouseDbCallable(const Model::CreateRDSToClickhouseDbRequest& request) const;
CreateSQLAccountOutcome createSQLAccount(const Model::CreateSQLAccountRequest &request)const;
void createSQLAccountAsync(const Model::CreateSQLAccountRequest& request, const CreateSQLAccountAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateSQLAccountOutcomeCallable createSQLAccountCallable(const Model::CreateSQLAccountRequest& request) const;
CreateServiceLinkedRoleOutcome createServiceLinkedRole(const Model::CreateServiceLinkedRoleRequest &request)const;
void createServiceLinkedRoleAsync(const Model::CreateServiceLinkedRoleRequest& request, const CreateServiceLinkedRoleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateServiceLinkedRoleOutcomeCallable createServiceLinkedRoleCallable(const Model::CreateServiceLinkedRoleRequest& request) const;
DeleteAccountOutcome deleteAccount(const Model::DeleteAccountRequest &request)const;
void deleteAccountAsync(const Model::DeleteAccountRequest& request, const DeleteAccountAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteAccountOutcomeCallable deleteAccountCallable(const Model::DeleteAccountRequest& request) const;
DeleteDBClusterOutcome deleteDBCluster(const Model::DeleteDBClusterRequest &request)const;
void deleteDBClusterAsync(const Model::DeleteDBClusterRequest& request, const DeleteDBClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteDBClusterOutcomeCallable deleteDBClusterCallable(const Model::DeleteDBClusterRequest& request) const;
DeleteSyndbOutcome deleteSyndb(const Model::DeleteSyndbRequest &request)const;
void deleteSyndbAsync(const Model::DeleteSyndbRequest& request, const DeleteSyndbAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteSyndbOutcomeCallable deleteSyndbCallable(const Model::DeleteSyndbRequest& request) const;
DescribeAccountAuthorityOutcome describeAccountAuthority(const Model::DescribeAccountAuthorityRequest &request)const;
void describeAccountAuthorityAsync(const Model::DescribeAccountAuthorityRequest& request, const DescribeAccountAuthorityAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeAccountAuthorityOutcomeCallable describeAccountAuthorityCallable(const Model::DescribeAccountAuthorityRequest& request) const;
DescribeAccountsOutcome describeAccounts(const Model::DescribeAccountsRequest &request)const;
void describeAccountsAsync(const Model::DescribeAccountsRequest& request, const DescribeAccountsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeAccountsOutcomeCallable describeAccountsCallable(const Model::DescribeAccountsRequest& request) const;
DescribeAllDataSourceOutcome describeAllDataSource(const Model::DescribeAllDataSourceRequest &request)const;
void describeAllDataSourceAsync(const Model::DescribeAllDataSourceRequest& request, const DescribeAllDataSourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeAllDataSourceOutcomeCallable describeAllDataSourceCallable(const Model::DescribeAllDataSourceRequest& request) const;
DescribeAllDataSourcesOutcome describeAllDataSources(const Model::DescribeAllDataSourcesRequest &request)const;
void describeAllDataSourcesAsync(const Model::DescribeAllDataSourcesRequest& request, const DescribeAllDataSourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeAllDataSourcesOutcomeCallable describeAllDataSourcesCallable(const Model::DescribeAllDataSourcesRequest& request) const;
DescribeBackupPolicyOutcome describeBackupPolicy(const Model::DescribeBackupPolicyRequest &request)const;
void describeBackupPolicyAsync(const Model::DescribeBackupPolicyRequest& request, const DescribeBackupPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeBackupPolicyOutcomeCallable describeBackupPolicyCallable(const Model::DescribeBackupPolicyRequest& request) const;
DescribeBackupsOutcome describeBackups(const Model::DescribeBackupsRequest &request)const;
void describeBackupsAsync(const Model::DescribeBackupsRequest& request, const DescribeBackupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeBackupsOutcomeCallable describeBackupsCallable(const Model::DescribeBackupsRequest& request) const;
DescribeColumnsOutcome describeColumns(const Model::DescribeColumnsRequest &request)const;
void describeColumnsAsync(const Model::DescribeColumnsRequest& request, const DescribeColumnsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeColumnsOutcomeCallable describeColumnsCallable(const Model::DescribeColumnsRequest& request) const;
DescribeConfigHistoryOutcome describeConfigHistory(const Model::DescribeConfigHistoryRequest &request)const;
void describeConfigHistoryAsync(const Model::DescribeConfigHistoryRequest& request, const DescribeConfigHistoryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeConfigHistoryOutcomeCallable describeConfigHistoryCallable(const Model::DescribeConfigHistoryRequest& request) const;
DescribeConfigVersionDifferenceOutcome describeConfigVersionDifference(const Model::DescribeConfigVersionDifferenceRequest &request)const;
void describeConfigVersionDifferenceAsync(const Model::DescribeConfigVersionDifferenceRequest& request, const DescribeConfigVersionDifferenceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeConfigVersionDifferenceOutcomeCallable describeConfigVersionDifferenceCallable(const Model::DescribeConfigVersionDifferenceRequest& request) const;
DescribeDBClusterAccessWhiteListOutcome describeDBClusterAccessWhiteList(const Model::DescribeDBClusterAccessWhiteListRequest &request)const;
void describeDBClusterAccessWhiteListAsync(const Model::DescribeDBClusterAccessWhiteListRequest& request, const DescribeDBClusterAccessWhiteListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeDBClusterAccessWhiteListOutcomeCallable describeDBClusterAccessWhiteListCallable(const Model::DescribeDBClusterAccessWhiteListRequest& request) const;
DescribeDBClusterAttributeOutcome describeDBClusterAttribute(const Model::DescribeDBClusterAttributeRequest &request)const;
void describeDBClusterAttributeAsync(const Model::DescribeDBClusterAttributeRequest& request, const DescribeDBClusterAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeDBClusterAttributeOutcomeCallable describeDBClusterAttributeCallable(const Model::DescribeDBClusterAttributeRequest& request) const;
DescribeDBClusterConfigOutcome describeDBClusterConfig(const Model::DescribeDBClusterConfigRequest &request)const;
void describeDBClusterConfigAsync(const Model::DescribeDBClusterConfigRequest& request, const DescribeDBClusterConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeDBClusterConfigOutcomeCallable describeDBClusterConfigCallable(const Model::DescribeDBClusterConfigRequest& request) const;
DescribeDBClusterConfigInXMLOutcome describeDBClusterConfigInXML(const Model::DescribeDBClusterConfigInXMLRequest &request)const;
void describeDBClusterConfigInXMLAsync(const Model::DescribeDBClusterConfigInXMLRequest& request, const DescribeDBClusterConfigInXMLAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeDBClusterConfigInXMLOutcomeCallable describeDBClusterConfigInXMLCallable(const Model::DescribeDBClusterConfigInXMLRequest& request) const;
DescribeDBClusterNetInfoItemsOutcome describeDBClusterNetInfoItems(const Model::DescribeDBClusterNetInfoItemsRequest &request)const;
void describeDBClusterNetInfoItemsAsync(const Model::DescribeDBClusterNetInfoItemsRequest& request, const DescribeDBClusterNetInfoItemsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeDBClusterNetInfoItemsOutcomeCallable describeDBClusterNetInfoItemsCallable(const Model::DescribeDBClusterNetInfoItemsRequest& request) const;
DescribeDBClusterPerformanceOutcome describeDBClusterPerformance(const Model::DescribeDBClusterPerformanceRequest &request)const;
void describeDBClusterPerformanceAsync(const Model::DescribeDBClusterPerformanceRequest& request, const DescribeDBClusterPerformanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeDBClusterPerformanceOutcomeCallable describeDBClusterPerformanceCallable(const Model::DescribeDBClusterPerformanceRequest& request) const;
DescribeDBClustersOutcome describeDBClusters(const Model::DescribeDBClustersRequest &request)const;
void describeDBClustersAsync(const Model::DescribeDBClustersRequest& request, const DescribeDBClustersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeDBClustersOutcomeCallable describeDBClustersCallable(const Model::DescribeDBClustersRequest& request) const;
DescribeDBConfigOutcome describeDBConfig(const Model::DescribeDBConfigRequest &request)const;
void describeDBConfigAsync(const Model::DescribeDBConfigRequest& request, const DescribeDBConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeDBConfigOutcomeCallable describeDBConfigCallable(const Model::DescribeDBConfigRequest& request) const;
DescribeOSSStorageOutcome describeOSSStorage(const Model::DescribeOSSStorageRequest &request)const;
void describeOSSStorageAsync(const Model::DescribeOSSStorageRequest& request, const DescribeOSSStorageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeOSSStorageOutcomeCallable describeOSSStorageCallable(const Model::DescribeOSSStorageRequest& request) const;
DescribeProcessListOutcome describeProcessList(const Model::DescribeProcessListRequest &request)const;
void describeProcessListAsync(const Model::DescribeProcessListRequest& request, const DescribeProcessListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeProcessListOutcomeCallable describeProcessListCallable(const Model::DescribeProcessListRequest& request) const;
DescribeRegionsOutcome describeRegions(const Model::DescribeRegionsRequest &request)const;
void describeRegionsAsync(const Model::DescribeRegionsRequest& request, const DescribeRegionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeRegionsOutcomeCallable describeRegionsCallable(const Model::DescribeRegionsRequest& request) const;
DescribeSchemasOutcome describeSchemas(const Model::DescribeSchemasRequest &request)const;
void describeSchemasAsync(const Model::DescribeSchemasRequest& request, const DescribeSchemasAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeSchemasOutcomeCallable describeSchemasCallable(const Model::DescribeSchemasRequest& request) const;
DescribeSlowLogRecordsOutcome describeSlowLogRecords(const Model::DescribeSlowLogRecordsRequest &request)const;
void describeSlowLogRecordsAsync(const Model::DescribeSlowLogRecordsRequest& request, const DescribeSlowLogRecordsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeSlowLogRecordsOutcomeCallable describeSlowLogRecordsCallable(const Model::DescribeSlowLogRecordsRequest& request) const;
DescribeSynDbTablesOutcome describeSynDbTables(const Model::DescribeSynDbTablesRequest &request)const;
void describeSynDbTablesAsync(const Model::DescribeSynDbTablesRequest& request, const DescribeSynDbTablesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeSynDbTablesOutcomeCallable describeSynDbTablesCallable(const Model::DescribeSynDbTablesRequest& request) const;
DescribeSynDbsOutcome describeSynDbs(const Model::DescribeSynDbsRequest &request)const;
void describeSynDbsAsync(const Model::DescribeSynDbsRequest& request, const DescribeSynDbsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeSynDbsOutcomeCallable describeSynDbsCallable(const Model::DescribeSynDbsRequest& request) const;
DescribeTablesOutcome describeTables(const Model::DescribeTablesRequest &request)const;
void describeTablesAsync(const Model::DescribeTablesRequest& request, const DescribeTablesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeTablesOutcomeCallable describeTablesCallable(const Model::DescribeTablesRequest& request) const;
DescribeTransferHistoryOutcome describeTransferHistory(const Model::DescribeTransferHistoryRequest &request)const;
void describeTransferHistoryAsync(const Model::DescribeTransferHistoryRequest& request, const DescribeTransferHistoryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeTransferHistoryOutcomeCallable describeTransferHistoryCallable(const Model::DescribeTransferHistoryRequest& request) const;
KillProcessOutcome killProcess(const Model::KillProcessRequest &request)const;
void killProcessAsync(const Model::KillProcessRequest& request, const KillProcessAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
KillProcessOutcomeCallable killProcessCallable(const Model::KillProcessRequest& request) const;
ModifyAccountAuthorityOutcome modifyAccountAuthority(const Model::ModifyAccountAuthorityRequest &request)const;
void modifyAccountAuthorityAsync(const Model::ModifyAccountAuthorityRequest& request, const ModifyAccountAuthorityAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyAccountAuthorityOutcomeCallable modifyAccountAuthorityCallable(const Model::ModifyAccountAuthorityRequest& request) const;
ModifyAccountDescriptionOutcome modifyAccountDescription(const Model::ModifyAccountDescriptionRequest &request)const;
void modifyAccountDescriptionAsync(const Model::ModifyAccountDescriptionRequest& request, const ModifyAccountDescriptionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyAccountDescriptionOutcomeCallable modifyAccountDescriptionCallable(const Model::ModifyAccountDescriptionRequest& request) const;
ModifyBackupPolicyOutcome modifyBackupPolicy(const Model::ModifyBackupPolicyRequest &request)const;
void modifyBackupPolicyAsync(const Model::ModifyBackupPolicyRequest& request, const ModifyBackupPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyBackupPolicyOutcomeCallable modifyBackupPolicyCallable(const Model::ModifyBackupPolicyRequest& request) const;
ModifyDBClusterOutcome modifyDBCluster(const Model::ModifyDBClusterRequest &request)const;
void modifyDBClusterAsync(const Model::ModifyDBClusterRequest& request, const ModifyDBClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyDBClusterOutcomeCallable modifyDBClusterCallable(const Model::ModifyDBClusterRequest& request) const;
ModifyDBClusterAccessWhiteListOutcome modifyDBClusterAccessWhiteList(const Model::ModifyDBClusterAccessWhiteListRequest &request)const;
void modifyDBClusterAccessWhiteListAsync(const Model::ModifyDBClusterAccessWhiteListRequest& request, const ModifyDBClusterAccessWhiteListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyDBClusterAccessWhiteListOutcomeCallable modifyDBClusterAccessWhiteListCallable(const Model::ModifyDBClusterAccessWhiteListRequest& request) const;
ModifyDBClusterConfigOutcome modifyDBClusterConfig(const Model::ModifyDBClusterConfigRequest &request)const;
void modifyDBClusterConfigAsync(const Model::ModifyDBClusterConfigRequest& request, const ModifyDBClusterConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyDBClusterConfigOutcomeCallable modifyDBClusterConfigCallable(const Model::ModifyDBClusterConfigRequest& request) const;
ModifyDBClusterConfigInXMLOutcome modifyDBClusterConfigInXML(const Model::ModifyDBClusterConfigInXMLRequest &request)const;
void modifyDBClusterConfigInXMLAsync(const Model::ModifyDBClusterConfigInXMLRequest& request, const ModifyDBClusterConfigInXMLAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyDBClusterConfigInXMLOutcomeCallable modifyDBClusterConfigInXMLCallable(const Model::ModifyDBClusterConfigInXMLRequest& request) const;
ModifyDBClusterDescriptionOutcome modifyDBClusterDescription(const Model::ModifyDBClusterDescriptionRequest &request)const;
void modifyDBClusterDescriptionAsync(const Model::ModifyDBClusterDescriptionRequest& request, const ModifyDBClusterDescriptionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyDBClusterDescriptionOutcomeCallable modifyDBClusterDescriptionCallable(const Model::ModifyDBClusterDescriptionRequest& request) const;
ModifyDBClusterMaintainTimeOutcome modifyDBClusterMaintainTime(const Model::ModifyDBClusterMaintainTimeRequest &request)const;
void modifyDBClusterMaintainTimeAsync(const Model::ModifyDBClusterMaintainTimeRequest& request, const ModifyDBClusterMaintainTimeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyDBClusterMaintainTimeOutcomeCallable modifyDBClusterMaintainTimeCallable(const Model::ModifyDBClusterMaintainTimeRequest& request) const;
ModifyDBConfigOutcome modifyDBConfig(const Model::ModifyDBConfigRequest &request)const;
void modifyDBConfigAsync(const Model::ModifyDBConfigRequest& request, const ModifyDBConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyDBConfigOutcomeCallable modifyDBConfigCallable(const Model::ModifyDBConfigRequest& request) const;
ModifyMinorVersionGreadeTypeOutcome modifyMinorVersionGreadeType(const Model::ModifyMinorVersionGreadeTypeRequest &request)const;
void modifyMinorVersionGreadeTypeAsync(const Model::ModifyMinorVersionGreadeTypeRequest& request, const ModifyMinorVersionGreadeTypeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyMinorVersionGreadeTypeOutcomeCallable modifyMinorVersionGreadeTypeCallable(const Model::ModifyMinorVersionGreadeTypeRequest& request) const;
ModifyRDSToClickhouseDbOutcome modifyRDSToClickhouseDb(const Model::ModifyRDSToClickhouseDbRequest &request)const;
void modifyRDSToClickhouseDbAsync(const Model::ModifyRDSToClickhouseDbRequest& request, const ModifyRDSToClickhouseDbAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyRDSToClickhouseDbOutcomeCallable modifyRDSToClickhouseDbCallable(const Model::ModifyRDSToClickhouseDbRequest& request) const;
ReleaseClusterPublicConnectionOutcome releaseClusterPublicConnection(const Model::ReleaseClusterPublicConnectionRequest &request)const;
void releaseClusterPublicConnectionAsync(const Model::ReleaseClusterPublicConnectionRequest& request, const ReleaseClusterPublicConnectionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ReleaseClusterPublicConnectionOutcomeCallable releaseClusterPublicConnectionCallable(const Model::ReleaseClusterPublicConnectionRequest& request) const;
ResetAccountPasswordOutcome resetAccountPassword(const Model::ResetAccountPasswordRequest &request)const;
void resetAccountPasswordAsync(const Model::ResetAccountPasswordRequest& request, const ResetAccountPasswordAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ResetAccountPasswordOutcomeCallable resetAccountPasswordCallable(const Model::ResetAccountPasswordRequest& request) const;
RestartInstanceOutcome restartInstance(const Model::RestartInstanceRequest &request)const;
void restartInstanceAsync(const Model::RestartInstanceRequest& request, const RestartInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RestartInstanceOutcomeCallable restartInstanceCallable(const Model::RestartInstanceRequest& request) const;
TransferVersionOutcome transferVersion(const Model::TransferVersionRequest &request)const;
void transferVersionAsync(const Model::TransferVersionRequest& request, const TransferVersionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
TransferVersionOutcomeCallable transferVersionCallable(const Model::TransferVersionRequest& request) const;
UpgradeMinorVersionOutcome upgradeMinorVersion(const Model::UpgradeMinorVersionRequest &request)const;
void upgradeMinorVersionAsync(const Model::UpgradeMinorVersionRequest& request, const UpgradeMinorVersionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpgradeMinorVersionOutcomeCallable upgradeMinorVersionCallable(const Model::UpgradeMinorVersionRequest& request) const;
private:
std::shared_ptr<EndpointProvider> endpointProvider_;
};
}
}
#endif // !ALIBABACLOUD_CLICKHOUSE_CLICKHOUSECLIENT_H_

32
clickhouse/include/alibabacloud/clickhouse/ClickhouseExport.h Normal file
View File

@@ -0,0 +1,32 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_CLICKHOUSEEXPORT_H_
#define ALIBABACLOUD_CLICKHOUSE_CLICKHOUSEEXPORT_H_
#include <alibabacloud/core/Global.h>
#if defined(ALIBABACLOUD_SHARED)
# if defined(ALIBABACLOUD_CLICKHOUSE_LIBRARY)
# define ALIBABACLOUD_CLICKHOUSE_EXPORT ALIBABACLOUD_DECL_EXPORT
# else
# define ALIBABACLOUD_CLICKHOUSE_EXPORT ALIBABACLOUD_DECL_IMPORT
# endif
#else
# define ALIBABACLOUD_CLICKHOUSE_EXPORT
#endif
#endif // !ALIBABACLOUD_CLICKHOUSE_CLICKHOUSEEXPORT_H_

60
clickhouse/include/alibabacloud/clickhouse/model/AllocateClusterPublicConnectionRequest.h Normal file
View File

@@ -0,0 +1,60 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_ALLOCATECLUSTERPUBLICCONNECTIONREQUEST_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_ALLOCATECLUSTERPUBLICCONNECTIONREQUEST_H_
#include <alibabacloud/clickhouse/ClickhouseExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Clickhouse {
namespace Model {
class ALIBABACLOUD_CLICKHOUSE_EXPORT AllocateClusterPublicConnectionRequest : public RpcServiceRequest {
public:
AllocateClusterPublicConnectionRequest();
~AllocateClusterPublicConnectionRequest();
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
std::string getConnectionStringPrefix() const;
void setConnectionStringPrefix(const std::string &connectionStringPrefix);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getDBClusterId() const;
void setDBClusterId(const std::string &dBClusterId);
std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
long getOwnerId() const;
void setOwnerId(long ownerId);
private:
long resourceOwnerId_;
std::string connectionStringPrefix_;
std::string accessKeyId_;
std::string resourceOwnerAccount_;
std::string dBClusterId_;
std::string ownerAccount_;
long ownerId_;
};
} // namespace Model
} // namespace Clickhouse
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_ALLOCATECLUSTERPUBLICCONNECTIONREQUEST_H_

49
clickhouse/include/alibabacloud/clickhouse/model/AllocateClusterPublicConnectionResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_ALLOCATECLUSTERPUBLICCONNECTIONRESULT_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_ALLOCATECLUSTERPUBLICCONNECTIONRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/clickhouse/ClickhouseExport.h>
namespace AlibabaCloud
{
namespace Clickhouse
{
namespace Model
{
class ALIBABACLOUD_CLICKHOUSE_EXPORT AllocateClusterPublicConnectionResult : public ServiceResult
{
public:
AllocateClusterPublicConnectionResult();
explicit AllocateClusterPublicConnectionResult(const std::string &payload);
~AllocateClusterPublicConnectionResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_ALLOCATECLUSTERPUBLICCONNECTIONRESULT_H_

84
clickhouse/include/alibabacloud/clickhouse/model/CheckClickhouseToRDSRequest.h Normal file
View File

@@ -0,0 +1,84 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_CHECKCLICKHOUSETORDSREQUEST_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_CHECKCLICKHOUSETORDSREQUEST_H_
#include <alibabacloud/clickhouse/ClickhouseExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Clickhouse {
namespace Model {
class ALIBABACLOUD_CLICKHOUSE_EXPORT CheckClickhouseToRDSRequest : public RpcServiceRequest {
public:
CheckClickhouseToRDSRequest();
~CheckClickhouseToRDSRequest();
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
std::string getRdsVpcId() const;
void setRdsVpcId(const std::string &rdsVpcId);
std::string getCkPassword() const;
void setCkPassword(const std::string &ckPassword);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getRdsPassword() const;
void setRdsPassword(const std::string &rdsPassword);
std::string getCkUserName() const;
void setCkUserName(const std::string &ckUserName);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getDbClusterId() const;
void setDbClusterId(const std::string &dbClusterId);
std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
std::string getRdsId() const;
void setRdsId(const std::string &rdsId);
long getOwnerId() const;
void setOwnerId(long ownerId);
long getClickhousePort() const;
void setClickhousePort(long clickhousePort);
long getRdsPort() const;
void setRdsPort(long rdsPort);
std::string getRdsVpcUrl() const;
void setRdsVpcUrl(const std::string &rdsVpcUrl);
std::string getRdsUserName() const;
void setRdsUserName(const std::string &rdsUserName);
private:
long resourceOwnerId_;
std::string rdsVpcId_;
std::string ckPassword_;
std::string accessKeyId_;
std::string rdsPassword_;
std::string ckUserName_;
std::string resourceOwnerAccount_;
std::string dbClusterId_;
std::string ownerAccount_;
std::string rdsId_;
long ownerId_;
long clickhousePort_;
long rdsPort_;
std::string rdsVpcUrl_;
std::string rdsUserName_;
};
} // namespace Model
} // namespace Clickhouse
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_CHECKCLICKHOUSETORDSREQUEST_H_

53
clickhouse/include/alibabacloud/clickhouse/model/CheckClickhouseToRDSResult.h Normal file
View File

@@ -0,0 +1,53 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_CHECKCLICKHOUSETORDSRESULT_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_CHECKCLICKHOUSETORDSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/clickhouse/ClickhouseExport.h>
namespace AlibabaCloud
{
namespace Clickhouse
{
namespace Model
{
class ALIBABACLOUD_CLICKHOUSE_EXPORT CheckClickhouseToRDSResult : public ServiceResult
{
public:
CheckClickhouseToRDSResult();
explicit CheckClickhouseToRDSResult(const std::string &payload);
~CheckClickhouseToRDSResult();
bool getStatus()const;
std::string getErrorCode()const;
protected:
void parse(const std::string &payload);
private:
bool status_;
std::string errorCode_;
};
}
}
}
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_CHECKCLICKHOUSETORDSRESULT_H_

45
clickhouse/include/alibabacloud/clickhouse/model/CheckModifyConfigNeedRestartRequest.h Normal file
View File

@@ -0,0 +1,45 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_CHECKMODIFYCONFIGNEEDRESTARTREQUEST_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_CHECKMODIFYCONFIGNEEDRESTARTREQUEST_H_
#include <alibabacloud/clickhouse/ClickhouseExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Clickhouse {
namespace Model {
class ALIBABACLOUD_CLICKHOUSE_EXPORT CheckModifyConfigNeedRestartRequest : public RpcServiceRequest {
public:
CheckModifyConfigNeedRestartRequest();
~CheckModifyConfigNeedRestartRequest();
std::string getDBClusterId() const;
void setDBClusterId(const std::string &dBClusterId);
std::string getConfig() const;
void setConfig(const std::string &config);
private:
std::string dBClusterId_;
std::string config_;
};
} // namespace Model
} // namespace Clickhouse
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_CHECKMODIFYCONFIGNEEDRESTARTREQUEST_H_

51
clickhouse/include/alibabacloud/clickhouse/model/CheckModifyConfigNeedRestartResult.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_CHECKMODIFYCONFIGNEEDRESTARTRESULT_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_CHECKMODIFYCONFIGNEEDRESTARTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/clickhouse/ClickhouseExport.h>
namespace AlibabaCloud
{
namespace Clickhouse
{
namespace Model
{
class ALIBABACLOUD_CLICKHOUSE_EXPORT CheckModifyConfigNeedRestartResult : public ServiceResult
{
public:
CheckModifyConfigNeedRestartResult();
explicit CheckModifyConfigNeedRestartResult(const std::string &payload);
~CheckModifyConfigNeedRestartResult();
bool getNeedRestart()const;
protected:
void parse(const std::string &payload);
private:
bool needRestart_;
};
}
}
}
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_CHECKMODIFYCONFIGNEEDRESTARTRESULT_H_

60
clickhouse/include/alibabacloud/clickhouse/model/CheckMonitorAlertRequest.h Normal file
View File

@@ -0,0 +1,60 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_CHECKMONITORALERTREQUEST_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_CHECKMONITORALERTREQUEST_H_
#include <alibabacloud/clickhouse/ClickhouseExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Clickhouse {
namespace Model {
class ALIBABACLOUD_CLICKHOUSE_EXPORT CheckMonitorAlertRequest : public RpcServiceRequest {
public:
CheckMonitorAlertRequest();
~CheckMonitorAlertRequest();
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getDBClusterId() const;
void setDBClusterId(const std::string &dBClusterId);
std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
long getOwnerId() const;
void setOwnerId(long ownerId);
private:
long resourceOwnerId_;
std::string accessKeyId_;
std::string regionId_;
std::string resourceOwnerAccount_;
std::string dBClusterId_;
std::string ownerAccount_;
long ownerId_;
};
} // namespace Model
} // namespace Clickhouse
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_CHECKMONITORALERTREQUEST_H_

53
clickhouse/include/alibabacloud/clickhouse/model/CheckMonitorAlertResult.h Normal file
View File

@@ -0,0 +1,53 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_CHECKMONITORALERTRESULT_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_CHECKMONITORALERTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/clickhouse/ClickhouseExport.h>
namespace AlibabaCloud
{
namespace Clickhouse
{
namespace Model
{
class ALIBABACLOUD_CLICKHOUSE_EXPORT CheckMonitorAlertResult : public ServiceResult
{
public:
CheckMonitorAlertResult();
explicit CheckMonitorAlertResult(const std::string &payload);
~CheckMonitorAlertResult();
std::string getState()const;
std::string get_Parameter()const;
protected:
void parse(const std::string &payload);
private:
std::string state_;
std::string _parameter_;
};
}
}
}
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_CHECKMONITORALERTRESULT_H_

66
clickhouse/include/alibabacloud/clickhouse/model/CheckScaleOutBalancedRequest.h Normal file
View File

@@ -0,0 +1,66 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_CHECKSCALEOUTBALANCEDREQUEST_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_CHECKSCALEOUTBALANCEDREQUEST_H_
#include <alibabacloud/clickhouse/ClickhouseExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Clickhouse {
namespace Model {
class ALIBABACLOUD_CLICKHOUSE_EXPORT CheckScaleOutBalancedRequest : public RpcServiceRequest {
public:
CheckScaleOutBalancedRequest();
~CheckScaleOutBalancedRequest();
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
int getPageNumber() const;
void setPageNumber(int pageNumber);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
int getPageSize() const;
void setPageSize(int pageSize);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getDBClusterId() const;
void setDBClusterId(const std::string &dBClusterId);
std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
long getOwnerId() const;
void setOwnerId(long ownerId);
private:
long resourceOwnerId_;
int pageNumber_;
std::string accessKeyId_;
std::string regionId_;
int pageSize_;
std::string resourceOwnerAccount_;
std::string dBClusterId_;
std::string ownerAccount_;
long ownerId_;
};
} // namespace Model
} // namespace Clickhouse
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_CHECKSCALEOUTBALANCEDREQUEST_H_

68
clickhouse/include/alibabacloud/clickhouse/model/CheckScaleOutBalancedResult.h Normal file
View File

@@ -0,0 +1,68 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_CHECKSCALEOUTBALANCEDRESULT_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_CHECKSCALEOUTBALANCEDRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/clickhouse/ClickhouseExport.h>
namespace AlibabaCloud
{
namespace Clickhouse
{
namespace Model
{
class ALIBABACLOUD_CLICKHOUSE_EXPORT CheckScaleOutBalancedResult : public ServiceResult
{
public:
struct TableDetail
{
std::string tableName;
std::string database;
std::string cluster;
int detail;
};
CheckScaleOutBalancedResult();
explicit CheckScaleOutBalancedResult(const std::string &payload);
~CheckScaleOutBalancedResult();
std::vector<TableDetail> getTableDetails()const;
int getTotalCount()const;
int getPageSize()const;
int getPageNumber()const;
std::string getCheckCode()const;
std::string getTimeDuration()const;
protected:
void parse(const std::string &payload);
private:
std::vector<TableDetail> tableDetails_;
int totalCount_;
int pageSize_;
int pageNumber_;
std::string checkCode_;
std::string timeDuration_;
};
}
}
}
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_CHECKSCALEOUTBALANCEDRESULT_H_

54
clickhouse/include/alibabacloud/clickhouse/model/CheckServiceLinkedRoleRequest.h Normal file
View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_CHECKSERVICELINKEDROLEREQUEST_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_CHECKSERVICELINKEDROLEREQUEST_H_
#include <alibabacloud/clickhouse/ClickhouseExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Clickhouse {
namespace Model {
class ALIBABACLOUD_CLICKHOUSE_EXPORT CheckServiceLinkedRoleRequest : public RpcServiceRequest {
public:
CheckServiceLinkedRoleRequest();
~CheckServiceLinkedRoleRequest();
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
long getOwnerId() const;
void setOwnerId(long ownerId);
private:
long resourceOwnerId_;
std::string accessKeyId_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
};
} // namespace Model
} // namespace Clickhouse
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_CHECKSERVICELINKEDROLEREQUEST_H_

51
clickhouse/include/alibabacloud/clickhouse/model/CheckServiceLinkedRoleResult.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_CHECKSERVICELINKEDROLERESULT_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_CHECKSERVICELINKEDROLERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/clickhouse/ClickhouseExport.h>
namespace AlibabaCloud
{
namespace Clickhouse
{
namespace Model
{
class ALIBABACLOUD_CLICKHOUSE_EXPORT CheckServiceLinkedRoleResult : public ServiceResult
{
public:
CheckServiceLinkedRoleResult();
explicit CheckServiceLinkedRoleResult(const std::string &payload);
~CheckServiceLinkedRoleResult();
bool getHasServiceLinkedRole()const;
protected:
void parse(const std::string &payload);
private:
bool hasServiceLinkedRole_;
};
}
}
}
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_CHECKSERVICELINKEDROLERESULT_H_

87
clickhouse/include/alibabacloud/clickhouse/model/CreateAccountAndAuthorityRequest.h Normal file
View File

@@ -0,0 +1,87 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_CREATEACCOUNTANDAUTHORITYREQUEST_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_CREATEACCOUNTANDAUTHORITYREQUEST_H_
#include <alibabacloud/clickhouse/ClickhouseExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Clickhouse {
namespace Model {
class ALIBABACLOUD_CLICKHOUSE_EXPORT CreateAccountAndAuthorityRequest : public RpcServiceRequest {
public:
CreateAccountAndAuthorityRequest();
~CreateAccountAndAuthorityRequest();
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
std::string getTotalDictionaries() const;
void setTotalDictionaries(const std::string &totalDictionaries);
std::string getAccountDescription() const;
void setAccountDescription(const std::string &accountDescription);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getAccountName() const;
void setAccountName(const std::string &accountName);
std::string getDmlAuthority() const;
void setDmlAuthority(const std::string &dmlAuthority);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getDBClusterId() const;
void setDBClusterId(const std::string &dBClusterId);
std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
std::string getAllowDatabases() const;
void setAllowDatabases(const std::string &allowDatabases);
std::string getAllowDictionaries() const;
void setAllowDictionaries(const std::string &allowDictionaries);
long getOwnerId() const;
void setOwnerId(long ownerId);
std::string getAccountPassword() const;
void setAccountPassword(const std::string &accountPassword);
bool getDdlAuthority() const;
void setDdlAuthority(bool ddlAuthority);
std::string getTotalDatabases() const;
void setTotalDatabases(const std::string &totalDatabases);
private:
long resourceOwnerId_;
std::string totalDictionaries_;
std::string accountDescription_;
std::string accessKeyId_;
std::string accountName_;
std::string dmlAuthority_;
std::string regionId_;
std::string resourceOwnerAccount_;
std::string dBClusterId_;
std::string ownerAccount_;
std::string allowDatabases_;
std::string allowDictionaries_;
long ownerId_;
std::string accountPassword_;
bool ddlAuthority_;
std::string totalDatabases_;
};
} // namespace Model
} // namespace Clickhouse
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_CREATEACCOUNTANDAUTHORITYREQUEST_H_

49
clickhouse/include/alibabacloud/clickhouse/model/CreateAccountAndAuthorityResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_CREATEACCOUNTANDAUTHORITYRESULT_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_CREATEACCOUNTANDAUTHORITYRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/clickhouse/ClickhouseExport.h>
namespace AlibabaCloud
{
namespace Clickhouse
{
namespace Model
{
class ALIBABACLOUD_CLICKHOUSE_EXPORT CreateAccountAndAuthorityResult : public ServiceResult
{
public:
CreateAccountAndAuthorityResult();
explicit CreateAccountAndAuthorityResult(const std::string &payload);
~CreateAccountAndAuthorityResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_CREATEACCOUNTANDAUTHORITYRESULT_H_

66
clickhouse/include/alibabacloud/clickhouse/model/CreateAccountRequest.h Normal file
View File

@@ -0,0 +1,66 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_CREATEACCOUNTREQUEST_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_CREATEACCOUNTREQUEST_H_
#include <alibabacloud/clickhouse/ClickhouseExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Clickhouse {
namespace Model {
class ALIBABACLOUD_CLICKHOUSE_EXPORT CreateAccountRequest : public RpcServiceRequest {
public:
CreateAccountRequest();
~CreateAccountRequest();
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
std::string getAccountDescription() const;
void setAccountDescription(const std::string &accountDescription);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getAccountName() const;
void setAccountName(const std::string &accountName);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getDBClusterId() const;
void setDBClusterId(const std::string &dBClusterId);
std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
long getOwnerId() const;
void setOwnerId(long ownerId);
std::string getAccountPassword() const;
void setAccountPassword(const std::string &accountPassword);
private:
long resourceOwnerId_;
std::string accountDescription_;
std::string accessKeyId_;
std::string accountName_;
std::string resourceOwnerAccount_;
std::string dBClusterId_;
std::string ownerAccount_;
long ownerId_;
std::string accountPassword_;
};
} // namespace Model
} // namespace Clickhouse
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_CREATEACCOUNTREQUEST_H_

49
clickhouse/include/alibabacloud/clickhouse/model/CreateAccountResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_CREATEACCOUNTRESULT_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_CREATEACCOUNTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/clickhouse/ClickhouseExport.h>
namespace AlibabaCloud
{
namespace Clickhouse
{
namespace Model
{
class ALIBABACLOUD_CLICKHOUSE_EXPORT CreateAccountResult : public ServiceResult
{
public:
CreateAccountResult();
explicit CreateAccountResult(const std::string &payload);
~CreateAccountResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_CREATEACCOUNTRESULT_H_

69
clickhouse/include/alibabacloud/clickhouse/model/CreateBackupPolicyRequest.h Normal file
View File

@@ -0,0 +1,69 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_CREATEBACKUPPOLICYREQUEST_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_CREATEBACKUPPOLICYREQUEST_H_
#include <alibabacloud/clickhouse/ClickhouseExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Clickhouse {
namespace Model {
class ALIBABACLOUD_CLICKHOUSE_EXPORT CreateBackupPolicyRequest : public RpcServiceRequest {
public:
CreateBackupPolicyRequest();
~CreateBackupPolicyRequest();
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getPreferredBackupPeriod() const;
void setPreferredBackupPeriod(const std::string &preferredBackupPeriod);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getDBClusterId() const;
void setDBClusterId(const std::string &dBClusterId);
std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
long getOwnerId() const;
void setOwnerId(long ownerId);
std::string getPreferredBackupTime() const;
void setPreferredBackupTime(const std::string &preferredBackupTime);
std::string getBackupRetentionPeriod() const;
void setBackupRetentionPeriod(const std::string &backupRetentionPeriod);
private:
long resourceOwnerId_;
std::string accessKeyId_;
std::string regionId_;
std::string preferredBackupPeriod_;
std::string resourceOwnerAccount_;
std::string dBClusterId_;
std::string ownerAccount_;
long ownerId_;
std::string preferredBackupTime_;
std::string backupRetentionPeriod_;
};
} // namespace Model
} // namespace Clickhouse
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_CREATEBACKUPPOLICYREQUEST_H_

49
clickhouse/include/alibabacloud/clickhouse/model/CreateBackupPolicyResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_CREATEBACKUPPOLICYRESULT_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_CREATEBACKUPPOLICYRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/clickhouse/ClickhouseExport.h>
namespace AlibabaCloud
{
namespace Clickhouse
{
namespace Model
{
class ALIBABACLOUD_CLICKHOUSE_EXPORT CreateBackupPolicyResult : public ServiceResult
{
public:
CreateBackupPolicyResult();
explicit CreateBackupPolicyResult(const std::string &payload);
~CreateBackupPolicyResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_CREATEBACKUPPOLICYRESULT_H_

132
clickhouse/include/alibabacloud/clickhouse/model/CreateDBInstanceRequest.h Normal file
View File

@@ -0,0 +1,132 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_CREATEDBINSTANCEREQUEST_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_CREATEDBINSTANCEREQUEST_H_
#include <alibabacloud/clickhouse/ClickhouseExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Clickhouse {
namespace Model {
class ALIBABACLOUD_CLICKHOUSE_EXPORT CreateDBInstanceRequest : public RpcServiceRequest {
public:
CreateDBInstanceRequest();
~CreateDBInstanceRequest();
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
std::string getDBClusterDescription() const;
void setDBClusterDescription(const std::string &dBClusterDescription);
std::string getSourceDBClusterId() const;
void setSourceDBClusterId(const std::string &sourceDBClusterId);
std::string getResourceGroupId() const;
void setResourceGroupId(const std::string &resourceGroupId);
std::string getZondIdBak2() const;
void setZondIdBak2(const std::string &zondIdBak2);
std::string getDbNodeStorageType() const;
void setDbNodeStorageType(const std::string &dbNodeStorageType);
std::string getEncryptionType() const;
void setEncryptionType(const std::string &encryptionType);
std::string getZoneIdBak() const;
void setZoneIdBak(const std::string &zoneIdBak);
std::string getPeriod() const;
void setPeriod(const std::string &period);
std::string getBackupSetID() const;
void setBackupSetID(const std::string &backupSetID);
std::string getEncryptionKey() const;
void setEncryptionKey(const std::string &encryptionKey);
long getOwnerId() const;
void setOwnerId(long ownerId);
std::string getDBNodeGroupCount() const;
void setDBNodeGroupCount(const std::string &dBNodeGroupCount);
std::string getVSwitchId() const;
void setVSwitchId(const std::string &vSwitchId);
bool getAutoRenew() const;
void setAutoRenew(bool autoRenew);
std::string getZoneId() const;
void setZoneId(const std::string &zoneId);
std::string getClientToken() const;
void setClientToken(const std::string &clientToken);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getDBClusterCategory() const;
void setDBClusterCategory(const std::string &dBClusterCategory);
std::string getDBClusterNetworkType() const;
void setDBClusterNetworkType(const std::string &dBClusterNetworkType);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
std::string getDBClusterVersion() const;
void setDBClusterVersion(const std::string &dBClusterVersion);
std::string getDBClusterClass() const;
void setDBClusterClass(const std::string &dBClusterClass);
std::string getVSwitchBak() const;
void setVSwitchBak(const std::string &vSwitchBak);
std::string getUsedTime() const;
void setUsedTime(const std::string &usedTime);
std::string getVSwitchBak2() const;
void setVSwitchBak2(const std::string &vSwitchBak2);
std::string getDBNodeStorage() const;
void setDBNodeStorage(const std::string &dBNodeStorage);
std::string getVPCId() const;
void setVPCId(const std::string &vPCId);
std::string getPayType() const;
void setPayType(const std::string &payType);
private:
long resourceOwnerId_;
std::string dBClusterDescription_;
std::string sourceDBClusterId_;
std::string resourceGroupId_;
std::string zondIdBak2_;
std::string dbNodeStorageType_;
std::string encryptionType_;
std::string zoneIdBak_;
std::string period_;
std::string backupSetID_;
std::string encryptionKey_;
long ownerId_;
std::string dBNodeGroupCount_;
std::string vSwitchId_;
bool autoRenew_;
std::string zoneId_;
std::string clientToken_;
std::string accessKeyId_;
std::string regionId_;
std::string dBClusterCategory_;
std::string dBClusterNetworkType_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
std::string dBClusterVersion_;
std::string dBClusterClass_;
std::string vSwitchBak_;
std::string usedTime_;
std::string vSwitchBak2_;
std::string dBNodeStorage_;
std::string vPCId_;
std::string payType_;
};
} // namespace Model
} // namespace Clickhouse
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_CREATEDBINSTANCEREQUEST_H_

53
clickhouse/include/alibabacloud/clickhouse/model/CreateDBInstanceResult.h Normal file
View File

@@ -0,0 +1,53 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_CREATEDBINSTANCERESULT_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_CREATEDBINSTANCERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/clickhouse/ClickhouseExport.h>
namespace AlibabaCloud
{
namespace Clickhouse
{
namespace Model
{
class ALIBABACLOUD_CLICKHOUSE_EXPORT CreateDBInstanceResult : public ServiceResult
{
public:
CreateDBInstanceResult();
explicit CreateDBInstanceResult(const std::string &payload);
~CreateDBInstanceResult();
std::string getDBClusterId()const;
std::string getOrderId()const;
protected:
void parse(const std::string &payload);
private:
std::string dBClusterId_;
std::string orderId_;
};
}
}
}
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_CREATEDBINSTANCERESULT_H_

60
clickhouse/include/alibabacloud/clickhouse/model/CreateMonitorDataReportRequest.h Normal file
View File

@@ -0,0 +1,60 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_CREATEMONITORDATAREPORTREQUEST_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_CREATEMONITORDATAREPORTREQUEST_H_
#include <alibabacloud/clickhouse/ClickhouseExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Clickhouse {
namespace Model {
class ALIBABACLOUD_CLICKHOUSE_EXPORT CreateMonitorDataReportRequest : public RpcServiceRequest {
public:
CreateMonitorDataReportRequest();
~CreateMonitorDataReportRequest();
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getDBClusterId() const;
void setDBClusterId(const std::string &dBClusterId);
std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
long getOwnerId() const;
void setOwnerId(long ownerId);
private:
long resourceOwnerId_;
std::string accessKeyId_;
std::string regionId_;
std::string resourceOwnerAccount_;
std::string dBClusterId_;
std::string ownerAccount_;
long ownerId_;
};
} // namespace Model
} // namespace Clickhouse
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_CREATEMONITORDATAREPORTREQUEST_H_

49
clickhouse/include/alibabacloud/clickhouse/model/CreateMonitorDataReportResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_CREATEMONITORDATAREPORTRESULT_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_CREATEMONITORDATAREPORTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/clickhouse/ClickhouseExport.h>
namespace AlibabaCloud
{
namespace Clickhouse
{
namespace Model
{
class ALIBABACLOUD_CLICKHOUSE_EXPORT CreateMonitorDataReportResult : public ServiceResult
{
public:
CreateMonitorDataReportResult();
explicit CreateMonitorDataReportResult(const std::string &payload);
~CreateMonitorDataReportResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_CREATEMONITORDATAREPORTRESULT_H_

60
clickhouse/include/alibabacloud/clickhouse/model/CreateOSSStorageRequest.h Normal file
View File

@@ -0,0 +1,60 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_CREATEOSSSTORAGEREQUEST_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_CREATEOSSSTORAGEREQUEST_H_
#include <alibabacloud/clickhouse/ClickhouseExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Clickhouse {
namespace Model {
class ALIBABACLOUD_CLICKHOUSE_EXPORT CreateOSSStorageRequest : public RpcServiceRequest {
public:
CreateOSSStorageRequest();
~CreateOSSStorageRequest();
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getDBClusterId() const;
void setDBClusterId(const std::string &dBClusterId);
std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
long getOwnerId() const;
void setOwnerId(long ownerId);
private:
long resourceOwnerId_;
std::string accessKeyId_;
std::string regionId_;
std::string resourceOwnerAccount_;
std::string dBClusterId_;
std::string ownerAccount_;
long ownerId_;
};
} // namespace Model
} // namespace Clickhouse
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_CREATEOSSSTORAGEREQUEST_H_

49
clickhouse/include/alibabacloud/clickhouse/model/CreateOSSStorageResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_CREATEOSSSTORAGERESULT_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_CREATEOSSSTORAGERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/clickhouse/ClickhouseExport.h>
namespace AlibabaCloud
{
namespace Clickhouse
{
namespace Model
{
class ALIBABACLOUD_CLICKHOUSE_EXPORT CreateOSSStorageResult : public ServiceResult
{
public:
CreateOSSStorageResult();
explicit CreateOSSStorageResult(const std::string &payload);
~CreateOSSStorageResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_CREATEOSSSTORAGERESULT_H_

63
clickhouse/include/alibabacloud/clickhouse/model/CreatePortsForClickHouseRequest.h Normal file
View File

@@ -0,0 +1,63 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_CREATEPORTSFORCLICKHOUSEREQUEST_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_CREATEPORTSFORCLICKHOUSEREQUEST_H_
#include <alibabacloud/clickhouse/ClickhouseExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Clickhouse {
namespace Model {
class ALIBABACLOUD_CLICKHOUSE_EXPORT CreatePortsForClickHouseRequest : public RpcServiceRequest {
public:
CreatePortsForClickHouseRequest();
~CreatePortsForClickHouseRequest();
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
std::string getPortType() const;
void setPortType(const std::string &portType);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getDBClusterId() const;
void setDBClusterId(const std::string &dBClusterId);
std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
long getOwnerId() const;
void setOwnerId(long ownerId);
private:
long resourceOwnerId_;
std::string portType_;
std::string accessKeyId_;
std::string regionId_;
std::string resourceOwnerAccount_;
std::string dBClusterId_;
std::string ownerAccount_;
long ownerId_;
};
} // namespace Model
} // namespace Clickhouse
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_CREATEPORTSFORCLICKHOUSEREQUEST_H_

49
clickhouse/include/alibabacloud/clickhouse/model/CreatePortsForClickHouseResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_CREATEPORTSFORCLICKHOUSERESULT_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_CREATEPORTSFORCLICKHOUSERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/clickhouse/ClickhouseExport.h>
namespace AlibabaCloud
{
namespace Clickhouse
{
namespace Model
{
class ALIBABACLOUD_CLICKHOUSE_EXPORT CreatePortsForClickHouseResult : public ServiceResult
{
public:
CreatePortsForClickHouseResult();
explicit CreatePortsForClickHouseResult(const std::string &payload);
~CreatePortsForClickHouseResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_CREATEPORTSFORCLICKHOUSERESULT_H_

93
clickhouse/include/alibabacloud/clickhouse/model/CreateRDSToClickhouseDbRequest.h Normal file
View File

@@ -0,0 +1,93 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_CREATERDSTOCLICKHOUSEDBREQUEST_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_CREATERDSTOCLICKHOUSEDBREQUEST_H_
#include <alibabacloud/clickhouse/ClickhouseExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Clickhouse {
namespace Model {
class ALIBABACLOUD_CLICKHOUSE_EXPORT CreateRDSToClickhouseDbRequest : public RpcServiceRequest {
public:
CreateRDSToClickhouseDbRequest();
~CreateRDSToClickhouseDbRequest();
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
std::string getSynDbTables() const;
void setSynDbTables(const std::string &synDbTables);
std::string getRdsVpcId() const;
void setRdsVpcId(const std::string &rdsVpcId);
std::string getCkPassword() const;
void setCkPassword(const std::string &ckPassword);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getRdsPassword() const;
void setRdsPassword(const std::string &rdsPassword);
std::string getCkUserName() const;
void setCkUserName(const std::string &ckUserName);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getDbClusterId() const;
void setDbClusterId(const std::string &dbClusterId);
std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
std::string getRdsId() const;
void setRdsId(const std::string &rdsId);
long getOwnerId() const;
void setOwnerId(long ownerId);
long getClickhousePort() const;
void setClickhousePort(long clickhousePort);
long getLimitUpper() const;
void setLimitUpper(long limitUpper);
long getRdsPort() const;
void setRdsPort(long rdsPort);
bool getSkipUnsupported() const;
void setSkipUnsupported(bool skipUnsupported);
std::string getRdsVpcUrl() const;
void setRdsVpcUrl(const std::string &rdsVpcUrl);
std::string getRdsUserName() const;
void setRdsUserName(const std::string &rdsUserName);
private:
long resourceOwnerId_;
std::string synDbTables_;
std::string rdsVpcId_;
std::string ckPassword_;
std::string accessKeyId_;
std::string rdsPassword_;
std::string ckUserName_;
std::string resourceOwnerAccount_;
std::string dbClusterId_;
std::string ownerAccount_;
std::string rdsId_;
long ownerId_;
long clickhousePort_;
long limitUpper_;
long rdsPort_;
bool skipUnsupported_;
std::string rdsVpcUrl_;
std::string rdsUserName_;
};
} // namespace Model
} // namespace Clickhouse
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_CREATERDSTOCLICKHOUSEDBREQUEST_H_

55
clickhouse/include/alibabacloud/clickhouse/model/CreateRDSToClickhouseDbResult.h Normal file
View File

@@ -0,0 +1,55 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_CREATERDSTOCLICKHOUSEDBRESULT_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_CREATERDSTOCLICKHOUSEDBRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/clickhouse/ClickhouseExport.h>
namespace AlibabaCloud
{
namespace Clickhouse
{
namespace Model
{
class ALIBABACLOUD_CLICKHOUSE_EXPORT CreateRDSToClickhouseDbResult : public ServiceResult
{
public:
CreateRDSToClickhouseDbResult();
explicit CreateRDSToClickhouseDbResult(const std::string &payload);
~CreateRDSToClickhouseDbResult();
long getStatus()const;
std::vector<std::string> getRepeatedDbs()const;
std::string getErrorMsg()const;
protected:
void parse(const std::string &payload);
private:
long status_;
std::vector<std::string> repeatedDbs_;
std::string errorMsg_;
};
}
}
}
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_CREATERDSTOCLICKHOUSEDBRESULT_H_

69
clickhouse/include/alibabacloud/clickhouse/model/CreateSQLAccountRequest.h Normal file
View File

@@ -0,0 +1,69 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_CREATESQLACCOUNTREQUEST_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_CREATESQLACCOUNTREQUEST_H_
#include <alibabacloud/clickhouse/ClickhouseExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Clickhouse {
namespace Model {
class ALIBABACLOUD_CLICKHOUSE_EXPORT CreateSQLAccountRequest : public RpcServiceRequest {
public:
CreateSQLAccountRequest();
~CreateSQLAccountRequest();
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
std::string getAccountType() const;
void setAccountType(const std::string &accountType);
std::string getAccountDescription() const;
void setAccountDescription(const std::string &accountDescription);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getAccountName() const;
void setAccountName(const std::string &accountName);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getDBClusterId() const;
void setDBClusterId(const std::string &dBClusterId);
std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
long getOwnerId() const;
void setOwnerId(long ownerId);
std::string getAccountPassword() const;
void setAccountPassword(const std::string &accountPassword);
private:
long resourceOwnerId_;
std::string accountType_;
std::string accountDescription_;
std::string accessKeyId_;
std::string accountName_;
std::string resourceOwnerAccount_;
std::string dBClusterId_;
std::string ownerAccount_;
long ownerId_;
std::string accountPassword_;
};
} // namespace Model
} // namespace Clickhouse
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_CREATESQLACCOUNTREQUEST_H_

49
clickhouse/include/alibabacloud/clickhouse/model/CreateSQLAccountResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_CREATESQLACCOUNTRESULT_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_CREATESQLACCOUNTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/clickhouse/ClickhouseExport.h>
namespace AlibabaCloud
{
namespace Clickhouse
{
namespace Model
{
class ALIBABACLOUD_CLICKHOUSE_EXPORT CreateSQLAccountResult : public ServiceResult
{
public:
CreateSQLAccountResult();
explicit CreateSQLAccountResult(const std::string &payload);
~CreateSQLAccountResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_CREATESQLACCOUNTRESULT_H_

54
clickhouse/include/alibabacloud/clickhouse/model/CreateServiceLinkedRoleRequest.h Normal file
View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_CREATESERVICELINKEDROLEREQUEST_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_CREATESERVICELINKEDROLEREQUEST_H_
#include <alibabacloud/clickhouse/ClickhouseExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Clickhouse {
namespace Model {
class ALIBABACLOUD_CLICKHOUSE_EXPORT CreateServiceLinkedRoleRequest : public RpcServiceRequest {
public:
CreateServiceLinkedRoleRequest();
~CreateServiceLinkedRoleRequest();
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
long getOwnerId() const;
void setOwnerId(long ownerId);
private:
long resourceOwnerId_;
std::string accessKeyId_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
};
} // namespace Model
} // namespace Clickhouse
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_CREATESERVICELINKEDROLEREQUEST_H_

49
clickhouse/include/alibabacloud/clickhouse/model/CreateServiceLinkedRoleResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_CREATESERVICELINKEDROLERESULT_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_CREATESERVICELINKEDROLERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/clickhouse/ClickhouseExport.h>
namespace AlibabaCloud
{
namespace Clickhouse
{
namespace Model
{
class ALIBABACLOUD_CLICKHOUSE_EXPORT CreateServiceLinkedRoleResult : public ServiceResult
{
public:
CreateServiceLinkedRoleResult();
explicit CreateServiceLinkedRoleResult(const std::string &payload);
~CreateServiceLinkedRoleResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_CREATESERVICELINKEDROLERESULT_H_

60
clickhouse/include/alibabacloud/clickhouse/model/DeleteAccountRequest.h Normal file
View File

@@ -0,0 +1,60 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_DELETEACCOUNTREQUEST_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_DELETEACCOUNTREQUEST_H_
#include <alibabacloud/clickhouse/ClickhouseExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Clickhouse {
namespace Model {
class ALIBABACLOUD_CLICKHOUSE_EXPORT DeleteAccountRequest : public RpcServiceRequest {
public:
DeleteAccountRequest();
~DeleteAccountRequest();
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getAccountName() const;
void setAccountName(const std::string &accountName);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getDBClusterId() const;
void setDBClusterId(const std::string &dBClusterId);
std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
long getOwnerId() const;
void setOwnerId(long ownerId);
private:
long resourceOwnerId_;
std::string accessKeyId_;
std::string accountName_;
std::string resourceOwnerAccount_;
std::string dBClusterId_;
std::string ownerAccount_;
long ownerId_;
};
} // namespace Model
} // namespace Clickhouse
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DELETEACCOUNTREQUEST_H_

49
clickhouse/include/alibabacloud/clickhouse/model/DeleteAccountResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_DELETEACCOUNTRESULT_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_DELETEACCOUNTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/clickhouse/ClickhouseExport.h>
namespace AlibabaCloud
{
namespace Clickhouse
{
namespace Model
{
class ALIBABACLOUD_CLICKHOUSE_EXPORT DeleteAccountResult : public ServiceResult
{
public:
DeleteAccountResult();
explicit DeleteAccountResult(const std::string &payload);
~DeleteAccountResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DELETEACCOUNTRESULT_H_

57
clickhouse/include/alibabacloud/clickhouse/model/DeleteDBClusterRequest.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_DELETEDBCLUSTERREQUEST_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_DELETEDBCLUSTERREQUEST_H_
#include <alibabacloud/clickhouse/ClickhouseExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Clickhouse {
namespace Model {
class ALIBABACLOUD_CLICKHOUSE_EXPORT DeleteDBClusterRequest : public RpcServiceRequest {
public:
DeleteDBClusterRequest();
~DeleteDBClusterRequest();
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getDBClusterId() const;
void setDBClusterId(const std::string &dBClusterId);
std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
long getOwnerId() const;
void setOwnerId(long ownerId);
private:
long resourceOwnerId_;
std::string accessKeyId_;
std::string resourceOwnerAccount_;
std::string dBClusterId_;
std::string ownerAccount_;
long ownerId_;
};
} // namespace Model
} // namespace Clickhouse
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DELETEDBCLUSTERREQUEST_H_

49
clickhouse/include/alibabacloud/clickhouse/model/DeleteDBClusterResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_DELETEDBCLUSTERRESULT_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_DELETEDBCLUSTERRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/clickhouse/ClickhouseExport.h>
namespace AlibabaCloud
{
namespace Clickhouse
{
namespace Model
{
class ALIBABACLOUD_CLICKHOUSE_EXPORT DeleteDBClusterResult : public ServiceResult
{
public:
DeleteDBClusterResult();
explicit DeleteDBClusterResult(const std::string &payload);
~DeleteDBClusterResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DELETEDBCLUSTERRESULT_H_

60
clickhouse/include/alibabacloud/clickhouse/model/DeleteSyndbRequest.h Normal file
View File

@@ -0,0 +1,60 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_DELETESYNDBREQUEST_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_DELETESYNDBREQUEST_H_
#include <alibabacloud/clickhouse/ClickhouseExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Clickhouse {
namespace Model {
class ALIBABACLOUD_CLICKHOUSE_EXPORT DeleteSyndbRequest : public RpcServiceRequest {
public:
DeleteSyndbRequest();
~DeleteSyndbRequest();
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
std::string getSynDb() const;
void setSynDb(const std::string &synDb);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getDbClusterId() const;
void setDbClusterId(const std::string &dbClusterId);
std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
long getOwnerId() const;
void setOwnerId(long ownerId);
private:
long resourceOwnerId_;
std::string synDb_;
std::string accessKeyId_;
std::string resourceOwnerAccount_;
std::string dbClusterId_;
std::string ownerAccount_;
long ownerId_;
};
} // namespace Model
} // namespace Clickhouse
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DELETESYNDBREQUEST_H_

55
clickhouse/include/alibabacloud/clickhouse/model/DeleteSyndbResult.h Normal file
View File

@@ -0,0 +1,55 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_DELETESYNDBRESULT_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_DELETESYNDBRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/clickhouse/ClickhouseExport.h>
namespace AlibabaCloud
{
namespace Clickhouse
{
namespace Model
{
class ALIBABACLOUD_CLICKHOUSE_EXPORT DeleteSyndbResult : public ServiceResult
{
public:
DeleteSyndbResult();
explicit DeleteSyndbResult(const std::string &payload);
~DeleteSyndbResult();
bool getStatus()const;
std::string getErrorMsg()const;
long getErrorCode()const;
protected:
void parse(const std::string &payload);
private:
bool status_;
std::string errorMsg_;
long errorCode_;
};
}
}
}
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DELETESYNDBRESULT_H_

63
clickhouse/include/alibabacloud/clickhouse/model/DescribeAccountAuthorityRequest.h Normal file
View File

@@ -0,0 +1,63 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEACCOUNTAUTHORITYREQUEST_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEACCOUNTAUTHORITYREQUEST_H_
#include <alibabacloud/clickhouse/ClickhouseExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Clickhouse {
namespace Model {
class ALIBABACLOUD_CLICKHOUSE_EXPORT DescribeAccountAuthorityRequest : public RpcServiceRequest {
public:
DescribeAccountAuthorityRequest();
~DescribeAccountAuthorityRequest();
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getAccountName() const;
void setAccountName(const std::string &accountName);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getDBClusterId() const;
void setDBClusterId(const std::string &dBClusterId);
std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
long getOwnerId() const;
void setOwnerId(long ownerId);
private:
long resourceOwnerId_;
std::string accessKeyId_;
std::string accountName_;
std::string regionId_;
std::string resourceOwnerAccount_;
std::string dBClusterId_;
std::string ownerAccount_;
long ownerId_;
};
} // namespace Model
} // namespace Clickhouse
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEACCOUNTAUTHORITYREQUEST_H_

63
clickhouse/include/alibabacloud/clickhouse/model/DescribeAccountAuthorityResult.h Normal file
View File

@@ -0,0 +1,63 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEACCOUNTAUTHORITYRESULT_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEACCOUNTAUTHORITYRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/clickhouse/ClickhouseExport.h>
namespace AlibabaCloud
{
namespace Clickhouse
{
namespace Model
{
class ALIBABACLOUD_CLICKHOUSE_EXPORT DescribeAccountAuthorityResult : public ServiceResult
{
public:
DescribeAccountAuthorityResult();
explicit DescribeAccountAuthorityResult(const std::string &payload);
~DescribeAccountAuthorityResult();
bool getDdlAuthority()const;
std::string getDmlAuthority()const;
std::vector<std::string> getTotalDatabases()const;
std::vector<std::string> getTotalDictionaries()const;
std::vector<std::string> getAllowDictionaries()const;
std::vector<std::string> getAllowDatabases()const;
std::string getAccountName()const;
protected:
void parse(const std::string &payload);
private:
bool ddlAuthority_;
std::string dmlAuthority_;
std::vector<std::string> totalDatabases_;
std::vector<std::string> totalDictionaries_;
std::vector<std::string> allowDictionaries_;
std::vector<std::string> allowDatabases_;
std::string accountName_;
};
}
}
}
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEACCOUNTAUTHORITYRESULT_H_

66
clickhouse/include/alibabacloud/clickhouse/model/DescribeAccountsRequest.h Normal file
View File

@@ -0,0 +1,66 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEACCOUNTSREQUEST_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEACCOUNTSREQUEST_H_
#include <alibabacloud/clickhouse/ClickhouseExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Clickhouse {
namespace Model {
class ALIBABACLOUD_CLICKHOUSE_EXPORT DescribeAccountsRequest : public RpcServiceRequest {
public:
DescribeAccountsRequest();
~DescribeAccountsRequest();
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
int getPageNumber() const;
void setPageNumber(int pageNumber);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getAccountName() const;
void setAccountName(const std::string &accountName);
int getPageSize() const;
void setPageSize(int pageSize);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getDBClusterId() const;
void setDBClusterId(const std::string &dBClusterId);
std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
long getOwnerId() const;
void setOwnerId(long ownerId);
private:
long resourceOwnerId_;
int pageNumber_;
std::string accessKeyId_;
std::string accountName_;
int pageSize_;
std::string resourceOwnerAccount_;
std::string dBClusterId_;
std::string ownerAccount_;
long ownerId_;
};
} // namespace Model
} // namespace Clickhouse
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEACCOUNTSREQUEST_H_

65
clickhouse/include/alibabacloud/clickhouse/model/DescribeAccountsResult.h Normal file
View File

@@ -0,0 +1,65 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEACCOUNTSRESULT_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEACCOUNTSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/clickhouse/ClickhouseExport.h>
namespace AlibabaCloud
{
namespace Clickhouse
{
namespace Model
{
class ALIBABACLOUD_CLICKHOUSE_EXPORT DescribeAccountsResult : public ServiceResult
{
public:
struct Account
{
std::string accountDescription;
std::string accountStatus;
std::string accountType;
std::string configType;
std::string accountName;
};
DescribeAccountsResult();
explicit DescribeAccountsResult(const std::string &payload);
~DescribeAccountsResult();
int getTotalCount()const;
int getPageSize()const;
int getPageNumber()const;
std::vector<Account> getAccounts()const;
protected:
void parse(const std::string &payload);
private:
int totalCount_;
int pageSize_;
int pageNumber_;
std::vector<Account> accounts_;
};
}
}
}
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEACCOUNTSRESULT_H_

63
clickhouse/include/alibabacloud/clickhouse/model/DescribeAllDataSourceRequest.h Normal file
View File

@@ -0,0 +1,63 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEALLDATASOURCEREQUEST_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEALLDATASOURCEREQUEST_H_
#include <alibabacloud/clickhouse/ClickhouseExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Clickhouse {
namespace Model {
class ALIBABACLOUD_CLICKHOUSE_EXPORT DescribeAllDataSourceRequest : public RpcServiceRequest {
public:
DescribeAllDataSourceRequest();
~DescribeAllDataSourceRequest();
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getTableName() const;
void setTableName(const std::string &tableName);
std::string getSchemaName() const;
void setSchemaName(const std::string &schemaName);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getDBClusterId() const;
void setDBClusterId(const std::string &dBClusterId);
std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
long getOwnerId() const;
void setOwnerId(long ownerId);
private:
long resourceOwnerId_;
std::string accessKeyId_;
std::string tableName_;
std::string schemaName_;
std::string resourceOwnerAccount_;
std::string dBClusterId_;
std::string ownerAccount_;
long ownerId_;
};
} // namespace Model
} // namespace Clickhouse
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEALLDATASOURCEREQUEST_H_

76
clickhouse/include/alibabacloud/clickhouse/model/DescribeAllDataSourceResult.h Normal file
View File

@@ -0,0 +1,76 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEALLDATASOURCERESULT_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEALLDATASOURCERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/clickhouse/ClickhouseExport.h>
namespace AlibabaCloud
{
namespace Clickhouse
{
namespace Model
{
class ALIBABACLOUD_CLICKHOUSE_EXPORT DescribeAllDataSourceResult : public ServiceResult
{
public:
struct Table
{
std::string tableName;
std::string dBClusterId;
std::string schemaName;
};
struct Column
{
std::string columnName;
std::string tableName;
std::string type;
bool autoIncrementColumn;
std::string dBClusterId;
bool primaryKey;
std::string schemaName;
};
struct Schema
{
std::string dBClusterId;
std::string schemaName;
};
DescribeAllDataSourceResult();
explicit DescribeAllDataSourceResult(const std::string &payload);
~DescribeAllDataSourceResult();
std::vector<Table> getTables()const;
std::vector<Column> getColumns()const;
std::vector<Schema> getSchemas()const;
protected:
void parse(const std::string &payload);
private:
std::vector<Table> tables_;
std::vector<Column> columns_;
std::vector<Schema> schemas_;
};
}
}
}
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEALLDATASOURCERESULT_H_

63
clickhouse/include/alibabacloud/clickhouse/model/DescribeAllDataSourcesRequest.h Normal file
View File

@@ -0,0 +1,63 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEALLDATASOURCESREQUEST_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEALLDATASOURCESREQUEST_H_
#include <alibabacloud/clickhouse/ClickhouseExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Clickhouse {
namespace Model {
class ALIBABACLOUD_CLICKHOUSE_EXPORT DescribeAllDataSourcesRequest : public RpcServiceRequest {
public:
DescribeAllDataSourcesRequest();
~DescribeAllDataSourcesRequest();
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getTableName() const;
void setTableName(const std::string &tableName);
std::string getSchemaName() const;
void setSchemaName(const std::string &schemaName);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getDBClusterId() const;
void setDBClusterId(const std::string &dBClusterId);
std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
long getOwnerId() const;
void setOwnerId(long ownerId);
private:
long resourceOwnerId_;
std::string accessKeyId_;
std::string tableName_;
std::string schemaName_;
std::string resourceOwnerAccount_;
std::string dBClusterId_;
std::string ownerAccount_;
long ownerId_;
};
} // namespace Model
} // namespace Clickhouse
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEALLDATASOURCESREQUEST_H_

76
clickhouse/include/alibabacloud/clickhouse/model/DescribeAllDataSourcesResult.h Normal file
View File

@@ -0,0 +1,76 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEALLDATASOURCESRESULT_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEALLDATASOURCESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/clickhouse/ClickhouseExport.h>
namespace AlibabaCloud
{
namespace Clickhouse
{
namespace Model
{
class ALIBABACLOUD_CLICKHOUSE_EXPORT DescribeAllDataSourcesResult : public ServiceResult
{
public:
struct Table
{
std::string tableName;
std::string dBClusterId;
std::string schemaName;
};
struct Column
{
std::string columnName;
std::string tableName;
std::string type;
bool autoIncrementColumn;
std::string dBClusterId;
bool primaryKey;
std::string schemaName;
};
struct Schema
{
std::string dBClusterId;
std::string schemaName;
};
DescribeAllDataSourcesResult();
explicit DescribeAllDataSourcesResult(const std::string &payload);
~DescribeAllDataSourcesResult();
std::vector<Table> getTables()const;
std::vector<Column> getColumns()const;
std::vector<Schema> getSchemas()const;
protected:
void parse(const std::string &payload);
private:
std::vector<Table> tables_;
std::vector<Column> columns_;
std::vector<Schema> schemas_;
};
}
}
}
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEALLDATASOURCESRESULT_H_

57
clickhouse/include/alibabacloud/clickhouse/model/DescribeBackupPolicyRequest.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEBACKUPPOLICYREQUEST_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEBACKUPPOLICYREQUEST_H_
#include <alibabacloud/clickhouse/ClickhouseExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Clickhouse {
namespace Model {
class ALIBABACLOUD_CLICKHOUSE_EXPORT DescribeBackupPolicyRequest : public RpcServiceRequest {
public:
DescribeBackupPolicyRequest();
~DescribeBackupPolicyRequest();
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getDBClusterId() const;
void setDBClusterId(const std::string &dBClusterId);
std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
long getOwnerId() const;
void setOwnerId(long ownerId);
private:
long resourceOwnerId_;
std::string accessKeyId_;
std::string resourceOwnerAccount_;
std::string dBClusterId_;
std::string ownerAccount_;
long ownerId_;
};
} // namespace Model
} // namespace Clickhouse
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEBACKUPPOLICYREQUEST_H_

59
clickhouse/include/alibabacloud/clickhouse/model/DescribeBackupPolicyResult.h Normal file
View File

@@ -0,0 +1,59 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEBACKUPPOLICYRESULT_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEBACKUPPOLICYRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/clickhouse/ClickhouseExport.h>
namespace AlibabaCloud
{
namespace Clickhouse
{
namespace Model
{
class ALIBABACLOUD_CLICKHOUSE_EXPORT DescribeBackupPolicyResult : public ServiceResult
{
public:
DescribeBackupPolicyResult();
explicit DescribeBackupPolicyResult(const std::string &payload);
~DescribeBackupPolicyResult();
std::string getPreferredBackupPeriod()const;
std::string get_Switch()const;
std::string getPreferredBackupTime()const;
std::string getBackupSize()const;
int getBackupRetentionPeriod()const;
protected:
void parse(const std::string &payload);
private:
std::string preferredBackupPeriod_;
std::string _switch_;
std::string preferredBackupTime_;
std::string backupSize_;
int backupRetentionPeriod_;
};
}
}
}
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEBACKUPPOLICYRESULT_H_

72
clickhouse/include/alibabacloud/clickhouse/model/DescribeBackupsRequest.h Normal file
View File

@@ -0,0 +1,72 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEBACKUPSREQUEST_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEBACKUPSREQUEST_H_
#include <alibabacloud/clickhouse/ClickhouseExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Clickhouse {
namespace Model {
class ALIBABACLOUD_CLICKHOUSE_EXPORT DescribeBackupsRequest : public RpcServiceRequest {
public:
DescribeBackupsRequest();
~DescribeBackupsRequest();
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
std::string getStartTime() const;
void setStartTime(const std::string &startTime);
int getPageNumber() const;
void setPageNumber(int pageNumber);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
int getPageSize() const;
void setPageSize(int pageSize);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getDBClusterId() const;
void setDBClusterId(const std::string &dBClusterId);
std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
std::string getBackupId() const;
void setBackupId(const std::string &backupId);
std::string getEndTime() const;
void setEndTime(const std::string &endTime);
long getOwnerId() const;
void setOwnerId(long ownerId);
private:
long resourceOwnerId_;
std::string startTime_;
int pageNumber_;
std::string accessKeyId_;
int pageSize_;
std::string resourceOwnerAccount_;
std::string dBClusterId_;
std::string ownerAccount_;
std::string backupId_;
std::string endTime_;
long ownerId_;
};
} // namespace Model
} // namespace Clickhouse
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEBACKUPSREQUEST_H_

70
clickhouse/include/alibabacloud/clickhouse/model/DescribeBackupsResult.h Normal file
View File

@@ -0,0 +1,70 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEBACKUPSRESULT_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEBACKUPSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/clickhouse/ClickhouseExport.h>
namespace AlibabaCloud
{
namespace Clickhouse
{
namespace Model
{
class ALIBABACLOUD_CLICKHOUSE_EXPORT DescribeBackupsResult : public ServiceResult
{
public:
struct Backup
{
std::string backupMethod;
std::string expireDate;
long backupSize;
std::string backupEndTime;
std::string backupSetInfo;
std::string dBClusterId;
std::string backupStartTime;
std::string backupType;
std::string backupId;
std::string backupStatus;
};
DescribeBackupsResult();
explicit DescribeBackupsResult(const std::string &payload);
~DescribeBackupsResult();
std::string getTotalCount()const;
std::string getPageSize()const;
std::string getPageNumber()const;
std::vector<Backup> getItems()const;
protected:
void parse(const std::string &payload);
private:
std::string totalCount_;
std::string pageSize_;
std::string pageNumber_;
std::vector<Backup> items_;
};
}
}
}
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEBACKUPSRESULT_H_

63
clickhouse/include/alibabacloud/clickhouse/model/DescribeColumnsRequest.h Normal file
View File

@@ -0,0 +1,63 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBECOLUMNSREQUEST_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBECOLUMNSREQUEST_H_
#include <alibabacloud/clickhouse/ClickhouseExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Clickhouse {
namespace Model {
class ALIBABACLOUD_CLICKHOUSE_EXPORT DescribeColumnsRequest : public RpcServiceRequest {
public:
DescribeColumnsRequest();
~DescribeColumnsRequest();
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getTableName() const;
void setTableName(const std::string &tableName);
std::string getSchemaName() const;
void setSchemaName(const std::string &schemaName);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getDBClusterId() const;
void setDBClusterId(const std::string &dBClusterId);
std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
long getOwnerId() const;
void setOwnerId(long ownerId);
private:
long resourceOwnerId_;
std::string accessKeyId_;
std::string tableName_;
std::string schemaName_;
std::string resourceOwnerAccount_;
std::string dBClusterId_;
std::string ownerAccount_;
long ownerId_;
};
} // namespace Model
} // namespace Clickhouse
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBECOLUMNSREQUEST_H_

61
clickhouse/include/alibabacloud/clickhouse/model/DescribeColumnsResult.h Normal file
View File

@@ -0,0 +1,61 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBECOLUMNSRESULT_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBECOLUMNSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/clickhouse/ClickhouseExport.h>
namespace AlibabaCloud
{
namespace Clickhouse
{
namespace Model
{
class ALIBABACLOUD_CLICKHOUSE_EXPORT DescribeColumnsResult : public ServiceResult
{
public:
struct Column
{
std::string columnName;
std::string tableName;
std::string type;
bool autoIncrementColumn;
std::string dBClusterId;
bool primaryKey;
std::string schemaName;
};
DescribeColumnsResult();
explicit DescribeColumnsResult(const std::string &payload);
~DescribeColumnsResult();
std::vector<Column> getItems()const;
protected:
void parse(const std::string &payload);
private:
std::vector<Column> items_;
};
}
}
}
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBECOLUMNSRESULT_H_

48
clickhouse/include/alibabacloud/clickhouse/model/DescribeConfigHistoryRequest.h Normal file
View File

@@ -0,0 +1,48 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBECONFIGHISTORYREQUEST_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBECONFIGHISTORYREQUEST_H_
#include <alibabacloud/clickhouse/ClickhouseExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Clickhouse {
namespace Model {
class ALIBABACLOUD_CLICKHOUSE_EXPORT DescribeConfigHistoryRequest : public RpcServiceRequest {
public:
DescribeConfigHistoryRequest();
~DescribeConfigHistoryRequest();
std::string getStartTime() const;
void setStartTime(const std::string &startTime);
std::string getDBClusterId() const;
void setDBClusterId(const std::string &dBClusterId);
std::string getEndTime() const;
void setEndTime(const std::string &endTime);
private:
std::string startTime_;
std::string dBClusterId_;
std::string endTime_;
};
} // namespace Model
} // namespace Clickhouse
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBECONFIGHISTORYREQUEST_H_

59
clickhouse/include/alibabacloud/clickhouse/model/DescribeConfigHistoryResult.h Normal file
View File

@@ -0,0 +1,59 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBECONFIGHISTORYRESULT_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBECONFIGHISTORYRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/clickhouse/ClickhouseExport.h>
namespace AlibabaCloud
{
namespace Clickhouse
{
namespace Model
{
class ALIBABACLOUD_CLICKHOUSE_EXPORT DescribeConfigHistoryResult : public ServiceResult
{
public:
struct ConfigHistoryItem
{
std::string changeId;
std::string ownerId;
std::string time;
std::string reason;
bool success;
};
DescribeConfigHistoryResult();
explicit DescribeConfigHistoryResult(const std::string &payload);
~DescribeConfigHistoryResult();
std::vector<ConfigHistoryItem> getConfigHistoryItems()const;
protected:
void parse(const std::string &payload);
private:
std::vector<ConfigHistoryItem> configHistoryItems_;
};
}
}
}
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBECONFIGHISTORYRESULT_H_

45
clickhouse/include/alibabacloud/clickhouse/model/DescribeConfigVersionDifferenceRequest.h Normal file
View File

@@ -0,0 +1,45 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBECONFIGVERSIONDIFFERENCEREQUEST_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBECONFIGVERSIONDIFFERENCEREQUEST_H_
#include <alibabacloud/clickhouse/ClickhouseExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Clickhouse {
namespace Model {
class ALIBABACLOUD_CLICKHOUSE_EXPORT DescribeConfigVersionDifferenceRequest : public RpcServiceRequest {
public:
DescribeConfigVersionDifferenceRequest();
~DescribeConfigVersionDifferenceRequest();
std::string getDBClusterId() const;
void setDBClusterId(const std::string &dBClusterId);
std::string getChangeId() const;
void setChangeId(const std::string &changeId);
private:
std::string dBClusterId_;
std::string changeId_;
};
} // namespace Model
} // namespace Clickhouse
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBECONFIGVERSIONDIFFERENCEREQUEST_H_

53
clickhouse/include/alibabacloud/clickhouse/model/DescribeConfigVersionDifferenceResult.h Normal file
View File

@@ -0,0 +1,53 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBECONFIGVERSIONDIFFERENCERESULT_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBECONFIGVERSIONDIFFERENCERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/clickhouse/ClickhouseExport.h>
namespace AlibabaCloud
{
namespace Clickhouse
{
namespace Model
{
class ALIBABACLOUD_CLICKHOUSE_EXPORT DescribeConfigVersionDifferenceResult : public ServiceResult
{
public:
DescribeConfigVersionDifferenceResult();
explicit DescribeConfigVersionDifferenceResult(const std::string &payload);
~DescribeConfigVersionDifferenceResult();
std::string getOldConfigXML()const;
std::string getNewConfigXML()const;
protected:
void parse(const std::string &payload);
private:
std::string oldConfigXML_;
std::string newConfigXML_;
};
}
}
}
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBECONFIGVERSIONDIFFERENCERESULT_H_

57
clickhouse/include/alibabacloud/clickhouse/model/DescribeDBClusterAccessWhiteListRequest.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCLUSTERACCESSWHITELISTREQUEST_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCLUSTERACCESSWHITELISTREQUEST_H_
#include <alibabacloud/clickhouse/ClickhouseExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Clickhouse {
namespace Model {
class ALIBABACLOUD_CLICKHOUSE_EXPORT DescribeDBClusterAccessWhiteListRequest : public RpcServiceRequest {
public:
DescribeDBClusterAccessWhiteListRequest();
~DescribeDBClusterAccessWhiteListRequest();
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getDBClusterId() const;
void setDBClusterId(const std::string &dBClusterId);
std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
long getOwnerId() const;
void setOwnerId(long ownerId);
private:
long resourceOwnerId_;
std::string accessKeyId_;
std::string resourceOwnerAccount_;
std::string dBClusterId_;
std::string ownerAccount_;
long ownerId_;
};
} // namespace Model
} // namespace Clickhouse
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCLUSTERACCESSWHITELISTREQUEST_H_

57
clickhouse/include/alibabacloud/clickhouse/model/DescribeDBClusterAccessWhiteListResult.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCLUSTERACCESSWHITELISTRESULT_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCLUSTERACCESSWHITELISTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/clickhouse/ClickhouseExport.h>
namespace AlibabaCloud
{
namespace Clickhouse
{
namespace Model
{
class ALIBABACLOUD_CLICKHOUSE_EXPORT DescribeDBClusterAccessWhiteListResult : public ServiceResult
{
public:
struct IPArray
{
std::string securityIPList;
std::string dBClusterIPArrayName;
std::string dBClusterIPArrayAttribute;
};
DescribeDBClusterAccessWhiteListResult();
explicit DescribeDBClusterAccessWhiteListResult(const std::string &payload);
~DescribeDBClusterAccessWhiteListResult();
std::vector<IPArray> getDBClusterAccessWhiteList()const;
protected:
void parse(const std::string &payload);
private:
std::vector<IPArray> dBClusterAccessWhiteList_;
};
}
}
}
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCLUSTERACCESSWHITELISTRESULT_H_

57
clickhouse/include/alibabacloud/clickhouse/model/DescribeDBClusterAttributeRequest.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCLUSTERATTRIBUTEREQUEST_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCLUSTERATTRIBUTEREQUEST_H_
#include <alibabacloud/clickhouse/ClickhouseExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Clickhouse {
namespace Model {
class ALIBABACLOUD_CLICKHOUSE_EXPORT DescribeDBClusterAttributeRequest : public RpcServiceRequest {
public:
DescribeDBClusterAttributeRequest();
~DescribeDBClusterAttributeRequest();
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getDBClusterId() const;
void setDBClusterId(const std::string &dBClusterId);
std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
long getOwnerId() const;
void setOwnerId(long ownerId);
private:
long resourceOwnerId_;
std::string accessKeyId_;
std::string resourceOwnerAccount_;
std::string dBClusterId_;
std::string ownerAccount_;
long ownerId_;
};
} // namespace Model
} // namespace Clickhouse
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCLUSTERATTRIBUTEREQUEST_H_

120
clickhouse/include/alibabacloud/clickhouse/model/DescribeDBClusterAttributeResult.h Normal file
View File

@@ -0,0 +1,120 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCLUSTERATTRIBUTERESULT_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCLUSTERATTRIBUTERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/clickhouse/ClickhouseExport.h>
namespace AlibabaCloud
{
namespace Clickhouse
{
namespace Model
{
class ALIBABACLOUD_CLICKHOUSE_EXPORT DescribeDBClusterAttributeResult : public ServiceResult
{
public:
struct DBCluster
{
struct ScaleOutStatus
{
std::string progress;
std::string ratio;
};
struct Tag
{
std::string value;
std::string key;
};
std::string engineMinorVersion;
std::string resourceGroupId;
std::string controlVersion;
std::string vpcIpAddr;
int port;
std::string dBClusterType;
std::string zookeeperClass;
std::string appointmentRestartNodeList;
int supportBackup;
long dBNodeCount;
std::string publicConnectionString;
std::string lockReason;
int extStorageSize;
std::vector<Tag> tags;
std::string engine;
bool appointmentElectZookeeperDisableWrite;
long dBNodeStorage;
std::string encryptionType;
std::string isExpired;
std::string storageType;
std::string engineVersion;
std::string vSwitchId;
std::string dBClusterDescription;
std::string payType;
std::string lockMode;
ScaleOutStatus scaleOutStatus;
std::string vpcId;
std::string vpcCloudInstanceId;
std::string zoneIdVswitchMap;
bool supportMysqlPort;
std::string connectionString;
std::string expireTime;
std::string category;
std::string engineLatestMinorVersion;
bool maintainAutoType;
std::string dBClusterId;
std::string encryptionKey;
std::string dBClusterNetworkType;
std::string extStorageType;
std::string availableUpgradeMajorVersion;
std::string commodityCode;
int supportOss;
bool supportHttpsPort;
std::string bid;
std::string maintainTime;
std::string appointmentElectZookeeperTime;
std::string zoneId;
std::string publicIpAddr;
std::string dBClusterStatus;
std::string createTime;
std::string dBNodeClass;
std::string regionId;
std::string appointmentRestartNodeTime;
std::string publicPort;
std::string aliUid;
std::string appointmentRestartTime;
};
DescribeDBClusterAttributeResult();
explicit DescribeDBClusterAttributeResult(const std::string &payload);
~DescribeDBClusterAttributeResult();
DBCluster getDBCluster()const;
protected:
void parse(const std::string &payload);
private:
DBCluster dBCluster_;
};
}
}
}
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCLUSTERATTRIBUTERESULT_H_

45
clickhouse/include/alibabacloud/clickhouse/model/DescribeDBClusterConfigInXMLRequest.h Normal file
View File

@@ -0,0 +1,45 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCLUSTERCONFIGINXMLREQUEST_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCLUSTERCONFIGINXMLREQUEST_H_
#include <alibabacloud/clickhouse/ClickhouseExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Clickhouse {
namespace Model {
class ALIBABACLOUD_CLICKHOUSE_EXPORT DescribeDBClusterConfigInXMLRequest : public RpcServiceRequest {
public:
DescribeDBClusterConfigInXMLRequest();
~DescribeDBClusterConfigInXMLRequest();
std::string getDBClusterId() const;
void setDBClusterId(const std::string &dBClusterId);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
private:
std::string dBClusterId_;
std::string regionId_;
};
} // namespace Model
} // namespace Clickhouse
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCLUSTERCONFIGINXMLREQUEST_H_

51
clickhouse/include/alibabacloud/clickhouse/model/DescribeDBClusterConfigInXMLResult.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCLUSTERCONFIGINXMLRESULT_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCLUSTERCONFIGINXMLRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/clickhouse/ClickhouseExport.h>
namespace AlibabaCloud
{
namespace Clickhouse
{
namespace Model
{
class ALIBABACLOUD_CLICKHOUSE_EXPORT DescribeDBClusterConfigInXMLResult : public ServiceResult
{
public:
DescribeDBClusterConfigInXMLResult();
explicit DescribeDBClusterConfigInXMLResult(const std::string &payload);
~DescribeDBClusterConfigInXMLResult();
std::string getConfig()const;
protected:
void parse(const std::string &payload);
private:
std::string config_;
};
}
}
}
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCLUSTERCONFIGINXMLRESULT_H_

60
clickhouse/include/alibabacloud/clickhouse/model/DescribeDBClusterConfigRequest.h Normal file
View File

@@ -0,0 +1,60 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCLUSTERCONFIGREQUEST_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCLUSTERCONFIGREQUEST_H_
#include <alibabacloud/clickhouse/ClickhouseExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Clickhouse {
namespace Model {
class ALIBABACLOUD_CLICKHOUSE_EXPORT DescribeDBClusterConfigRequest : public RpcServiceRequest {
public:
DescribeDBClusterConfigRequest();
~DescribeDBClusterConfigRequest();
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getDBClusterId() const;
void setDBClusterId(const std::string &dBClusterId);
std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
long getOwnerId() const;
void setOwnerId(long ownerId);
private:
long resourceOwnerId_;
std::string accessKeyId_;
std::string regionId_;
std::string resourceOwnerAccount_;
std::string dBClusterId_;
std::string ownerAccount_;
long ownerId_;
};
} // namespace Model
} // namespace Clickhouse
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCLUSTERCONFIGREQUEST_H_

51
clickhouse/include/alibabacloud/clickhouse/model/DescribeDBClusterConfigResult.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCLUSTERCONFIGRESULT_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCLUSTERCONFIGRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/clickhouse/ClickhouseExport.h>
namespace AlibabaCloud
{
namespace Clickhouse
{
namespace Model
{
class ALIBABACLOUD_CLICKHOUSE_EXPORT DescribeDBClusterConfigResult : public ServiceResult
{
public:
DescribeDBClusterConfigResult();
explicit DescribeDBClusterConfigResult(const std::string &payload);
~DescribeDBClusterConfigResult();
std::string getConfig()const;
protected:
void parse(const std::string &payload);
private:
std::string config_;
};
}
}
}
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCLUSTERCONFIGRESULT_H_

57
clickhouse/include/alibabacloud/clickhouse/model/DescribeDBClusterNetInfoItemsRequest.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCLUSTERNETINFOITEMSREQUEST_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCLUSTERNETINFOITEMSREQUEST_H_
#include <alibabacloud/clickhouse/ClickhouseExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Clickhouse {
namespace Model {
class ALIBABACLOUD_CLICKHOUSE_EXPORT DescribeDBClusterNetInfoItemsRequest : public RpcServiceRequest {
public:
DescribeDBClusterNetInfoItemsRequest();
~DescribeDBClusterNetInfoItemsRequest();
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getDBClusterId() const;
void setDBClusterId(const std::string &dBClusterId);
std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
long getOwnerId() const;
void setOwnerId(long ownerId);
private:
long resourceOwnerId_;
std::string accessKeyId_;
std::string resourceOwnerAccount_;
std::string dBClusterId_;
std::string ownerAccount_;
long ownerId_;
};
} // namespace Model
} // namespace Clickhouse
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCLUSTERNETINFOITEMSREQUEST_H_

67
clickhouse/include/alibabacloud/clickhouse/model/DescribeDBClusterNetInfoItemsResult.h Normal file
View File

@@ -0,0 +1,67 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCLUSTERNETINFOITEMSRESULT_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCLUSTERNETINFOITEMSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/clickhouse/ClickhouseExport.h>
namespace AlibabaCloud
{
namespace Clickhouse
{
namespace Model
{
class ALIBABACLOUD_CLICKHOUSE_EXPORT DescribeDBClusterNetInfoItemsResult : public ServiceResult
{
public:
struct NetInfoItem
{
std::string httpPort;
std::string vpcId;
std::string mySQLPort;
std::string jdbcPort;
std::string vSwitchId;
std::string connectionString;
std::string iPAddress;
std::string netType;
std::string httpsPort;
};
DescribeDBClusterNetInfoItemsResult();
explicit DescribeDBClusterNetInfoItemsResult(const std::string &payload);
~DescribeDBClusterNetInfoItemsResult();
std::vector<NetInfoItem> getNetInfoItems()const;
std::string getClusterNetworkType()const;
bool getEnableSLB()const;
protected:
void parse(const std::string &payload);
private:
std::vector<NetInfoItem> netInfoItems_;
std::string clusterNetworkType_;
bool enableSLB_;
};
}
}
}
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCLUSTERNETINFOITEMSRESULT_H_

66
clickhouse/include/alibabacloud/clickhouse/model/DescribeDBClusterPerformanceRequest.h Normal file
View File

@@ -0,0 +1,66 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCLUSTERPERFORMANCEREQUEST_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCLUSTERPERFORMANCEREQUEST_H_
#include <alibabacloud/clickhouse/ClickhouseExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Clickhouse {
namespace Model {
class ALIBABACLOUD_CLICKHOUSE_EXPORT DescribeDBClusterPerformanceRequest : public RpcServiceRequest {
public:
DescribeDBClusterPerformanceRequest();
~DescribeDBClusterPerformanceRequest();
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
std::string getStartTime() const;
void setStartTime(const std::string &startTime);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getKey() const;
void setKey(const std::string &key);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getDBClusterId() const;
void setDBClusterId(const std::string &dBClusterId);
std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
std::string getEndTime() const;
void setEndTime(const std::string &endTime);
long getOwnerId() const;
void setOwnerId(long ownerId);
private:
long resourceOwnerId_;
std::string startTime_;
std::string accessKeyId_;
std::string key_;
std::string resourceOwnerAccount_;
std::string dBClusterId_;
std::string ownerAccount_;
std::string endTime_;
long ownerId_;
};
} // namespace Model
} // namespace Clickhouse
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCLUSTERPERFORMANCEREQUEST_H_

73
clickhouse/include/alibabacloud/clickhouse/model/DescribeDBClusterPerformanceResult.h Normal file
View File

@@ -0,0 +1,73 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCLUSTERPERFORMANCERESULT_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCLUSTERPERFORMANCERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/clickhouse/ClickhouseExport.h>
namespace AlibabaCloud
{
namespace Clickhouse
{
namespace Model
{
class ALIBABACLOUD_CLICKHOUSE_EXPORT DescribeDBClusterPerformanceResult : public ServiceResult
{
public:
struct PerformanceItem
{
struct SeriesItem
{
struct ValueItem
{
std::vector<std::string> point;
};
std::vector<SeriesItem::ValueItem> values;
std::string name;
};
std::vector<PerformanceItem::SeriesItem> series;
std::string unit;
std::string key;
std::string name;
};
DescribeDBClusterPerformanceResult();
explicit DescribeDBClusterPerformanceResult(const std::string &payload);
~DescribeDBClusterPerformanceResult();
std::string getEndTime()const;
std::string getStartTime()const;
std::string getDBClusterId()const;
std::vector<PerformanceItem> getPerformances()const;
protected:
void parse(const std::string &payload);
private:
std::string endTime_;
std::string startTime_;
std::string dBClusterId_;
std::vector<PerformanceItem> performances_;
};
}
}
}
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCLUSTERPERFORMANCERESULT_H_

85
clickhouse/include/alibabacloud/clickhouse/model/DescribeDBClustersRequest.h Normal file
View File

@@ -0,0 +1,85 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCLUSTERSREQUEST_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCLUSTERSREQUEST_H_
#include <alibabacloud/clickhouse/ClickhouseExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Clickhouse {
namespace Model {
class ALIBABACLOUD_CLICKHOUSE_EXPORT DescribeDBClustersRequest : public RpcServiceRequest {
public:
struct Tag {
std::string value;
std::string key;
};
DescribeDBClustersRequest();
~DescribeDBClustersRequest();
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
std::string getDBClusterDescription() const;
void setDBClusterDescription(const std::string &dBClusterDescription);
std::string getDBClusterStatus() const;
void setDBClusterStatus(const std::string &dBClusterStatus);
std::string getControlVersion() const;
void setControlVersion(const std::string &controlVersion);
int getPageNumber() const;
void setPageNumber(int pageNumber);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getResourceGroupId() const;
void setResourceGroupId(const std::string &resourceGroupId);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
int getPageSize() const;
void setPageSize(int pageSize);
std::vector<Tag> getTag() const;
void setTag(const std::vector<Tag> &tag);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
long getOwnerId() const;
void setOwnerId(long ownerId);
std::string getDBClusterIds() const;
void setDBClusterIds(const std::string &dBClusterIds);
private:
long resourceOwnerId_;
std::string dBClusterDescription_;
std::string dBClusterStatus_;
std::string controlVersion_;
int pageNumber_;
std::string accessKeyId_;
std::string resourceGroupId_;
std::string regionId_;
int pageSize_;
std::vector<Tag> tag_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
std::string dBClusterIds_;
};
} // namespace Model
} // namespace Clickhouse
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCLUSTERSREQUEST_H_

103
clickhouse/include/alibabacloud/clickhouse/model/DescribeDBClustersResult.h Normal file
View File

@@ -0,0 +1,103 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCLUSTERSRESULT_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCLUSTERSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/clickhouse/ClickhouseExport.h>
namespace AlibabaCloud
{
namespace Clickhouse
{
namespace Model
{
class ALIBABACLOUD_CLICKHOUSE_EXPORT DescribeDBClustersResult : public ServiceResult
{
public:
struct DBCluster
{
struct ScaleOutStatus
{
std::string progress;
std::string ratio;
};
struct Tag
{
std::string value;
std::string key;
};
std::string category;
std::string resourceGroupId;
std::string controlVersion;
int port;
std::string dBClusterId;
std::string dBClusterNetworkType;
std::string extStorageType;
std::string dbVersion;
long dBNodeCount;
std::string commodityCode;
std::string bid;
std::string lockReason;
int extStorageSize;
std::vector<DBCluster::Tag> tags;
long dBNodeStorage;
std::string isExpired;
std::string storageType;
std::string zoneId;
std::string dBClusterStatus;
std::string createTime;
std::string vSwitchId;
std::string scaleOutDisableWriteWindows;
std::string dBClusterDescription;
std::string payType;
std::string lockMode;
std::string dBNodeClass;
ScaleOutStatus scaleOutStatus;
std::string vpcId;
std::string vpcCloudInstanceId;
std::string regionId;
std::string connectionString;
std::string expireTime;
std::string aliUid;
};
DescribeDBClustersResult();
explicit DescribeDBClustersResult(const std::string &payload);
~DescribeDBClustersResult();
int getTotalCount()const;
int getPageSize()const;
int getPageNumber()const;
std::vector<DBCluster> getDBClusters()const;
protected:
void parse(const std::string &payload);
private:
int totalCount_;
int pageSize_;
int pageNumber_;
std::vector<DBCluster> dBClusters_;
};
}
}
}
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCLUSTERSRESULT_H_

60
clickhouse/include/alibabacloud/clickhouse/model/DescribeDBConfigRequest.h Normal file
View File

@@ -0,0 +1,60 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCONFIGREQUEST_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCONFIGREQUEST_H_
#include <alibabacloud/clickhouse/ClickhouseExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Clickhouse {
namespace Model {
class ALIBABACLOUD_CLICKHOUSE_EXPORT DescribeDBConfigRequest : public RpcServiceRequest {
public:
DescribeDBConfigRequest();
~DescribeDBConfigRequest();
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getDBClusterId() const;
void setDBClusterId(const std::string &dBClusterId);
std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
long getOwnerId() const;
void setOwnerId(long ownerId);
private:
long resourceOwnerId_;
std::string accessKeyId_;
std::string regionId_;
std::string resourceOwnerAccount_;
std::string dBClusterId_;
std::string ownerAccount_;
long ownerId_;
};
} // namespace Model
} // namespace Clickhouse
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCONFIGREQUEST_H_

51
clickhouse/include/alibabacloud/clickhouse/model/DescribeDBConfigResult.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCONFIGRESULT_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCONFIGRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/clickhouse/ClickhouseExport.h>
namespace AlibabaCloud
{
namespace Clickhouse
{
namespace Model
{
class ALIBABACLOUD_CLICKHOUSE_EXPORT DescribeDBConfigResult : public ServiceResult
{
public:
DescribeDBConfigResult();
explicit DescribeDBConfigResult(const std::string &payload);
~DescribeDBConfigResult();
std::string getConfig()const;
protected:
void parse(const std::string &payload);
private:
std::string config_;
};
}
}
}
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCONFIGRESULT_H_

60
clickhouse/include/alibabacloud/clickhouse/model/DescribeOSSStorageRequest.h Normal file
View File

@@ -0,0 +1,60 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEOSSSTORAGEREQUEST_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEOSSSTORAGEREQUEST_H_
#include <alibabacloud/clickhouse/ClickhouseExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Clickhouse {
namespace Model {
class ALIBABACLOUD_CLICKHOUSE_EXPORT DescribeOSSStorageRequest : public RpcServiceRequest {
public:
DescribeOSSStorageRequest();
~DescribeOSSStorageRequest();
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getDBClusterId() const;
void setDBClusterId(const std::string &dBClusterId);
std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
long getOwnerId() const;
void setOwnerId(long ownerId);
private:
long resourceOwnerId_;
std::string accessKeyId_;
std::string regionId_;
std::string resourceOwnerAccount_;
std::string dBClusterId_;
std::string ownerAccount_;
long ownerId_;
};
} // namespace Model
} // namespace Clickhouse
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEOSSSTORAGEREQUEST_H_

57
clickhouse/include/alibabacloud/clickhouse/model/DescribeOSSStorageResult.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEOSSSTORAGERESULT_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEOSSSTORAGERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/clickhouse/ClickhouseExport.h>
namespace AlibabaCloud
{
namespace Clickhouse
{
namespace Model
{
class ALIBABACLOUD_CLICKHOUSE_EXPORT DescribeOSSStorageResult : public ServiceResult
{
public:
DescribeOSSStorageResult();
explicit DescribeOSSStorageResult(const std::string &payload);
~DescribeOSSStorageResult();
std::string getPolicy()const;
std::string getState()const;
bool getColdStorage()const;
std::string getStorageUsage()const;
protected:
void parse(const std::string &payload);
private:
std::string policy_;
std::string state_;
bool coldStorage_;
std::string storageUsage_;
};
}
}
}
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEOSSSTORAGERESULT_H_

81
clickhouse/include/alibabacloud/clickhouse/model/DescribeProcessListRequest.h Normal file
View File

@@ -0,0 +1,81 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEPROCESSLISTREQUEST_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEPROCESSLISTREQUEST_H_
#include <alibabacloud/clickhouse/ClickhouseExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Clickhouse {
namespace Model {
class ALIBABACLOUD_CLICKHOUSE_EXPORT DescribeProcessListRequest : public RpcServiceRequest {
public:
DescribeProcessListRequest();
~DescribeProcessListRequest();
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
std::string getInitialQueryId() const;
void setInitialQueryId(const std::string &initialQueryId);
int getQueryDurationMs() const;
void setQueryDurationMs(int queryDurationMs);
int getPageNumber() const;
void setPageNumber(int pageNumber);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
int getPageSize() const;
void setPageSize(int pageSize);
std::string getInitialUser() const;
void setInitialUser(const std::string &initialUser);
std::string getKeyword() const;
void setKeyword(const std::string &keyword);
std::string getOrder() const;
void setOrder(const std::string &order);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getDBClusterId() const;
void setDBClusterId(const std::string &dBClusterId);
std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
long getOwnerId() const;
void setOwnerId(long ownerId);
private:
long resourceOwnerId_;
std::string initialQueryId_;
int queryDurationMs_;
int pageNumber_;
std::string accessKeyId_;
std::string regionId_;
int pageSize_;
std::string initialUser_;
std::string keyword_;
std::string order_;
std::string resourceOwnerAccount_;
std::string dBClusterId_;
std::string ownerAccount_;
long ownerId_;
};
} // namespace Model
} // namespace Clickhouse
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEPROCESSLISTREQUEST_H_

79
clickhouse/include/alibabacloud/clickhouse/model/DescribeProcessListResult.h Normal file
View File

@@ -0,0 +1,79 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEPROCESSLISTRESULT_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEPROCESSLISTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/clickhouse/ClickhouseExport.h>
namespace AlibabaCloud
{
namespace Clickhouse
{
namespace Model
{
class ALIBABACLOUD_CLICKHOUSE_EXPORT DescribeProcessListResult : public ServiceResult
{
public:
struct ProcessList
{
struct Statistics
{
float elapsedTime;
int bytesRead;
int rowsRead;
};
struct ResultSet
{
std::string type;
std::string name;
};
struct ResultSet1
{
std::string initialUser;
std::string query;
std::string initialAddress;
std::string initialQueryId;
std::string queryDurationMs;
std::string queryStartTime;
};
std::string rowsBeforeLimitAtLeast;
std::vector<ResultSet> tableSchema;
std::vector<ResultSet1> data;
Statistics statistics;
std::string rows;
};
DescribeProcessListResult();
explicit DescribeProcessListResult(const std::string &payload);
~DescribeProcessListResult();
ProcessList getProcessList()const;
protected:
void parse(const std::string &payload);
private:
ProcessList processList_;
};
}
}
}
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEPROCESSLISTRESULT_H_

54
clickhouse/include/alibabacloud/clickhouse/model/DescribeRegionsRequest.h Normal file
View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEREGIONSREQUEST_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEREGIONSREQUEST_H_
#include <alibabacloud/clickhouse/ClickhouseExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Clickhouse {
namespace Model {
class ALIBABACLOUD_CLICKHOUSE_EXPORT DescribeRegionsRequest : public RpcServiceRequest {
public:
DescribeRegionsRequest();
~DescribeRegionsRequest();
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
long getOwnerId() const;
void setOwnerId(long ownerId);
private:
long resourceOwnerId_;
std::string accessKeyId_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
};
} // namespace Model
} // namespace Clickhouse
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEREGIONSREQUEST_H_

61
clickhouse/include/alibabacloud/clickhouse/model/DescribeRegionsResult.h Normal file
View File

@@ -0,0 +1,61 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEREGIONSRESULT_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEREGIONSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/clickhouse/ClickhouseExport.h>
namespace AlibabaCloud
{
namespace Clickhouse
{
namespace Model
{
class ALIBABACLOUD_CLICKHOUSE_EXPORT DescribeRegionsResult : public ServiceResult
{
public:
struct Region
{
struct Zone
{
bool vpcEnabled;
std::string zoneId;
};
std::string regionId;
std::vector<Region::Zone> zones;
};
DescribeRegionsResult();
explicit DescribeRegionsResult(const std::string &payload);
~DescribeRegionsResult();
std::vector<Region> getRegions()const;
protected:
void parse(const std::string &payload);
private:
std::vector<Region> regions_;
};
}
}
}
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEREGIONSRESULT_H_

63
clickhouse/include/alibabacloud/clickhouse/model/DescribeSchemasRequest.h Normal file
View File

@@ -0,0 +1,63 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBESCHEMASREQUEST_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBESCHEMASREQUEST_H_
#include <alibabacloud/clickhouse/ClickhouseExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Clickhouse {
namespace Model {
class ALIBABACLOUD_CLICKHOUSE_EXPORT DescribeSchemasRequest : public RpcServiceRequest {
public:
DescribeSchemasRequest();
~DescribeSchemasRequest();
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getTableName() const;
void setTableName(const std::string &tableName);
std::string getSchemaName() const;
void setSchemaName(const std::string &schemaName);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getDBClusterId() const;
void setDBClusterId(const std::string &dBClusterId);
std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
long getOwnerId() const;
void setOwnerId(long ownerId);
private:
long resourceOwnerId_;
std::string accessKeyId_;
std::string tableName_;
std::string schemaName_;
std::string resourceOwnerAccount_;
std::string dBClusterId_;
std::string ownerAccount_;
long ownerId_;
};
} // namespace Model
} // namespace Clickhouse
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBESCHEMASREQUEST_H_

56
clickhouse/include/alibabacloud/clickhouse/model/DescribeSchemasResult.h Normal file
View File

@@ -0,0 +1,56 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBESCHEMASRESULT_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBESCHEMASRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/clickhouse/ClickhouseExport.h>
namespace AlibabaCloud
{
namespace Clickhouse
{
namespace Model
{
class ALIBABACLOUD_CLICKHOUSE_EXPORT DescribeSchemasResult : public ServiceResult
{
public:
struct Schema
{
std::string dBClusterId;
std::string schemaName;
};
DescribeSchemasResult();
explicit DescribeSchemasResult(const std::string &payload);
~DescribeSchemasResult();
std::vector<Schema> getItems()const;
protected:
void parse(const std::string &payload);
private:
std::vector<Schema> items_;
};
}
}
}
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBESCHEMASRESULT_H_

75
clickhouse/include/alibabacloud/clickhouse/model/DescribeSlowLogRecordsRequest.h Normal file
View File

@@ -0,0 +1,75 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBESLOWLOGRECORDSREQUEST_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBESLOWLOGRECORDSREQUEST_H_
#include <alibabacloud/clickhouse/ClickhouseExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Clickhouse {
namespace Model {
class ALIBABACLOUD_CLICKHOUSE_EXPORT DescribeSlowLogRecordsRequest : public RpcServiceRequest {
public:
DescribeSlowLogRecordsRequest();
~DescribeSlowLogRecordsRequest();
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
int getQueryDurationMs() const;
void setQueryDurationMs(int queryDurationMs);
std::string getStartTime() const;
void setStartTime(const std::string &startTime);
int getPageNumber() const;
void setPageNumber(int pageNumber);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
int getPageSize() const;
void setPageSize(int pageSize);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getDBClusterId() const;
void setDBClusterId(const std::string &dBClusterId);
std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
std::string getEndTime() const;
void setEndTime(const std::string &endTime);
long getOwnerId() const;
void setOwnerId(long ownerId);
private:
long resourceOwnerId_;
int queryDurationMs_;
std::string startTime_;
int pageNumber_;
std::string accessKeyId_;
std::string regionId_;
int pageSize_;
std::string resourceOwnerAccount_;
std::string dBClusterId_;
std::string ownerAccount_;
std::string endTime_;
long ownerId_;
};
} // namespace Model
} // namespace Clickhouse
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBESLOWLOGRECORDSREQUEST_H_

84
clickhouse/include/alibabacloud/clickhouse/model/DescribeSlowLogRecordsResult.h Normal file
View File

@@ -0,0 +1,84 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBESLOWLOGRECORDSRESULT_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBESLOWLOGRECORDSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/clickhouse/ClickhouseExport.h>
namespace AlibabaCloud
{
namespace Clickhouse
{
namespace Model
{
class ALIBABACLOUD_CLICKHOUSE_EXPORT DescribeSlowLogRecordsResult : public ServiceResult
{
public:
struct SlowLogRecords
{
struct Statistics
{
float elapsedTime;
int bytesRead;
int rowsRead;
};
struct ResultSet
{
std::string type;
std::string name;
};
struct ResultSet1
{
std::string initialUser;
std::string type;
std::string query;
std::string initialAddress;
std::string initialQueryId;
std::string queryDurationMs;
std::string readBytes;
std::string readRows;
std::string queryStartTime;
std::string memoryUsage;
std::string resultBytes;
};
std::string rowsBeforeLimitAtLeast;
std::vector<ResultSet> tableSchema;
std::vector<ResultSet1> data;
Statistics statistics;
std::string rows;
};
DescribeSlowLogRecordsResult();
explicit DescribeSlowLogRecordsResult(const std::string &payload);
~DescribeSlowLogRecordsResult();
SlowLogRecords getSlowLogRecords()const;
protected:
void parse(const std::string &payload);
private:
SlowLogRecords slowLogRecords_;
};
}
}
}
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBESLOWLOGRECORDSRESULT_H_

60
clickhouse/include/alibabacloud/clickhouse/model/DescribeSynDbTablesRequest.h Normal file
View File

@@ -0,0 +1,60 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBESYNDBTABLESREQUEST_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBESYNDBTABLESREQUEST_H_
#include <alibabacloud/clickhouse/ClickhouseExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Clickhouse {
namespace Model {
class ALIBABACLOUD_CLICKHOUSE_EXPORT DescribeSynDbTablesRequest : public RpcServiceRequest {
public:
DescribeSynDbTablesRequest();
~DescribeSynDbTablesRequest();
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
std::string getSynDb() const;
void setSynDb(const std::string &synDb);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getDbClusterId() const;
void setDbClusterId(const std::string &dbClusterId);
std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
long getOwnerId() const;
void setOwnerId(long ownerId);
private:
long resourceOwnerId_;
std::string synDb_;
std::string accessKeyId_;
std::string resourceOwnerAccount_;
std::string dbClusterId_;
std::string ownerAccount_;
long ownerId_;
};
} // namespace Model
} // namespace Clickhouse
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBESYNDBTABLESREQUEST_H_

51
clickhouse/include/alibabacloud/clickhouse/model/DescribeSynDbTablesResult.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBESYNDBTABLESRESULT_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBESYNDBTABLESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/clickhouse/ClickhouseExport.h>
namespace AlibabaCloud
{
namespace Clickhouse
{
namespace Model
{
class ALIBABACLOUD_CLICKHOUSE_EXPORT DescribeSynDbTablesResult : public ServiceResult
{
public:
DescribeSynDbTablesResult();
explicit DescribeSynDbTablesResult(const std::string &payload);
~DescribeSynDbTablesResult();
std::vector<std::string> getTables()const;
protected:
void parse(const std::string &payload);
private:
std::vector<std::string> tables_;
};
}
}
}
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBESYNDBTABLESRESULT_H_

63
clickhouse/include/alibabacloud/clickhouse/model/DescribeSynDbsRequest.h Normal file
View File

@@ -0,0 +1,63 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBESYNDBSREQUEST_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBESYNDBSREQUEST_H_
#include <alibabacloud/clickhouse/ClickhouseExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Clickhouse {
namespace Model {
class ALIBABACLOUD_CLICKHOUSE_EXPORT DescribeSynDbsRequest : public RpcServiceRequest {
public:
DescribeSynDbsRequest();
~DescribeSynDbsRequest();
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
int getPageNumber() const;
void setPageNumber(int pageNumber);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
int getPageSize() const;
void setPageSize(int pageSize);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getDbClusterId() const;
void setDbClusterId(const std::string &dbClusterId);
std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
long getOwnerId() const;
void setOwnerId(long ownerId);
private:
long resourceOwnerId_;
int pageNumber_;
std::string accessKeyId_;
int pageSize_;
std::string resourceOwnerAccount_;
std::string dbClusterId_;
std::string ownerAccount_;
long ownerId_;
};
} // namespace Model
} // namespace Clickhouse
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBESYNDBSREQUEST_H_

67
clickhouse/include/alibabacloud/clickhouse/model/DescribeSynDbsResult.h Normal file
View File

@@ -0,0 +1,67 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBESYNDBSRESULT_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBESYNDBSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/clickhouse/ClickhouseExport.h>
namespace AlibabaCloud
{
namespace Clickhouse
{
namespace Model
{
class ALIBABACLOUD_CLICKHOUSE_EXPORT DescribeSynDbsResult : public ServiceResult
{
public:
struct SynDb
{
std::string rdsVpcUrl;
std::string rdsUserName;
bool synStatus;
std::string errorMsg;
std::string synDb;
std::string rdsId;
std::string rdsPassword;
};
DescribeSynDbsResult();
explicit DescribeSynDbsResult(const std::string &payload);
~DescribeSynDbsResult();
int getTotalCount()const;
std::vector<SynDb> getSynDbs()const;
int getPageSize()const;
int getPageNumber()const;
protected:
void parse(const std::string &payload);
private:
int totalCount_;
std::vector<SynDb> synDbs_;
int pageSize_;
int pageNumber_;
};
}
}
}
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBESYNDBSRESULT_H_

63
clickhouse/include/alibabacloud/clickhouse/model/DescribeTablesRequest.h Normal file
View File

@@ -0,0 +1,63 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBETABLESREQUEST_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBETABLESREQUEST_H_
#include <alibabacloud/clickhouse/ClickhouseExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Clickhouse {
namespace Model {
class ALIBABACLOUD_CLICKHOUSE_EXPORT DescribeTablesRequest : public RpcServiceRequest {
public:
DescribeTablesRequest();
~DescribeTablesRequest();
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getTableName() const;
void setTableName(const std::string &tableName);
std::string getSchemaName() const;
void setSchemaName(const std::string &schemaName);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getDBClusterId() const;
void setDBClusterId(const std::string &dBClusterId);
std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
long getOwnerId() const;
void setOwnerId(long ownerId);
private:
long resourceOwnerId_;
std::string accessKeyId_;
std::string tableName_;
std::string schemaName_;
std::string resourceOwnerAccount_;
std::string dBClusterId_;
std::string ownerAccount_;
long ownerId_;
};
} // namespace Model
} // namespace Clickhouse
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBETABLESREQUEST_H_

57
clickhouse/include/alibabacloud/clickhouse/model/DescribeTablesResult.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBETABLESRESULT_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBETABLESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/clickhouse/ClickhouseExport.h>
namespace AlibabaCloud
{
namespace Clickhouse
{
namespace Model
{
class ALIBABACLOUD_CLICKHOUSE_EXPORT DescribeTablesResult : public ServiceResult
{
public:
struct Table
{
std::string tableName;
std::string dBClusterId;
std::string schemaName;
};
DescribeTablesResult();
explicit DescribeTablesResult(const std::string &payload);
~DescribeTablesResult();
std::vector<Table> getItems()const;
protected:
void parse(const std::string &payload);
private:
std::vector<Table> items_;
};
}
}
}
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBETABLESRESULT_H_

57
clickhouse/include/alibabacloud/clickhouse/model/DescribeTransferHistoryRequest.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBETRANSFERHISTORYREQUEST_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBETRANSFERHISTORYREQUEST_H_
#include <alibabacloud/clickhouse/ClickhouseExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Clickhouse {
namespace Model {
class ALIBABACLOUD_CLICKHOUSE_EXPORT DescribeTransferHistoryRequest : public RpcServiceRequest {
public:
DescribeTransferHistoryRequest();
~DescribeTransferHistoryRequest();
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getDBClusterId() const;
void setDBClusterId(const std::string &dBClusterId);
std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
long getOwnerId() const;
void setOwnerId(long ownerId);
private:
long resourceOwnerId_;
std::string accessKeyId_;
std::string resourceOwnerAccount_;
std::string dBClusterId_;
std::string ownerAccount_;
long ownerId_;
};
} // namespace Model
} // namespace Clickhouse
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBETRANSFERHISTORYREQUEST_H_

67
clickhouse/include/alibabacloud/clickhouse/model/DescribeTransferHistoryResult.h Normal file
View File

@@ -0,0 +1,67 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBETRANSFERHISTORYRESULT_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBETRANSFERHISTORYRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/clickhouse/ClickhouseExport.h>
namespace AlibabaCloud
{
namespace Clickhouse
{
namespace Model
{
class ALIBABACLOUD_CLICKHOUSE_EXPORT DescribeTransferHistoryResult : public ServiceResult
{
public:
struct HistoryDetail
{
std::string targetDBCluster;
std::string status;
long unsyncedBytes;
std::string progress;
std::string targetControlVersion;
std::string sourceDBCluster;
std::string disableWriteWindows;
std::string sourceControlVersion;
std::string subJobStatus;
long bytesPerMinute;
long unsyncedParts;
std::string subJob;
double partsPerMinute;
};
DescribeTransferHistoryResult();
explicit DescribeTransferHistoryResult(const std::string &payload);
~DescribeTransferHistoryResult();
std::vector<HistoryDetail> getHistoryDetails()const;
protected:
void parse(const std::string &payload);
private:
std::vector<HistoryDetail> historyDetails_;
};
}
}
}
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBETRANSFERHISTORYRESULT_H_

63
clickhouse/include/alibabacloud/clickhouse/model/KillProcessRequest.h Normal file
View File

@@ -0,0 +1,63 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_KILLPROCESSREQUEST_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_KILLPROCESSREQUEST_H_
#include <alibabacloud/clickhouse/ClickhouseExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Clickhouse {
namespace Model {
class ALIBABACLOUD_CLICKHOUSE_EXPORT KillProcessRequest : public RpcServiceRequest {
public:
KillProcessRequest();
~KillProcessRequest();
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
std::string getInitialQueryId() const;
void setInitialQueryId(const std::string &initialQueryId);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getDBClusterId() const;
void setDBClusterId(const std::string &dBClusterId);
std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
long getOwnerId() const;
void setOwnerId(long ownerId);
private:
long resourceOwnerId_;
std::string initialQueryId_;
std::string accessKeyId_;
std::string regionId_;
std::string resourceOwnerAccount_;
std::string dBClusterId_;
std::string ownerAccount_;
long ownerId_;
};
} // namespace Model
} // namespace Clickhouse
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_KILLPROCESSREQUEST_H_

49
clickhouse/include/alibabacloud/clickhouse/model/KillProcessResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_KILLPROCESSRESULT_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_KILLPROCESSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/clickhouse/ClickhouseExport.h>
namespace AlibabaCloud
{
namespace Clickhouse
{
namespace Model
{
class ALIBABACLOUD_CLICKHOUSE_EXPORT KillProcessResult : public ServiceResult
{
public:
KillProcessResult();
explicit KillProcessResult(const std::string &payload);
~KillProcessResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_KILLPROCESSRESULT_H_

81
clickhouse/include/alibabacloud/clickhouse/model/ModifyAccountAuthorityRequest.h Normal file
View File

@@ -0,0 +1,81 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_MODIFYACCOUNTAUTHORITYREQUEST_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_MODIFYACCOUNTAUTHORITYREQUEST_H_
#include <alibabacloud/clickhouse/ClickhouseExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Clickhouse {
namespace Model {
class ALIBABACLOUD_CLICKHOUSE_EXPORT ModifyAccountAuthorityRequest : public RpcServiceRequest {
public:
ModifyAccountAuthorityRequest();
~ModifyAccountAuthorityRequest();
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
std::string getTotalDictionaries() const;
void setTotalDictionaries(const std::string &totalDictionaries);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getAccountName() const;
void setAccountName(const std::string &accountName);
std::string getDmlAuthority() const;
void setDmlAuthority(const std::string &dmlAuthority);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getDBClusterId() const;
void setDBClusterId(const std::string &dBClusterId);
std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
std::string getAllowDatabases() const;
void setAllowDatabases(const std::string &allowDatabases);
std::string getAllowDictionaries() const;
void setAllowDictionaries(const std::string &allowDictionaries);
long getOwnerId() const;
void setOwnerId(long ownerId);
bool getDdlAuthority() const;
void setDdlAuthority(bool ddlAuthority);
std::string getTotalDatabases() const;
void setTotalDatabases(const std::string &totalDatabases);
private:
long resourceOwnerId_;
std::string totalDictionaries_;
std::string accessKeyId_;
std::string accountName_;
std::string dmlAuthority_;
std::string regionId_;
std::string resourceOwnerAccount_;
std::string dBClusterId_;
std::string ownerAccount_;
std::string allowDatabases_;
std::string allowDictionaries_;
long ownerId_;
bool ddlAuthority_;
std::string totalDatabases_;
};
} // namespace Model
} // namespace Clickhouse
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_MODIFYACCOUNTAUTHORITYREQUEST_H_

49
clickhouse/include/alibabacloud/clickhouse/model/ModifyAccountAuthorityResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_MODIFYACCOUNTAUTHORITYRESULT_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_MODIFYACCOUNTAUTHORITYRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/clickhouse/ClickhouseExport.h>
namespace AlibabaCloud
{
namespace Clickhouse
{
namespace Model
{
class ALIBABACLOUD_CLICKHOUSE_EXPORT ModifyAccountAuthorityResult : public ServiceResult
{
public:
ModifyAccountAuthorityResult();
explicit ModifyAccountAuthorityResult(const std::string &payload);
~ModifyAccountAuthorityResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_MODIFYACCOUNTAUTHORITYRESULT_H_

63
clickhouse/include/alibabacloud/clickhouse/model/ModifyAccountDescriptionRequest.h Normal file
View File

@@ -0,0 +1,63 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_MODIFYACCOUNTDESCRIPTIONREQUEST_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_MODIFYACCOUNTDESCRIPTIONREQUEST_H_
#include <alibabacloud/clickhouse/ClickhouseExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Clickhouse {
namespace Model {
class ALIBABACLOUD_CLICKHOUSE_EXPORT ModifyAccountDescriptionRequest : public RpcServiceRequest {
public:
ModifyAccountDescriptionRequest();
~ModifyAccountDescriptionRequest();
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
std::string getAccountDescription() const;
void setAccountDescription(const std::string &accountDescription);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getAccountName() const;
void setAccountName(const std::string &accountName);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getDBClusterId() const;
void setDBClusterId(const std::string &dBClusterId);
std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
long getOwnerId() const;
void setOwnerId(long ownerId);
private:
long resourceOwnerId_;
std::string accountDescription_;
std::string accessKeyId_;
std::string accountName_;
std::string resourceOwnerAccount_;
std::string dBClusterId_;
std::string ownerAccount_;
long ownerId_;
};
} // namespace Model
} // namespace Clickhouse
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_MODIFYACCOUNTDESCRIPTIONREQUEST_H_

49
clickhouse/include/alibabacloud/clickhouse/model/ModifyAccountDescriptionResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_MODIFYACCOUNTDESCRIPTIONRESULT_H_
#define ALIBABACLOUD_CLICKHOUSE_MODEL_MODIFYACCOUNTDESCRIPTIONRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/clickhouse/ClickhouseExport.h>
namespace AlibabaCloud
{
namespace Clickhouse
{
namespace Model
{
class ALIBABACLOUD_CLICKHOUSE_EXPORT ModifyAccountDescriptionResult : public ServiceResult
{
public:
ModifyAccountDescriptionResult();
explicit ModifyAccountDescriptionResult(const std::string &payload);
~ModifyAccountDescriptionResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_MODIFYACCOUNTDESCRIPTIONRESULT_H_

Some files were not shown because too many files have changed in this diff Show More