From c994b2d439376563fbaccafac2322a373f9ab9d2 Mon Sep 17 00:00:00 2001 From: sdk-team Date: Thu, 3 Aug 2023 15:00:31 +0000 Subject: [PATCH] Automatically generate sdk tasks. --- VERSION | 2 +- rds-data/CMakeLists.txt | 122 ++++++ .../alibabacloud/rds-data/Rds_dataClient.h | 126 ++++++ .../alibabacloud/rds-data/Rds_dataExport.h | 32 ++ .../model/BatchExecuteStatementRequest.h | 70 +++ .../model/BatchExecuteStatementResult.h | 49 +++ .../rds-data/model/BeginTransactionRequest.h | 48 ++ .../rds-data/model/BeginTransactionResult.h | 61 +++ .../rds-data/model/CommitTransactionRequest.h | 48 ++ .../rds-data/model/CommitTransactionResult.h | 61 +++ .../rds-data/model/DeleteRequest.h | 57 +++ .../rds-data/model/DeleteResult.h | 61 +++ .../rds-data/model/ExecuteStatementRequest.h | 86 ++++ .../rds-data/model/ExecuteStatementResult.h | 49 +++ .../rds-data/model/InsertListRequest.h | 57 +++ .../rds-data/model/InsertListResult.h | 62 +++ .../rds-data/model/InsertRequest.h | 57 +++ .../rds-data/model/InsertResult.h | 62 +++ .../model/RollbackTransactionRequest.h | 48 ++ .../model/RollbackTransactionResult.h | 61 +++ .../rds-data/model/SelectRequest.h | 63 +++ .../rds-data/model/SelectResult.h | 61 +++ .../rds-data/model/UpdateRequest.h | 60 +++ .../rds-data/model/UpdateResult.h | 61 +++ rds-data/src/Rds-dataClient.cc | 413 ++++++++++++++++++ .../src/model/BatchExecuteStatementRequest.cc | 92 ++++ .../src/model/BatchExecuteStatementResult.cc | 44 ++ rds-data/src/model/BeginTransactionRequest.cc | 54 +++ rds-data/src/model/BeginTransactionResult.cc | 73 ++++ .../src/model/CommitTransactionRequest.cc | 54 +++ rds-data/src/model/CommitTransactionResult.cc | 73 ++++ rds-data/src/model/DeleteRequest.cc | 81 ++++ rds-data/src/model/DeleteResult.cc | 73 ++++ rds-data/src/model/ExecuteStatementRequest.cc | 127 ++++++ rds-data/src/model/ExecuteStatementResult.cc | 44 ++ rds-data/src/model/InsertListRequest.cc | 85 ++++ rds-data/src/model/InsertListResult.cc | 76 ++++ rds-data/src/model/InsertRequest.cc | 83 ++++ rds-data/src/model/InsertResult.cc | 75 ++++ .../src/model/RollbackTransactionRequest.cc | 54 +++ .../src/model/RollbackTransactionResult.cc | 73 ++++ rds-data/src/model/SelectRequest.cc | 99 +++++ rds-data/src/model/SelectResult.cc | 74 ++++ rds-data/src/model/UpdateRequest.cc | 92 ++++ rds-data/src/model/UpdateResult.cc | 73 ++++ 45 files changed, 3375 insertions(+), 1 deletion(-) create mode 100644 rds-data/CMakeLists.txt create mode 100644 rds-data/include/alibabacloud/rds-data/Rds_dataClient.h create mode 100644 rds-data/include/alibabacloud/rds-data/Rds_dataExport.h create mode 100644 rds-data/include/alibabacloud/rds-data/model/BatchExecuteStatementRequest.h create mode 100644 rds-data/include/alibabacloud/rds-data/model/BatchExecuteStatementResult.h create mode 100644 rds-data/include/alibabacloud/rds-data/model/BeginTransactionRequest.h create mode 100644 rds-data/include/alibabacloud/rds-data/model/BeginTransactionResult.h create mode 100644 rds-data/include/alibabacloud/rds-data/model/CommitTransactionRequest.h create mode 100644 rds-data/include/alibabacloud/rds-data/model/CommitTransactionResult.h create mode 100644 rds-data/include/alibabacloud/rds-data/model/DeleteRequest.h create mode 100644 rds-data/include/alibabacloud/rds-data/model/DeleteResult.h create mode 100644 rds-data/include/alibabacloud/rds-data/model/ExecuteStatementRequest.h create mode 100644 rds-data/include/alibabacloud/rds-data/model/ExecuteStatementResult.h create mode 100644 rds-data/include/alibabacloud/rds-data/model/InsertListRequest.h create mode 100644 rds-data/include/alibabacloud/rds-data/model/InsertListResult.h create mode 100644 rds-data/include/alibabacloud/rds-data/model/InsertRequest.h create mode 100644 rds-data/include/alibabacloud/rds-data/model/InsertResult.h create mode 100644 rds-data/include/alibabacloud/rds-data/model/RollbackTransactionRequest.h create mode 100644 rds-data/include/alibabacloud/rds-data/model/RollbackTransactionResult.h create mode 100644 rds-data/include/alibabacloud/rds-data/model/SelectRequest.h create mode 100644 rds-data/include/alibabacloud/rds-data/model/SelectResult.h create mode 100644 rds-data/include/alibabacloud/rds-data/model/UpdateRequest.h create mode 100644 rds-data/include/alibabacloud/rds-data/model/UpdateResult.h create mode 100644 rds-data/src/Rds-dataClient.cc create mode 100644 rds-data/src/model/BatchExecuteStatementRequest.cc create mode 100644 rds-data/src/model/BatchExecuteStatementResult.cc create mode 100644 rds-data/src/model/BeginTransactionRequest.cc create mode 100644 rds-data/src/model/BeginTransactionResult.cc create mode 100644 rds-data/src/model/CommitTransactionRequest.cc create mode 100644 rds-data/src/model/CommitTransactionResult.cc create mode 100644 rds-data/src/model/DeleteRequest.cc create mode 100644 rds-data/src/model/DeleteResult.cc create mode 100644 rds-data/src/model/ExecuteStatementRequest.cc create mode 100644 rds-data/src/model/ExecuteStatementResult.cc create mode 100644 rds-data/src/model/InsertListRequest.cc create mode 100644 rds-data/src/model/InsertListResult.cc create mode 100644 rds-data/src/model/InsertRequest.cc create mode 100644 rds-data/src/model/InsertResult.cc create mode 100644 rds-data/src/model/RollbackTransactionRequest.cc create mode 100644 rds-data/src/model/RollbackTransactionResult.cc create mode 100644 rds-data/src/model/SelectRequest.cc create mode 100644 rds-data/src/model/SelectResult.cc create mode 100644 rds-data/src/model/UpdateRequest.cc create mode 100644 rds-data/src/model/UpdateResult.cc diff --git a/VERSION b/VERSION index 44ed10e27..ca8be06f9 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -1.36.1712 \ No newline at end of file +1.36.1713 \ No newline at end of file diff --git a/rds-data/CMakeLists.txt b/rds-data/CMakeLists.txt new file mode 100644 index 000000000..79d2da1f4 --- /dev/null +++ b/rds-data/CMakeLists.txt @@ -0,0 +1,122 @@ +# +# 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(rds-data_public_header + include/alibabacloud/rds-data/Rds_dataClient.h + include/alibabacloud/rds-data/Rds_dataExport.h ) + +set(rds-data_public_header_model + include/alibabacloud/rds-data/model/BatchExecuteStatementRequest.h + include/alibabacloud/rds-data/model/BatchExecuteStatementResult.h + include/alibabacloud/rds-data/model/BeginTransactionRequest.h + include/alibabacloud/rds-data/model/BeginTransactionResult.h + include/alibabacloud/rds-data/model/CommitTransactionRequest.h + include/alibabacloud/rds-data/model/CommitTransactionResult.h + include/alibabacloud/rds-data/model/DeleteRequest.h + include/alibabacloud/rds-data/model/DeleteResult.h + include/alibabacloud/rds-data/model/ExecuteStatementRequest.h + include/alibabacloud/rds-data/model/ExecuteStatementResult.h + include/alibabacloud/rds-data/model/InsertRequest.h + include/alibabacloud/rds-data/model/InsertResult.h + include/alibabacloud/rds-data/model/InsertListRequest.h + include/alibabacloud/rds-data/model/InsertListResult.h + include/alibabacloud/rds-data/model/RollbackTransactionRequest.h + include/alibabacloud/rds-data/model/RollbackTransactionResult.h + include/alibabacloud/rds-data/model/SelectRequest.h + include/alibabacloud/rds-data/model/SelectResult.h + include/alibabacloud/rds-data/model/UpdateRequest.h + include/alibabacloud/rds-data/model/UpdateResult.h ) + +set(rds-data_src + src/Rds-dataClient.cc + src/model/BatchExecuteStatementRequest.cc + src/model/BatchExecuteStatementResult.cc + src/model/BeginTransactionRequest.cc + src/model/BeginTransactionResult.cc + src/model/CommitTransactionRequest.cc + src/model/CommitTransactionResult.cc + src/model/DeleteRequest.cc + src/model/DeleteResult.cc + src/model/ExecuteStatementRequest.cc + src/model/ExecuteStatementResult.cc + src/model/InsertRequest.cc + src/model/InsertResult.cc + src/model/InsertListRequest.cc + src/model/InsertListResult.cc + src/model/RollbackTransactionRequest.cc + src/model/RollbackTransactionResult.cc + src/model/SelectRequest.cc + src/model/SelectResult.cc + src/model/UpdateRequest.cc + src/model/UpdateResult.cc ) + +add_library(rds-data ${LIB_TYPE} + ${rds-data_public_header} + ${rds-data_public_header_model} + ${rds-data_src}) + +set_target_properties(rds-data + 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}rds-data + ) + +if(${LIB_TYPE} STREQUAL "SHARED") + set_target_properties(rds-data + PROPERTIES + DEFINE_SYMBOL ALIBABACLOUD_RDS_DATA_LIBRARY) +endif() + +target_include_directories(rds-data + PRIVATE include + ${CMAKE_SOURCE_DIR}/core/include + ) +target_link_libraries(rds-data + core) + +if(CMAKE_HOST_WIN32) + ExternalProject_Get_Property(jsoncpp INSTALL_DIR) + set(jsoncpp_install_dir ${INSTALL_DIR}) + add_dependencies(rds-data + jsoncpp) + target_include_directories(rds-data + PRIVATE ${jsoncpp_install_dir}/include) + target_link_libraries(rds-data + ${jsoncpp_install_dir}/lib/jsoncpp.lib) + set_target_properties(rds-data + PROPERTIES + COMPILE_OPTIONS "/bigobj") +else() + target_include_directories(rds-data + PRIVATE /usr/include/jsoncpp) + target_link_libraries(rds-data + jsoncpp) +endif() + +install(FILES ${rds-data_public_header} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/rds-data) +install(FILES ${rds-data_public_header_model} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/rds-data/model) +install(TARGETS rds-data + ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} + LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} + RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} + ) \ No newline at end of file diff --git a/rds-data/include/alibabacloud/rds-data/Rds_dataClient.h b/rds-data/include/alibabacloud/rds-data/Rds_dataClient.h new file mode 100644 index 000000000..ebaadd79e --- /dev/null +++ b/rds-data/include/alibabacloud/rds-data/Rds_dataClient.h @@ -0,0 +1,126 @@ +/* + * 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_RDS_DATA_RDS_DATACLIENT_H_ +#define ALIBABACLOUD_RDS_DATA_RDS_DATACLIENT_H_ + +#include +#include +#include +#include +#include "Rds_dataExport.h" +#include "model/BatchExecuteStatementRequest.h" +#include "model/BatchExecuteStatementResult.h" +#include "model/BeginTransactionRequest.h" +#include "model/BeginTransactionResult.h" +#include "model/CommitTransactionRequest.h" +#include "model/CommitTransactionResult.h" +#include "model/DeleteRequest.h" +#include "model/DeleteResult.h" +#include "model/ExecuteStatementRequest.h" +#include "model/ExecuteStatementResult.h" +#include "model/InsertRequest.h" +#include "model/InsertResult.h" +#include "model/InsertListRequest.h" +#include "model/InsertListResult.h" +#include "model/RollbackTransactionRequest.h" +#include "model/RollbackTransactionResult.h" +#include "model/SelectRequest.h" +#include "model/SelectResult.h" +#include "model/UpdateRequest.h" +#include "model/UpdateResult.h" + + +namespace AlibabaCloud +{ + namespace Rds_data + { + class ALIBABACLOUD_RDS_DATA_EXPORT Rds_dataClient : public RpcServiceClient + { + public: + typedef Outcome BatchExecuteStatementOutcome; + typedef std::future BatchExecuteStatementOutcomeCallable; + typedef std::function&)> BatchExecuteStatementAsyncHandler; + typedef Outcome BeginTransactionOutcome; + typedef std::future BeginTransactionOutcomeCallable; + typedef std::function&)> BeginTransactionAsyncHandler; + typedef Outcome CommitTransactionOutcome; + typedef std::future CommitTransactionOutcomeCallable; + typedef std::function&)> CommitTransactionAsyncHandler; + typedef Outcome DeleteOutcome; + typedef std::future DeleteOutcomeCallable; + typedef std::function&)> DeleteAsyncHandler; + typedef Outcome ExecuteStatementOutcome; + typedef std::future ExecuteStatementOutcomeCallable; + typedef std::function&)> ExecuteStatementAsyncHandler; + typedef Outcome InsertOutcome; + typedef std::future InsertOutcomeCallable; + typedef std::function&)> InsertAsyncHandler; + typedef Outcome InsertListOutcome; + typedef std::future InsertListOutcomeCallable; + typedef std::function&)> InsertListAsyncHandler; + typedef Outcome RollbackTransactionOutcome; + typedef std::future RollbackTransactionOutcomeCallable; + typedef std::function&)> RollbackTransactionAsyncHandler; + typedef Outcome SelectOutcome; + typedef std::future SelectOutcomeCallable; + typedef std::function&)> SelectAsyncHandler; + typedef Outcome UpdateOutcome; + typedef std::future UpdateOutcomeCallable; + typedef std::function&)> UpdateAsyncHandler; + + Rds_dataClient(const Credentials &credentials, const ClientConfiguration &configuration); + Rds_dataClient(const std::shared_ptr &credentialsProvider, const ClientConfiguration &configuration); + Rds_dataClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration); + ~Rds_dataClient(); + BatchExecuteStatementOutcome batchExecuteStatement(const Model::BatchExecuteStatementRequest &request)const; + void batchExecuteStatementAsync(const Model::BatchExecuteStatementRequest& request, const BatchExecuteStatementAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + BatchExecuteStatementOutcomeCallable batchExecuteStatementCallable(const Model::BatchExecuteStatementRequest& request) const; + BeginTransactionOutcome beginTransaction(const Model::BeginTransactionRequest &request)const; + void beginTransactionAsync(const Model::BeginTransactionRequest& request, const BeginTransactionAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + BeginTransactionOutcomeCallable beginTransactionCallable(const Model::BeginTransactionRequest& request) const; + CommitTransactionOutcome commitTransaction(const Model::CommitTransactionRequest &request)const; + void commitTransactionAsync(const Model::CommitTransactionRequest& request, const CommitTransactionAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + CommitTransactionOutcomeCallable commitTransactionCallable(const Model::CommitTransactionRequest& request) const; + DeleteOutcome delete(const Model::DeleteRequest &request)const; + void deleteAsync(const Model::DeleteRequest& request, const DeleteAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DeleteOutcomeCallable deleteCallable(const Model::DeleteRequest& request) const; + ExecuteStatementOutcome executeStatement(const Model::ExecuteStatementRequest &request)const; + void executeStatementAsync(const Model::ExecuteStatementRequest& request, const ExecuteStatementAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + ExecuteStatementOutcomeCallable executeStatementCallable(const Model::ExecuteStatementRequest& request) const; + InsertOutcome insert(const Model::InsertRequest &request)const; + void insertAsync(const Model::InsertRequest& request, const InsertAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + InsertOutcomeCallable insertCallable(const Model::InsertRequest& request) const; + InsertListOutcome insertList(const Model::InsertListRequest &request)const; + void insertListAsync(const Model::InsertListRequest& request, const InsertListAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + InsertListOutcomeCallable insertListCallable(const Model::InsertListRequest& request) const; + RollbackTransactionOutcome rollbackTransaction(const Model::RollbackTransactionRequest &request)const; + void rollbackTransactionAsync(const Model::RollbackTransactionRequest& request, const RollbackTransactionAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + RollbackTransactionOutcomeCallable rollbackTransactionCallable(const Model::RollbackTransactionRequest& request) const; + SelectOutcome select(const Model::SelectRequest &request)const; + void selectAsync(const Model::SelectRequest& request, const SelectAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + SelectOutcomeCallable selectCallable(const Model::SelectRequest& request) const; + UpdateOutcome update(const Model::UpdateRequest &request)const; + void updateAsync(const Model::UpdateRequest& request, const UpdateAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + UpdateOutcomeCallable updateCallable(const Model::UpdateRequest& request) const; + + private: + std::shared_ptr endpointProvider_; + }; + } +} + +#endif // !ALIBABACLOUD_RDS_DATA_RDS_DATACLIENT_H_ diff --git a/rds-data/include/alibabacloud/rds-data/Rds_dataExport.h b/rds-data/include/alibabacloud/rds-data/Rds_dataExport.h new file mode 100644 index 000000000..801479b51 --- /dev/null +++ b/rds-data/include/alibabacloud/rds-data/Rds_dataExport.h @@ -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_RDS_DATA_RDS_DATAEXPORT_H_ +#define ALIBABACLOUD_RDS_DATA_RDS_DATAEXPORT_H_ + +#include + +#if defined(ALIBABACLOUD_SHARED) +# if defined(ALIBABACLOUD_RDS_DATA_LIBRARY) +# define ALIBABACLOUD_RDS_DATA_EXPORT ALIBABACLOUD_DECL_EXPORT +# else +# define ALIBABACLOUD_RDS_DATA_EXPORT ALIBABACLOUD_DECL_IMPORT +# endif +#else +# define ALIBABACLOUD_RDS_DATA_EXPORT +#endif + +#endif // !ALIBABACLOUD_RDS_DATA_RDS_DATAEXPORT_H_ \ No newline at end of file diff --git a/rds-data/include/alibabacloud/rds-data/model/BatchExecuteStatementRequest.h b/rds-data/include/alibabacloud/rds-data/model/BatchExecuteStatementRequest.h new file mode 100644 index 000000000..006cf7f8d --- /dev/null +++ b/rds-data/include/alibabacloud/rds-data/model/BatchExecuteStatementRequest.h @@ -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_RDS_DATA_MODEL_BATCHEXECUTESTATEMENTREQUEST_H_ +#define ALIBABACLOUD_RDS_DATA_MODEL_BATCHEXECUTESTATEMENTREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Rds_data { +namespace Model { +class ALIBABACLOUD_RDS_DATA_EXPORT BatchExecuteStatementRequest : public RpcServiceRequest { +public: + struct ParameterSetsItem { + std::string name; + std::string typeHint; + struct Value { + std::string arrayValue; + std::string blobValue; + bool booleanValue; + bool isNull; + long longValue; + std::string stringValue; + }; + Value value; + }; + BatchExecuteStatementRequest(); + ~BatchExecuteStatementRequest(); + std::vector> getParameterSets() const; + void setParameterSets(const std::vector> ¶meterSets); + std::string getTransactionId() const; + void setTransactionId(const std::string &transactionId); + std::string getSql() const; + void setSql(const std::string &sql); + std::string getDatabase() const; + void setDatabase(const std::string &database); + std::string getResourceArn() const; + void setResourceArn(const std::string &resourceArn); + std::string getSecretArn() const; + void setSecretArn(const std::string &secretArn); + +private: + std::vector> parameterSets_; + std::string transactionId_; + std::string sql_; + std::string database_; + std::string resourceArn_; + std::string secretArn_; +}; +} // namespace Model +} // namespace Rds_data +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_RDS_DATA_MODEL_BATCHEXECUTESTATEMENTREQUEST_H_ diff --git a/rds-data/include/alibabacloud/rds-data/model/BatchExecuteStatementResult.h b/rds-data/include/alibabacloud/rds-data/model/BatchExecuteStatementResult.h new file mode 100644 index 000000000..8365e4f1c --- /dev/null +++ b/rds-data/include/alibabacloud/rds-data/model/BatchExecuteStatementResult.h @@ -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_RDS_DATA_MODEL_BATCHEXECUTESTATEMENTRESULT_H_ +#define ALIBABACLOUD_RDS_DATA_MODEL_BATCHEXECUTESTATEMENTRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Rds_data + { + namespace Model + { + class ALIBABACLOUD_RDS_DATA_EXPORT BatchExecuteStatementResult : public ServiceResult + { + public: + + + BatchExecuteStatementResult(); + explicit BatchExecuteStatementResult(const std::string &payload); + ~BatchExecuteStatementResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_RDS_DATA_MODEL_BATCHEXECUTESTATEMENTRESULT_H_ \ No newline at end of file diff --git a/rds-data/include/alibabacloud/rds-data/model/BeginTransactionRequest.h b/rds-data/include/alibabacloud/rds-data/model/BeginTransactionRequest.h new file mode 100644 index 000000000..12cc900e4 --- /dev/null +++ b/rds-data/include/alibabacloud/rds-data/model/BeginTransactionRequest.h @@ -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_RDS_DATA_MODEL_BEGINTRANSACTIONREQUEST_H_ +#define ALIBABACLOUD_RDS_DATA_MODEL_BEGINTRANSACTIONREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Rds_data { +namespace Model { +class ALIBABACLOUD_RDS_DATA_EXPORT BeginTransactionRequest : public RpcServiceRequest { +public: + BeginTransactionRequest(); + ~BeginTransactionRequest(); + std::string getDatabase() const; + void setDatabase(const std::string &database); + std::string getResourceArn() const; + void setResourceArn(const std::string &resourceArn); + std::string getSecretArn() const; + void setSecretArn(const std::string &secretArn); + +private: + std::string database_; + std::string resourceArn_; + std::string secretArn_; +}; +} // namespace Model +} // namespace Rds_data +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_RDS_DATA_MODEL_BEGINTRANSACTIONREQUEST_H_ diff --git a/rds-data/include/alibabacloud/rds-data/model/BeginTransactionResult.h b/rds-data/include/alibabacloud/rds-data/model/BeginTransactionResult.h new file mode 100644 index 000000000..febddeff3 --- /dev/null +++ b/rds-data/include/alibabacloud/rds-data/model/BeginTransactionResult.h @@ -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_RDS_DATA_MODEL_BEGINTRANSACTIONRESULT_H_ +#define ALIBABACLOUD_RDS_DATA_MODEL_BEGINTRANSACTIONRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Rds_data + { + namespace Model + { + class ALIBABACLOUD_RDS_DATA_EXPORT BeginTransactionResult : public ServiceResult + { + public: + struct Data + { + std::string transactionId; + }; + + + BeginTransactionResult(); + explicit BeginTransactionResult(const std::string &payload); + ~BeginTransactionResult(); + std::string getMessage()const; + Data getData()const; + std::string getCode()const; + bool getSuccess()const; + + protected: + void parse(const std::string &payload); + private: + std::string message_; + Data data_; + std::string code_; + bool success_; + + }; + } + } +} +#endif // !ALIBABACLOUD_RDS_DATA_MODEL_BEGINTRANSACTIONRESULT_H_ \ No newline at end of file diff --git a/rds-data/include/alibabacloud/rds-data/model/CommitTransactionRequest.h b/rds-data/include/alibabacloud/rds-data/model/CommitTransactionRequest.h new file mode 100644 index 000000000..309a76ec7 --- /dev/null +++ b/rds-data/include/alibabacloud/rds-data/model/CommitTransactionRequest.h @@ -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_RDS_DATA_MODEL_COMMITTRANSACTIONREQUEST_H_ +#define ALIBABACLOUD_RDS_DATA_MODEL_COMMITTRANSACTIONREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Rds_data { +namespace Model { +class ALIBABACLOUD_RDS_DATA_EXPORT CommitTransactionRequest : public RpcServiceRequest { +public: + CommitTransactionRequest(); + ~CommitTransactionRequest(); + std::string getTransactionId() const; + void setTransactionId(const std::string &transactionId); + std::string getResourceArn() const; + void setResourceArn(const std::string &resourceArn); + std::string getSecretArn() const; + void setSecretArn(const std::string &secretArn); + +private: + std::string transactionId_; + std::string resourceArn_; + std::string secretArn_; +}; +} // namespace Model +} // namespace Rds_data +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_RDS_DATA_MODEL_COMMITTRANSACTIONREQUEST_H_ diff --git a/rds-data/include/alibabacloud/rds-data/model/CommitTransactionResult.h b/rds-data/include/alibabacloud/rds-data/model/CommitTransactionResult.h new file mode 100644 index 000000000..a8ba40155 --- /dev/null +++ b/rds-data/include/alibabacloud/rds-data/model/CommitTransactionResult.h @@ -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_RDS_DATA_MODEL_COMMITTRANSACTIONRESULT_H_ +#define ALIBABACLOUD_RDS_DATA_MODEL_COMMITTRANSACTIONRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Rds_data + { + namespace Model + { + class ALIBABACLOUD_RDS_DATA_EXPORT CommitTransactionResult : public ServiceResult + { + public: + struct Data + { + std::string transactionStatus; + }; + + + CommitTransactionResult(); + explicit CommitTransactionResult(const std::string &payload); + ~CommitTransactionResult(); + std::string getMessage()const; + Data getData()const; + std::string getCode()const; + bool getSuccess()const; + + protected: + void parse(const std::string &payload); + private: + std::string message_; + Data data_; + std::string code_; + bool success_; + + }; + } + } +} +#endif // !ALIBABACLOUD_RDS_DATA_MODEL_COMMITTRANSACTIONRESULT_H_ \ No newline at end of file diff --git a/rds-data/include/alibabacloud/rds-data/model/DeleteRequest.h b/rds-data/include/alibabacloud/rds-data/model/DeleteRequest.h new file mode 100644 index 000000000..fd5df6da5 --- /dev/null +++ b/rds-data/include/alibabacloud/rds-data/model/DeleteRequest.h @@ -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_RDS_DATA_MODEL_DELETEREQUEST_H_ +#define ALIBABACLOUD_RDS_DATA_MODEL_DELETEREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Rds_data { +namespace Model { +class ALIBABACLOUD_RDS_DATA_EXPORT DeleteRequest : public RpcServiceRequest { +public: + DeleteRequest(); + ~DeleteRequest(); + std::string getTransactionId() const; + void setTransactionId(const std::string &transactionId); + std::string getFilter() const; + void setFilter(const std::string &filter); + std::string getDatabase() const; + void setDatabase(const std::string &database); + std::string getResourceArn() const; + void setResourceArn(const std::string &resourceArn); + std::string getTable() const; + void setTable(const std::string &table); + std::string getSecretArn() const; + void setSecretArn(const std::string &secretArn); + +private: + std::string transactionId_; + std::string filter_; + std::string database_; + std::string resourceArn_; + std::string table_; + std::string secretArn_; +}; +} // namespace Model +} // namespace Rds_data +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_RDS_DATA_MODEL_DELETEREQUEST_H_ diff --git a/rds-data/include/alibabacloud/rds-data/model/DeleteResult.h b/rds-data/include/alibabacloud/rds-data/model/DeleteResult.h new file mode 100644 index 000000000..c8b92a13d --- /dev/null +++ b/rds-data/include/alibabacloud/rds-data/model/DeleteResult.h @@ -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_RDS_DATA_MODEL_DELETERESULT_H_ +#define ALIBABACLOUD_RDS_DATA_MODEL_DELETERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Rds_data + { + namespace Model + { + class ALIBABACLOUD_RDS_DATA_EXPORT DeleteResult : public ServiceResult + { + public: + struct Data + { + long numberOfRecordsUpdated; + }; + + + DeleteResult(); + explicit DeleteResult(const std::string &payload); + ~DeleteResult(); + std::string getMessage()const; + Data getData()const; + std::string getCode()const; + bool getSuccess()const; + + protected: + void parse(const std::string &payload); + private: + std::string message_; + Data data_; + std::string code_; + bool success_; + + }; + } + } +} +#endif // !ALIBABACLOUD_RDS_DATA_MODEL_DELETERESULT_H_ \ No newline at end of file diff --git a/rds-data/include/alibabacloud/rds-data/model/ExecuteStatementRequest.h b/rds-data/include/alibabacloud/rds-data/model/ExecuteStatementRequest.h new file mode 100644 index 000000000..7fbcec8d9 --- /dev/null +++ b/rds-data/include/alibabacloud/rds-data/model/ExecuteStatementRequest.h @@ -0,0 +1,86 @@ +/* + * 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_RDS_DATA_MODEL_EXECUTESTATEMENTREQUEST_H_ +#define ALIBABACLOUD_RDS_DATA_MODEL_EXECUTESTATEMENTREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Rds_data { +namespace Model { +class ALIBABACLOUD_RDS_DATA_EXPORT ExecuteStatementRequest : public RpcServiceRequest { +public: + struct ResultSetOptions { + std::string decimalReturnType; + std::string longReturnType; + }; + struct Parameters { + std::string name; + std::string typeHint; + struct Value { + std::string arrayValue; + std::string blobValue; + bool booleanValue; + bool isNull; + long longValue; + std::string stringValue; + }; + Value value; + }; + ExecuteStatementRequest(); + ~ExecuteStatementRequest(); + bool getIncludeResultMetadata() const; + void setIncludeResultMetadata(bool includeResultMetadata); + std::string getFormatRecordsAs() const; + void setFormatRecordsAs(const std::string &formatRecordsAs); + std::string getTransactionId() const; + void setTransactionId(const std::string &transactionId); + std::string getSql() const; + void setSql(const std::string &sql); + ResultSetOptions getResultSetOptions() const; + void setResultSetOptions(const ResultSetOptions &resultSetOptions); + std::string getDatabase() const; + void setDatabase(const std::string &database); + std::string getResourceArn() const; + void setResourceArn(const std::string &resourceArn); + std::vector getParameters() const; + void setParameters(const std::vector ¶meters); + bool getContinueAfterTimeout() const; + void setContinueAfterTimeout(bool continueAfterTimeout); + std::string getSecretArn() const; + void setSecretArn(const std::string &secretArn); + +private: + bool includeResultMetadata_; + std::string formatRecordsAs_; + std::string transactionId_; + std::string sql_; + ResultSetOptions resultSetOptions_; + std::string database_; + std::string resourceArn_; + std::vector parameters_; + bool continueAfterTimeout_; + std::string secretArn_; +}; +} // namespace Model +} // namespace Rds_data +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_RDS_DATA_MODEL_EXECUTESTATEMENTREQUEST_H_ diff --git a/rds-data/include/alibabacloud/rds-data/model/ExecuteStatementResult.h b/rds-data/include/alibabacloud/rds-data/model/ExecuteStatementResult.h new file mode 100644 index 000000000..0202a9d99 --- /dev/null +++ b/rds-data/include/alibabacloud/rds-data/model/ExecuteStatementResult.h @@ -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_RDS_DATA_MODEL_EXECUTESTATEMENTRESULT_H_ +#define ALIBABACLOUD_RDS_DATA_MODEL_EXECUTESTATEMENTRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Rds_data + { + namespace Model + { + class ALIBABACLOUD_RDS_DATA_EXPORT ExecuteStatementResult : public ServiceResult + { + public: + + + ExecuteStatementResult(); + explicit ExecuteStatementResult(const std::string &payload); + ~ExecuteStatementResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_RDS_DATA_MODEL_EXECUTESTATEMENTRESULT_H_ \ No newline at end of file diff --git a/rds-data/include/alibabacloud/rds-data/model/InsertListRequest.h b/rds-data/include/alibabacloud/rds-data/model/InsertListRequest.h new file mode 100644 index 000000000..87a849e62 --- /dev/null +++ b/rds-data/include/alibabacloud/rds-data/model/InsertListRequest.h @@ -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_RDS_DATA_MODEL_INSERTLISTREQUEST_H_ +#define ALIBABACLOUD_RDS_DATA_MODEL_INSERTLISTREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Rds_data { +namespace Model { +class ALIBABACLOUD_RDS_DATA_EXPORT InsertListRequest : public RpcServiceRequest { +public: + InsertListRequest(); + ~InsertListRequest(); + std::vector> getRecords() const; + void setRecords(const std::vector> &records); + std::string getTransactionId() const; + void setTransactionId(const std::string &transactionId); + std::string getDatabase() const; + void setDatabase(const std::string &database); + std::string getResourceArn() const; + void setResourceArn(const std::string &resourceArn); + std::string getTable() const; + void setTable(const std::string &table); + std::string getSecretArn() const; + void setSecretArn(const std::string &secretArn); + +private: + std::vector> records_; + std::string transactionId_; + std::string database_; + std::string resourceArn_; + std::string table_; + std::string secretArn_; +}; +} // namespace Model +} // namespace Rds_data +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_RDS_DATA_MODEL_INSERTLISTREQUEST_H_ diff --git a/rds-data/include/alibabacloud/rds-data/model/InsertListResult.h b/rds-data/include/alibabacloud/rds-data/model/InsertListResult.h new file mode 100644 index 000000000..e7eb3a7e4 --- /dev/null +++ b/rds-data/include/alibabacloud/rds-data/model/InsertListResult.h @@ -0,0 +1,62 @@ +/* + * 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_RDS_DATA_MODEL_INSERTLISTRESULT_H_ +#define ALIBABACLOUD_RDS_DATA_MODEL_INSERTLISTRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Rds_data + { + namespace Model + { + class ALIBABACLOUD_RDS_DATA_EXPORT InsertListResult : public ServiceResult + { + public: + struct Data + { + long numberOfRecordsUpdated; + std::vector autoIncrementKeys; + }; + + + InsertListResult(); + explicit InsertListResult(const std::string &payload); + ~InsertListResult(); + std::string getMessage()const; + Data getData()const; + std::string getCode()const; + bool getSuccess()const; + + protected: + void parse(const std::string &payload); + private: + std::string message_; + Data data_; + std::string code_; + bool success_; + + }; + } + } +} +#endif // !ALIBABACLOUD_RDS_DATA_MODEL_INSERTLISTRESULT_H_ \ No newline at end of file diff --git a/rds-data/include/alibabacloud/rds-data/model/InsertRequest.h b/rds-data/include/alibabacloud/rds-data/model/InsertRequest.h new file mode 100644 index 000000000..dcd437d12 --- /dev/null +++ b/rds-data/include/alibabacloud/rds-data/model/InsertRequest.h @@ -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_RDS_DATA_MODEL_INSERTREQUEST_H_ +#define ALIBABACLOUD_RDS_DATA_MODEL_INSERTREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Rds_data { +namespace Model { +class ALIBABACLOUD_RDS_DATA_EXPORT InsertRequest : public RpcServiceRequest { +public: + InsertRequest(); + ~InsertRequest(); + std::string getTransactionId() const; + void setTransactionId(const std::string &transactionId); + std::string getDatabase() const; + void setDatabase(const std::string &database); + std::map getRecord() const; + void setRecord(const std::map &record); + std::string getResourceArn() const; + void setResourceArn(const std::string &resourceArn); + std::string getTable() const; + void setTable(const std::string &table); + std::string getSecretArn() const; + void setSecretArn(const std::string &secretArn); + +private: + std::string transactionId_; + std::string database_; + std::map record_; + std::string resourceArn_; + std::string table_; + std::string secretArn_; +}; +} // namespace Model +} // namespace Rds_data +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_RDS_DATA_MODEL_INSERTREQUEST_H_ diff --git a/rds-data/include/alibabacloud/rds-data/model/InsertResult.h b/rds-data/include/alibabacloud/rds-data/model/InsertResult.h new file mode 100644 index 000000000..a3cffbd09 --- /dev/null +++ b/rds-data/include/alibabacloud/rds-data/model/InsertResult.h @@ -0,0 +1,62 @@ +/* + * 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_RDS_DATA_MODEL_INSERTRESULT_H_ +#define ALIBABACLOUD_RDS_DATA_MODEL_INSERTRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Rds_data + { + namespace Model + { + class ALIBABACLOUD_RDS_DATA_EXPORT InsertResult : public ServiceResult + { + public: + struct Data + { + long numberOfRecordsUpdated; + long autoIncrementKey; + }; + + + InsertResult(); + explicit InsertResult(const std::string &payload); + ~InsertResult(); + std::string getMessage()const; + Data getData()const; + std::string getCode()const; + bool getSuccess()const; + + protected: + void parse(const std::string &payload); + private: + std::string message_; + Data data_; + std::string code_; + bool success_; + + }; + } + } +} +#endif // !ALIBABACLOUD_RDS_DATA_MODEL_INSERTRESULT_H_ \ No newline at end of file diff --git a/rds-data/include/alibabacloud/rds-data/model/RollbackTransactionRequest.h b/rds-data/include/alibabacloud/rds-data/model/RollbackTransactionRequest.h new file mode 100644 index 000000000..7fe85a6ac --- /dev/null +++ b/rds-data/include/alibabacloud/rds-data/model/RollbackTransactionRequest.h @@ -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_RDS_DATA_MODEL_ROLLBACKTRANSACTIONREQUEST_H_ +#define ALIBABACLOUD_RDS_DATA_MODEL_ROLLBACKTRANSACTIONREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Rds_data { +namespace Model { +class ALIBABACLOUD_RDS_DATA_EXPORT RollbackTransactionRequest : public RpcServiceRequest { +public: + RollbackTransactionRequest(); + ~RollbackTransactionRequest(); + std::string getTransactionId() const; + void setTransactionId(const std::string &transactionId); + std::string getResourceArn() const; + void setResourceArn(const std::string &resourceArn); + std::string getSecretArn() const; + void setSecretArn(const std::string &secretArn); + +private: + std::string transactionId_; + std::string resourceArn_; + std::string secretArn_; +}; +} // namespace Model +} // namespace Rds_data +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_RDS_DATA_MODEL_ROLLBACKTRANSACTIONREQUEST_H_ diff --git a/rds-data/include/alibabacloud/rds-data/model/RollbackTransactionResult.h b/rds-data/include/alibabacloud/rds-data/model/RollbackTransactionResult.h new file mode 100644 index 000000000..055f9f56d --- /dev/null +++ b/rds-data/include/alibabacloud/rds-data/model/RollbackTransactionResult.h @@ -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_RDS_DATA_MODEL_ROLLBACKTRANSACTIONRESULT_H_ +#define ALIBABACLOUD_RDS_DATA_MODEL_ROLLBACKTRANSACTIONRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Rds_data + { + namespace Model + { + class ALIBABACLOUD_RDS_DATA_EXPORT RollbackTransactionResult : public ServiceResult + { + public: + struct Data + { + std::string transactionStatus; + }; + + + RollbackTransactionResult(); + explicit RollbackTransactionResult(const std::string &payload); + ~RollbackTransactionResult(); + std::string getMessage()const; + Data getData()const; + std::string getCode()const; + bool getSuccess()const; + + protected: + void parse(const std::string &payload); + private: + std::string message_; + Data data_; + std::string code_; + bool success_; + + }; + } + } +} +#endif // !ALIBABACLOUD_RDS_DATA_MODEL_ROLLBACKTRANSACTIONRESULT_H_ \ No newline at end of file diff --git a/rds-data/include/alibabacloud/rds-data/model/SelectRequest.h b/rds-data/include/alibabacloud/rds-data/model/SelectRequest.h new file mode 100644 index 000000000..b07f6eec1 --- /dev/null +++ b/rds-data/include/alibabacloud/rds-data/model/SelectRequest.h @@ -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_RDS_DATA_MODEL_SELECTREQUEST_H_ +#define ALIBABACLOUD_RDS_DATA_MODEL_SELECTREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Rds_data { +namespace Model { +class ALIBABACLOUD_RDS_DATA_EXPORT SelectRequest : public RpcServiceRequest { +public: + SelectRequest(); + ~SelectRequest(); + std::string getTransactionId() const; + void setTransactionId(const std::string &transactionId); + long getPageNumber() const; + void setPageNumber(long pageNumber); + std::string getFilter() const; + void setFilter(const std::string &filter); + std::string getDatabase() const; + void setDatabase(const std::string &database); + long getPageSize() const; + void setPageSize(long pageSize); + std::string getResourceArn() const; + void setResourceArn(const std::string &resourceArn); + std::string getTable() const; + void setTable(const std::string &table); + std::string getSecretArn() const; + void setSecretArn(const std::string &secretArn); + +private: + std::string transactionId_; + long pageNumber_; + std::string filter_; + std::string database_; + long pageSize_; + std::string resourceArn_; + std::string table_; + std::string secretArn_; +}; +} // namespace Model +} // namespace Rds_data +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_RDS_DATA_MODEL_SELECTREQUEST_H_ diff --git a/rds-data/include/alibabacloud/rds-data/model/SelectResult.h b/rds-data/include/alibabacloud/rds-data/model/SelectResult.h new file mode 100644 index 000000000..d788063cf --- /dev/null +++ b/rds-data/include/alibabacloud/rds-data/model/SelectResult.h @@ -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_RDS_DATA_MODEL_SELECTRESULT_H_ +#define ALIBABACLOUD_RDS_DATA_MODEL_SELECTRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Rds_data + { + namespace Model + { + class ALIBABACLOUD_RDS_DATA_EXPORT SelectResult : public ServiceResult + { + public: + struct Data + { + std::vector records; + }; + + + SelectResult(); + explicit SelectResult(const std::string &payload); + ~SelectResult(); + std::string getMessage()const; + Data getData()const; + std::string getCode()const; + bool getSuccess()const; + + protected: + void parse(const std::string &payload); + private: + std::string message_; + Data data_; + std::string code_; + bool success_; + + }; + } + } +} +#endif // !ALIBABACLOUD_RDS_DATA_MODEL_SELECTRESULT_H_ \ No newline at end of file diff --git a/rds-data/include/alibabacloud/rds-data/model/UpdateRequest.h b/rds-data/include/alibabacloud/rds-data/model/UpdateRequest.h new file mode 100644 index 000000000..ed40951e2 --- /dev/null +++ b/rds-data/include/alibabacloud/rds-data/model/UpdateRequest.h @@ -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_RDS_DATA_MODEL_UPDATEREQUEST_H_ +#define ALIBABACLOUD_RDS_DATA_MODEL_UPDATEREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Rds_data { +namespace Model { +class ALIBABACLOUD_RDS_DATA_EXPORT UpdateRequest : public RpcServiceRequest { +public: + UpdateRequest(); + ~UpdateRequest(); + std::string getTransactionId() const; + void setTransactionId(const std::string &transactionId); + std::string getFilter() const; + void setFilter(const std::string &filter); + std::string getDatabase() const; + void setDatabase(const std::string &database); + std::map getRecord() const; + void setRecord(const std::map &record); + std::string getResourceArn() const; + void setResourceArn(const std::string &resourceArn); + std::string getTable() const; + void setTable(const std::string &table); + std::string getSecretArn() const; + void setSecretArn(const std::string &secretArn); + +private: + std::string transactionId_; + std::string filter_; + std::string database_; + std::map record_; + std::string resourceArn_; + std::string table_; + std::string secretArn_; +}; +} // namespace Model +} // namespace Rds_data +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_RDS_DATA_MODEL_UPDATEREQUEST_H_ diff --git a/rds-data/include/alibabacloud/rds-data/model/UpdateResult.h b/rds-data/include/alibabacloud/rds-data/model/UpdateResult.h new file mode 100644 index 000000000..9b0444946 --- /dev/null +++ b/rds-data/include/alibabacloud/rds-data/model/UpdateResult.h @@ -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_RDS_DATA_MODEL_UPDATERESULT_H_ +#define ALIBABACLOUD_RDS_DATA_MODEL_UPDATERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Rds_data + { + namespace Model + { + class ALIBABACLOUD_RDS_DATA_EXPORT UpdateResult : public ServiceResult + { + public: + struct Data + { + long numberOfRecordsUpdated; + }; + + + UpdateResult(); + explicit UpdateResult(const std::string &payload); + ~UpdateResult(); + std::string getMessage()const; + Data getData()const; + std::string getCode()const; + bool getSuccess()const; + + protected: + void parse(const std::string &payload); + private: + std::string message_; + Data data_; + std::string code_; + bool success_; + + }; + } + } +} +#endif // !ALIBABACLOUD_RDS_DATA_MODEL_UPDATERESULT_H_ \ No newline at end of file diff --git a/rds-data/src/Rds-dataClient.cc b/rds-data/src/Rds-dataClient.cc new file mode 100644 index 000000000..53a62257d --- /dev/null +++ b/rds-data/src/Rds-dataClient.cc @@ -0,0 +1,413 @@ +/* + * 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. + */ + +#include +#include + +using namespace AlibabaCloud; +using namespace AlibabaCloud::Location; +using namespace AlibabaCloud::Rds_data; +using namespace AlibabaCloud::Rds_data::Model; + +namespace +{ + const std::string SERVICE_NAME = "rds-data"; +} + +Rds_dataClient::Rds_dataClient(const Credentials &credentials, const ClientConfiguration &configuration) : + RpcServiceClient(SERVICE_NAME, std::make_shared(credentials), configuration) +{ + auto locationClient = std::make_shared(credentials, configuration); + endpointProvider_ = std::make_shared(locationClient, configuration.regionId(), SERVICE_NAME, ""); +} + +Rds_dataClient::Rds_dataClient(const std::shared_ptr& credentialsProvider, const ClientConfiguration & configuration) : + RpcServiceClient(SERVICE_NAME, credentialsProvider, configuration) +{ + auto locationClient = std::make_shared(credentialsProvider, configuration); + endpointProvider_ = std::make_shared(locationClient, configuration.regionId(), SERVICE_NAME, ""); +} + +Rds_dataClient::Rds_dataClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) : + RpcServiceClient(SERVICE_NAME, std::make_shared(accessKeyId, accessKeySecret), configuration) +{ + auto locationClient = std::make_shared(accessKeyId, accessKeySecret, configuration); + endpointProvider_ = std::make_shared(locationClient, configuration.regionId(), SERVICE_NAME, ""); +} + +Rds_dataClient::~Rds_dataClient() +{} + +Rds_dataClient::BatchExecuteStatementOutcome Rds_dataClient::batchExecuteStatement(const BatchExecuteStatementRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return BatchExecuteStatementOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return BatchExecuteStatementOutcome(BatchExecuteStatementResult(outcome.result())); + else + return BatchExecuteStatementOutcome(outcome.error()); +} + +void Rds_dataClient::batchExecuteStatementAsync(const BatchExecuteStatementRequest& request, const BatchExecuteStatementAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, batchExecuteStatement(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +Rds_dataClient::BatchExecuteStatementOutcomeCallable Rds_dataClient::batchExecuteStatementCallable(const BatchExecuteStatementRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->batchExecuteStatement(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +Rds_dataClient::BeginTransactionOutcome Rds_dataClient::beginTransaction(const BeginTransactionRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return BeginTransactionOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return BeginTransactionOutcome(BeginTransactionResult(outcome.result())); + else + return BeginTransactionOutcome(outcome.error()); +} + +void Rds_dataClient::beginTransactionAsync(const BeginTransactionRequest& request, const BeginTransactionAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, beginTransaction(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +Rds_dataClient::BeginTransactionOutcomeCallable Rds_dataClient::beginTransactionCallable(const BeginTransactionRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->beginTransaction(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +Rds_dataClient::CommitTransactionOutcome Rds_dataClient::commitTransaction(const CommitTransactionRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return CommitTransactionOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return CommitTransactionOutcome(CommitTransactionResult(outcome.result())); + else + return CommitTransactionOutcome(outcome.error()); +} + +void Rds_dataClient::commitTransactionAsync(const CommitTransactionRequest& request, const CommitTransactionAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, commitTransaction(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +Rds_dataClient::CommitTransactionOutcomeCallable Rds_dataClient::commitTransactionCallable(const CommitTransactionRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->commitTransaction(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +Rds_dataClient::DeleteOutcome Rds_dataClient::delete(const DeleteRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return DeleteOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DeleteOutcome(DeleteResult(outcome.result())); + else + return DeleteOutcome(outcome.error()); +} + +void Rds_dataClient::deleteAsync(const DeleteRequest& request, const DeleteAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, delete(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +Rds_dataClient::DeleteOutcomeCallable Rds_dataClient::deleteCallable(const DeleteRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->delete(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +Rds_dataClient::ExecuteStatementOutcome Rds_dataClient::executeStatement(const ExecuteStatementRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return ExecuteStatementOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return ExecuteStatementOutcome(ExecuteStatementResult(outcome.result())); + else + return ExecuteStatementOutcome(outcome.error()); +} + +void Rds_dataClient::executeStatementAsync(const ExecuteStatementRequest& request, const ExecuteStatementAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, executeStatement(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +Rds_dataClient::ExecuteStatementOutcomeCallable Rds_dataClient::executeStatementCallable(const ExecuteStatementRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->executeStatement(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +Rds_dataClient::InsertOutcome Rds_dataClient::insert(const InsertRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return InsertOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return InsertOutcome(InsertResult(outcome.result())); + else + return InsertOutcome(outcome.error()); +} + +void Rds_dataClient::insertAsync(const InsertRequest& request, const InsertAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, insert(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +Rds_dataClient::InsertOutcomeCallable Rds_dataClient::insertCallable(const InsertRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->insert(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +Rds_dataClient::InsertListOutcome Rds_dataClient::insertList(const InsertListRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return InsertListOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return InsertListOutcome(InsertListResult(outcome.result())); + else + return InsertListOutcome(outcome.error()); +} + +void Rds_dataClient::insertListAsync(const InsertListRequest& request, const InsertListAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, insertList(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +Rds_dataClient::InsertListOutcomeCallable Rds_dataClient::insertListCallable(const InsertListRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->insertList(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +Rds_dataClient::RollbackTransactionOutcome Rds_dataClient::rollbackTransaction(const RollbackTransactionRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return RollbackTransactionOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return RollbackTransactionOutcome(RollbackTransactionResult(outcome.result())); + else + return RollbackTransactionOutcome(outcome.error()); +} + +void Rds_dataClient::rollbackTransactionAsync(const RollbackTransactionRequest& request, const RollbackTransactionAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, rollbackTransaction(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +Rds_dataClient::RollbackTransactionOutcomeCallable Rds_dataClient::rollbackTransactionCallable(const RollbackTransactionRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->rollbackTransaction(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +Rds_dataClient::SelectOutcome Rds_dataClient::select(const SelectRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return SelectOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return SelectOutcome(SelectResult(outcome.result())); + else + return SelectOutcome(outcome.error()); +} + +void Rds_dataClient::selectAsync(const SelectRequest& request, const SelectAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, select(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +Rds_dataClient::SelectOutcomeCallable Rds_dataClient::selectCallable(const SelectRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->select(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +Rds_dataClient::UpdateOutcome Rds_dataClient::update(const UpdateRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return UpdateOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return UpdateOutcome(UpdateResult(outcome.result())); + else + return UpdateOutcome(outcome.error()); +} + +void Rds_dataClient::updateAsync(const UpdateRequest& request, const UpdateAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, update(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +Rds_dataClient::UpdateOutcomeCallable Rds_dataClient::updateCallable(const UpdateRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->update(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + diff --git a/rds-data/src/model/BatchExecuteStatementRequest.cc b/rds-data/src/model/BatchExecuteStatementRequest.cc new file mode 100644 index 000000000..1c6373c12 --- /dev/null +++ b/rds-data/src/model/BatchExecuteStatementRequest.cc @@ -0,0 +1,92 @@ +/* + * 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. + */ + +#include + +using AlibabaCloud::Rds_data::Model::BatchExecuteStatementRequest; + +BatchExecuteStatementRequest::BatchExecuteStatementRequest() + : RpcServiceRequest("rds-data", "2022-03-30", "BatchExecuteStatement") { + setMethod(HttpRequest::Method::Post); +} + +BatchExecuteStatementRequest::~BatchExecuteStatementRequest() {} + +std::vector> BatchExecuteStatementRequest::getParameterSets() const { + return parameterSets_; +} + +void BatchExecuteStatementRequest::setParameterSets(const std::vector> ¶meterSets) { + parameterSets_ = parameterSets; + for(int dep1 = 0; dep1 != parameterSets.size(); dep1++) { + for(int dep2 = 0; dep2 != parameterSets[dep1].size(); dep2++) { + setBodyParameter(std::string("ParameterSets") + "." + std::to_string(dep1 + 1) + "." + std::to_string(dep2 + 1) + ".Name", parameterSets[dep1][dep2].name); + setBodyParameter(std::string("ParameterSets") + "." + std::to_string(dep1 + 1) + "." + std::to_string(dep2 + 1) + ".TypeHint", parameterSets[dep1][dep2].typeHint); + setBodyParameter(std::string("ParameterSets") + "." + std::to_string(dep1 + 1) + "." + std::to_string(dep2 + 1) + ".Value.ArrayValue", parameterSets[dep1][dep2].value.arrayValue); + setBodyParameter(std::string("ParameterSets") + "." + std::to_string(dep1 + 1) + "." + std::to_string(dep2 + 1) + ".Value.BlobValue", parameterSets[dep1][dep2].value.blobValue); + setBodyParameter(std::string("ParameterSets") + "." + std::to_string(dep1 + 1) + "." + std::to_string(dep2 + 1) + ".Value.BooleanValue", parameterSets[dep1][dep2].value.booleanValue ? "true" : "false"); + setBodyParameter(std::string("ParameterSets") + "." + std::to_string(dep1 + 1) + "." + std::to_string(dep2 + 1) + ".Value.IsNull", parameterSets[dep1][dep2].value.isNull ? "true" : "false"); + setBodyParameter(std::string("ParameterSets") + "." + std::to_string(dep1 + 1) + "." + std::to_string(dep2 + 1) + ".Value.LongValue", std::to_string(parameterSets[dep1][dep2].value.longValue)); + setBodyParameter(std::string("ParameterSets") + "." + std::to_string(dep1 + 1) + "." + std::to_string(dep2 + 1) + ".Value.StringValue", parameterSets[dep1][dep2].value.stringValue); + } + } +} + +std::string BatchExecuteStatementRequest::getTransactionId() const { + return transactionId_; +} + +void BatchExecuteStatementRequest::setTransactionId(const std::string &transactionId) { + transactionId_ = transactionId; + setBodyParameter(std::string("TransactionId"), transactionId); +} + +std::string BatchExecuteStatementRequest::getSql() const { + return sql_; +} + +void BatchExecuteStatementRequest::setSql(const std::string &sql) { + sql_ = sql; + setBodyParameter(std::string("Sql"), sql); +} + +std::string BatchExecuteStatementRequest::getDatabase() const { + return database_; +} + +void BatchExecuteStatementRequest::setDatabase(const std::string &database) { + database_ = database; + setBodyParameter(std::string("Database"), database); +} + +std::string BatchExecuteStatementRequest::getResourceArn() const { + return resourceArn_; +} + +void BatchExecuteStatementRequest::setResourceArn(const std::string &resourceArn) { + resourceArn_ = resourceArn; + setBodyParameter(std::string("ResourceArn"), resourceArn); +} + +std::string BatchExecuteStatementRequest::getSecretArn() const { + return secretArn_; +} + +void BatchExecuteStatementRequest::setSecretArn(const std::string &secretArn) { + secretArn_ = secretArn; + setBodyParameter(std::string("SecretArn"), secretArn); +} + diff --git a/rds-data/src/model/BatchExecuteStatementResult.cc b/rds-data/src/model/BatchExecuteStatementResult.cc new file mode 100644 index 000000000..ee88f3906 --- /dev/null +++ b/rds-data/src/model/BatchExecuteStatementResult.cc @@ -0,0 +1,44 @@ +/* + * 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. + */ + +#include +#include + +using namespace AlibabaCloud::Rds_data; +using namespace AlibabaCloud::Rds_data::Model; + +BatchExecuteStatementResult::BatchExecuteStatementResult() : + ServiceResult() +{} + +BatchExecuteStatementResult::BatchExecuteStatementResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +BatchExecuteStatementResult::~BatchExecuteStatementResult() +{} + +void BatchExecuteStatementResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + +} + diff --git a/rds-data/src/model/BeginTransactionRequest.cc b/rds-data/src/model/BeginTransactionRequest.cc new file mode 100644 index 000000000..5f8c94a06 --- /dev/null +++ b/rds-data/src/model/BeginTransactionRequest.cc @@ -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. + */ + +#include + +using AlibabaCloud::Rds_data::Model::BeginTransactionRequest; + +BeginTransactionRequest::BeginTransactionRequest() + : RpcServiceRequest("rds-data", "2022-03-30", "BeginTransaction") { + setMethod(HttpRequest::Method::Post); +} + +BeginTransactionRequest::~BeginTransactionRequest() {} + +std::string BeginTransactionRequest::getDatabase() const { + return database_; +} + +void BeginTransactionRequest::setDatabase(const std::string &database) { + database_ = database; + setBodyParameter(std::string("Database"), database); +} + +std::string BeginTransactionRequest::getResourceArn() const { + return resourceArn_; +} + +void BeginTransactionRequest::setResourceArn(const std::string &resourceArn) { + resourceArn_ = resourceArn; + setBodyParameter(std::string("ResourceArn"), resourceArn); +} + +std::string BeginTransactionRequest::getSecretArn() const { + return secretArn_; +} + +void BeginTransactionRequest::setSecretArn(const std::string &secretArn) { + secretArn_ = secretArn; + setBodyParameter(std::string("SecretArn"), secretArn); +} + diff --git a/rds-data/src/model/BeginTransactionResult.cc b/rds-data/src/model/BeginTransactionResult.cc new file mode 100644 index 000000000..5a729bf52 --- /dev/null +++ b/rds-data/src/model/BeginTransactionResult.cc @@ -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. + */ + +#include +#include + +using namespace AlibabaCloud::Rds_data; +using namespace AlibabaCloud::Rds_data::Model; + +BeginTransactionResult::BeginTransactionResult() : + ServiceResult() +{} + +BeginTransactionResult::BeginTransactionResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +BeginTransactionResult::~BeginTransactionResult() +{} + +void BeginTransactionResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto dataNode = value["Data"]; + if(!dataNode["TransactionId"].isNull()) + data_.transactionId = dataNode["TransactionId"].asString(); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + if(!value["Code"].isNull()) + code_ = value["Code"].asString(); + if(!value["Message"].isNull()) + message_ = value["Message"].asString(); + +} + +std::string BeginTransactionResult::getMessage()const +{ + return message_; +} + +BeginTransactionResult::Data BeginTransactionResult::getData()const +{ + return data_; +} + +std::string BeginTransactionResult::getCode()const +{ + return code_; +} + +bool BeginTransactionResult::getSuccess()const +{ + return success_; +} + diff --git a/rds-data/src/model/CommitTransactionRequest.cc b/rds-data/src/model/CommitTransactionRequest.cc new file mode 100644 index 000000000..ac85af7bd --- /dev/null +++ b/rds-data/src/model/CommitTransactionRequest.cc @@ -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. + */ + +#include + +using AlibabaCloud::Rds_data::Model::CommitTransactionRequest; + +CommitTransactionRequest::CommitTransactionRequest() + : RpcServiceRequest("rds-data", "2022-03-30", "CommitTransaction") { + setMethod(HttpRequest::Method::Post); +} + +CommitTransactionRequest::~CommitTransactionRequest() {} + +std::string CommitTransactionRequest::getTransactionId() const { + return transactionId_; +} + +void CommitTransactionRequest::setTransactionId(const std::string &transactionId) { + transactionId_ = transactionId; + setBodyParameter(std::string("TransactionId"), transactionId); +} + +std::string CommitTransactionRequest::getResourceArn() const { + return resourceArn_; +} + +void CommitTransactionRequest::setResourceArn(const std::string &resourceArn) { + resourceArn_ = resourceArn; + setBodyParameter(std::string("ResourceArn"), resourceArn); +} + +std::string CommitTransactionRequest::getSecretArn() const { + return secretArn_; +} + +void CommitTransactionRequest::setSecretArn(const std::string &secretArn) { + secretArn_ = secretArn; + setBodyParameter(std::string("SecretArn"), secretArn); +} + diff --git a/rds-data/src/model/CommitTransactionResult.cc b/rds-data/src/model/CommitTransactionResult.cc new file mode 100644 index 000000000..3ea548b3e --- /dev/null +++ b/rds-data/src/model/CommitTransactionResult.cc @@ -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. + */ + +#include +#include + +using namespace AlibabaCloud::Rds_data; +using namespace AlibabaCloud::Rds_data::Model; + +CommitTransactionResult::CommitTransactionResult() : + ServiceResult() +{} + +CommitTransactionResult::CommitTransactionResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +CommitTransactionResult::~CommitTransactionResult() +{} + +void CommitTransactionResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto dataNode = value["Data"]; + if(!dataNode["TransactionStatus"].isNull()) + data_.transactionStatus = dataNode["TransactionStatus"].asString(); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + if(!value["Code"].isNull()) + code_ = value["Code"].asString(); + if(!value["Message"].isNull()) + message_ = value["Message"].asString(); + +} + +std::string CommitTransactionResult::getMessage()const +{ + return message_; +} + +CommitTransactionResult::Data CommitTransactionResult::getData()const +{ + return data_; +} + +std::string CommitTransactionResult::getCode()const +{ + return code_; +} + +bool CommitTransactionResult::getSuccess()const +{ + return success_; +} + diff --git a/rds-data/src/model/DeleteRequest.cc b/rds-data/src/model/DeleteRequest.cc new file mode 100644 index 000000000..a10a211e6 --- /dev/null +++ b/rds-data/src/model/DeleteRequest.cc @@ -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. + */ + +#include + +using AlibabaCloud::Rds_data::Model::DeleteRequest; + +DeleteRequest::DeleteRequest() + : RpcServiceRequest("rds-data", "2022-03-30", "Delete") { + setMethod(HttpRequest::Method::Post); +} + +DeleteRequest::~DeleteRequest() {} + +std::string DeleteRequest::getTransactionId() const { + return transactionId_; +} + +void DeleteRequest::setTransactionId(const std::string &transactionId) { + transactionId_ = transactionId; + setBodyParameter(std::string("TransactionId"), transactionId); +} + +std::string DeleteRequest::getFilter() const { + return filter_; +} + +void DeleteRequest::setFilter(const std::string &filter) { + filter_ = filter; + setBodyParameter(std::string("Filter"), filter); +} + +std::string DeleteRequest::getDatabase() const { + return database_; +} + +void DeleteRequest::setDatabase(const std::string &database) { + database_ = database; + setBodyParameter(std::string("Database"), database); +} + +std::string DeleteRequest::getResourceArn() const { + return resourceArn_; +} + +void DeleteRequest::setResourceArn(const std::string &resourceArn) { + resourceArn_ = resourceArn; + setBodyParameter(std::string("ResourceArn"), resourceArn); +} + +std::string DeleteRequest::getTable() const { + return table_; +} + +void DeleteRequest::setTable(const std::string &table) { + table_ = table; + setBodyParameter(std::string("Table"), table); +} + +std::string DeleteRequest::getSecretArn() const { + return secretArn_; +} + +void DeleteRequest::setSecretArn(const std::string &secretArn) { + secretArn_ = secretArn; + setBodyParameter(std::string("SecretArn"), secretArn); +} + diff --git a/rds-data/src/model/DeleteResult.cc b/rds-data/src/model/DeleteResult.cc new file mode 100644 index 000000000..2fe6d8dce --- /dev/null +++ b/rds-data/src/model/DeleteResult.cc @@ -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. + */ + +#include +#include + +using namespace AlibabaCloud::Rds_data; +using namespace AlibabaCloud::Rds_data::Model; + +DeleteResult::DeleteResult() : + ServiceResult() +{} + +DeleteResult::DeleteResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DeleteResult::~DeleteResult() +{} + +void DeleteResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto dataNode = value["Data"]; + if(!dataNode["NumberOfRecordsUpdated"].isNull()) + data_.numberOfRecordsUpdated = std::stol(dataNode["NumberOfRecordsUpdated"].asString()); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + if(!value["Code"].isNull()) + code_ = value["Code"].asString(); + if(!value["Message"].isNull()) + message_ = value["Message"].asString(); + +} + +std::string DeleteResult::getMessage()const +{ + return message_; +} + +DeleteResult::Data DeleteResult::getData()const +{ + return data_; +} + +std::string DeleteResult::getCode()const +{ + return code_; +} + +bool DeleteResult::getSuccess()const +{ + return success_; +} + diff --git a/rds-data/src/model/ExecuteStatementRequest.cc b/rds-data/src/model/ExecuteStatementRequest.cc new file mode 100644 index 000000000..dad2e4697 --- /dev/null +++ b/rds-data/src/model/ExecuteStatementRequest.cc @@ -0,0 +1,127 @@ +/* + * 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. + */ + +#include + +using AlibabaCloud::Rds_data::Model::ExecuteStatementRequest; + +ExecuteStatementRequest::ExecuteStatementRequest() + : RpcServiceRequest("rds-data", "2022-03-30", "ExecuteStatement") { + setMethod(HttpRequest::Method::Post); +} + +ExecuteStatementRequest::~ExecuteStatementRequest() {} + +bool ExecuteStatementRequest::getIncludeResultMetadata() const { + return includeResultMetadata_; +} + +void ExecuteStatementRequest::setIncludeResultMetadata(bool includeResultMetadata) { + includeResultMetadata_ = includeResultMetadata; + setBodyParameter(std::string("IncludeResultMetadata"), includeResultMetadata ? "true" : "false"); +} + +std::string ExecuteStatementRequest::getFormatRecordsAs() const { + return formatRecordsAs_; +} + +void ExecuteStatementRequest::setFormatRecordsAs(const std::string &formatRecordsAs) { + formatRecordsAs_ = formatRecordsAs; + setBodyParameter(std::string("FormatRecordsAs"), formatRecordsAs); +} + +std::string ExecuteStatementRequest::getTransactionId() const { + return transactionId_; +} + +void ExecuteStatementRequest::setTransactionId(const std::string &transactionId) { + transactionId_ = transactionId; + setBodyParameter(std::string("TransactionId"), transactionId); +} + +std::string ExecuteStatementRequest::getSql() const { + return sql_; +} + +void ExecuteStatementRequest::setSql(const std::string &sql) { + sql_ = sql; + setBodyParameter(std::string("Sql"), sql); +} + +ExecuteStatementRequest::ResultSetOptions ExecuteStatementRequest::getResultSetOptions() const { + return resultSetOptions_; +} + +void ExecuteStatementRequest::setResultSetOptions(const ExecuteStatementRequest::ResultSetOptions &resultSetOptions) { + resultSetOptions_ = resultSetOptions; + setBodyParameter(std::string("ResultSetOptions") + ".DecimalReturnType", resultSetOptions.decimalReturnType); + setBodyParameter(std::string("ResultSetOptions") + ".LongReturnType", resultSetOptions.longReturnType); +} + +std::string ExecuteStatementRequest::getDatabase() const { + return database_; +} + +void ExecuteStatementRequest::setDatabase(const std::string &database) { + database_ = database; + setBodyParameter(std::string("Database"), database); +} + +std::string ExecuteStatementRequest::getResourceArn() const { + return resourceArn_; +} + +void ExecuteStatementRequest::setResourceArn(const std::string &resourceArn) { + resourceArn_ = resourceArn; + setBodyParameter(std::string("ResourceArn"), resourceArn); +} + +std::vector ExecuteStatementRequest::getParameters() const { + return parameters_; +} + +void ExecuteStatementRequest::setParameters(const std::vector ¶meters) { + parameters_ = parameters; + for(int dep1 = 0; dep1 != parameters.size(); dep1++) { + setBodyParameter(std::string("Parameters") + "." + std::to_string(dep1 + 1) + ".Name", parameters[dep1].name); + setBodyParameter(std::string("Parameters") + "." + std::to_string(dep1 + 1) + ".TypeHint", parameters[dep1].typeHint); + setBodyParameter(std::string("Parameters") + "." + std::to_string(dep1 + 1) + ".Value.ArrayValue", parameters[dep1].value.arrayValue); + setBodyParameter(std::string("Parameters") + "." + std::to_string(dep1 + 1) + ".Value.BlobValue", parameters[dep1].value.blobValue); + setBodyParameter(std::string("Parameters") + "." + std::to_string(dep1 + 1) + ".Value.BooleanValue", parameters[dep1].value.booleanValue ? "true" : "false"); + setBodyParameter(std::string("Parameters") + "." + std::to_string(dep1 + 1) + ".Value.IsNull", parameters[dep1].value.isNull ? "true" : "false"); + setBodyParameter(std::string("Parameters") + "." + std::to_string(dep1 + 1) + ".Value.LongValue", std::to_string(parameters[dep1].value.longValue)); + setBodyParameter(std::string("Parameters") + "." + std::to_string(dep1 + 1) + ".Value.StringValue", parameters[dep1].value.stringValue); + } +} + +bool ExecuteStatementRequest::getContinueAfterTimeout() const { + return continueAfterTimeout_; +} + +void ExecuteStatementRequest::setContinueAfterTimeout(bool continueAfterTimeout) { + continueAfterTimeout_ = continueAfterTimeout; + setBodyParameter(std::string("ContinueAfterTimeout"), continueAfterTimeout ? "true" : "false"); +} + +std::string ExecuteStatementRequest::getSecretArn() const { + return secretArn_; +} + +void ExecuteStatementRequest::setSecretArn(const std::string &secretArn) { + secretArn_ = secretArn; + setBodyParameter(std::string("SecretArn"), secretArn); +} + diff --git a/rds-data/src/model/ExecuteStatementResult.cc b/rds-data/src/model/ExecuteStatementResult.cc new file mode 100644 index 000000000..56e4affac --- /dev/null +++ b/rds-data/src/model/ExecuteStatementResult.cc @@ -0,0 +1,44 @@ +/* + * 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. + */ + +#include +#include + +using namespace AlibabaCloud::Rds_data; +using namespace AlibabaCloud::Rds_data::Model; + +ExecuteStatementResult::ExecuteStatementResult() : + ServiceResult() +{} + +ExecuteStatementResult::ExecuteStatementResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +ExecuteStatementResult::~ExecuteStatementResult() +{} + +void ExecuteStatementResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + +} + diff --git a/rds-data/src/model/InsertListRequest.cc b/rds-data/src/model/InsertListRequest.cc new file mode 100644 index 000000000..244d2e612 --- /dev/null +++ b/rds-data/src/model/InsertListRequest.cc @@ -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. + */ + +#include + +using AlibabaCloud::Rds_data::Model::InsertListRequest; + +InsertListRequest::InsertListRequest() + : RpcServiceRequest("rds-data", "2022-03-30", "InsertList") { + setMethod(HttpRequest::Method::Post); +} + +InsertListRequest::~InsertListRequest() {} + +std::vector> InsertListRequest::getRecords() const { + return records_; +} + +void InsertListRequest::setRecords(const std::vector> &records) { + records_ = records; + for(int dep1 = 0; dep1 != records.size(); dep1++) { + for(auto const &iter2 : records[dep1]) { + setBodyParameter(std::string("Records") + "." + std::to_string(dep1 + 1) + "." + iter2.first, std::to_string(iter2.second)); + } + } +} + +std::string InsertListRequest::getTransactionId() const { + return transactionId_; +} + +void InsertListRequest::setTransactionId(const std::string &transactionId) { + transactionId_ = transactionId; + setBodyParameter(std::string("TransactionId"), transactionId); +} + +std::string InsertListRequest::getDatabase() const { + return database_; +} + +void InsertListRequest::setDatabase(const std::string &database) { + database_ = database; + setBodyParameter(std::string("Database"), database); +} + +std::string InsertListRequest::getResourceArn() const { + return resourceArn_; +} + +void InsertListRequest::setResourceArn(const std::string &resourceArn) { + resourceArn_ = resourceArn; + setBodyParameter(std::string("ResourceArn"), resourceArn); +} + +std::string InsertListRequest::getTable() const { + return table_; +} + +void InsertListRequest::setTable(const std::string &table) { + table_ = table; + setBodyParameter(std::string("Table"), table); +} + +std::string InsertListRequest::getSecretArn() const { + return secretArn_; +} + +void InsertListRequest::setSecretArn(const std::string &secretArn) { + secretArn_ = secretArn; + setBodyParameter(std::string("SecretArn"), secretArn); +} + diff --git a/rds-data/src/model/InsertListResult.cc b/rds-data/src/model/InsertListResult.cc new file mode 100644 index 000000000..832679563 --- /dev/null +++ b/rds-data/src/model/InsertListResult.cc @@ -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. + */ + +#include +#include + +using namespace AlibabaCloud::Rds_data; +using namespace AlibabaCloud::Rds_data::Model; + +InsertListResult::InsertListResult() : + ServiceResult() +{} + +InsertListResult::InsertListResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +InsertListResult::~InsertListResult() +{} + +void InsertListResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto dataNode = value["Data"]; + if(!dataNode["NumberOfRecordsUpdated"].isNull()) + data_.numberOfRecordsUpdated = std::stol(dataNode["NumberOfRecordsUpdated"].asString()); + auto allAutoIncrementKeys = dataNode["AutoIncrementKeys"]["null"]; + for (auto value : allAutoIncrementKeys) + data_.autoIncrementKeys.push_back(value.asString()); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + if(!value["Code"].isNull()) + code_ = value["Code"].asString(); + if(!value["Message"].isNull()) + message_ = value["Message"].asString(); + +} + +std::string InsertListResult::getMessage()const +{ + return message_; +} + +InsertListResult::Data InsertListResult::getData()const +{ + return data_; +} + +std::string InsertListResult::getCode()const +{ + return code_; +} + +bool InsertListResult::getSuccess()const +{ + return success_; +} + diff --git a/rds-data/src/model/InsertRequest.cc b/rds-data/src/model/InsertRequest.cc new file mode 100644 index 000000000..fb657ffbe --- /dev/null +++ b/rds-data/src/model/InsertRequest.cc @@ -0,0 +1,83 @@ +/* + * 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. + */ + +#include + +using AlibabaCloud::Rds_data::Model::InsertRequest; + +InsertRequest::InsertRequest() + : RpcServiceRequest("rds-data", "2022-03-30", "Insert") { + setMethod(HttpRequest::Method::Post); +} + +InsertRequest::~InsertRequest() {} + +std::string InsertRequest::getTransactionId() const { + return transactionId_; +} + +void InsertRequest::setTransactionId(const std::string &transactionId) { + transactionId_ = transactionId; + setBodyParameter(std::string("TransactionId"), transactionId); +} + +std::string InsertRequest::getDatabase() const { + return database_; +} + +void InsertRequest::setDatabase(const std::string &database) { + database_ = database; + setBodyParameter(std::string("Database"), database); +} + +std::map InsertRequest::getRecord() const { + return record_; +} + +void InsertRequest::setRecord(const std::map &record) { + record_ = record; + for(auto const &iter1 : record) { + setBodyParameter(std::string("Record") + "." + iter1.first, std::to_string(iter1.second)); + } +} + +std::string InsertRequest::getResourceArn() const { + return resourceArn_; +} + +void InsertRequest::setResourceArn(const std::string &resourceArn) { + resourceArn_ = resourceArn; + setBodyParameter(std::string("ResourceArn"), resourceArn); +} + +std::string InsertRequest::getTable() const { + return table_; +} + +void InsertRequest::setTable(const std::string &table) { + table_ = table; + setBodyParameter(std::string("Table"), table); +} + +std::string InsertRequest::getSecretArn() const { + return secretArn_; +} + +void InsertRequest::setSecretArn(const std::string &secretArn) { + secretArn_ = secretArn; + setBodyParameter(std::string("SecretArn"), secretArn); +} + diff --git a/rds-data/src/model/InsertResult.cc b/rds-data/src/model/InsertResult.cc new file mode 100644 index 000000000..a80fde870 --- /dev/null +++ b/rds-data/src/model/InsertResult.cc @@ -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. + */ + +#include +#include + +using namespace AlibabaCloud::Rds_data; +using namespace AlibabaCloud::Rds_data::Model; + +InsertResult::InsertResult() : + ServiceResult() +{} + +InsertResult::InsertResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +InsertResult::~InsertResult() +{} + +void InsertResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto dataNode = value["Data"]; + if(!dataNode["NumberOfRecordsUpdated"].isNull()) + data_.numberOfRecordsUpdated = std::stol(dataNode["NumberOfRecordsUpdated"].asString()); + if(!dataNode["AutoIncrementKey"].isNull()) + data_.autoIncrementKey = std::stol(dataNode["AutoIncrementKey"].asString()); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + if(!value["Code"].isNull()) + code_ = value["Code"].asString(); + if(!value["Message"].isNull()) + message_ = value["Message"].asString(); + +} + +std::string InsertResult::getMessage()const +{ + return message_; +} + +InsertResult::Data InsertResult::getData()const +{ + return data_; +} + +std::string InsertResult::getCode()const +{ + return code_; +} + +bool InsertResult::getSuccess()const +{ + return success_; +} + diff --git a/rds-data/src/model/RollbackTransactionRequest.cc b/rds-data/src/model/RollbackTransactionRequest.cc new file mode 100644 index 000000000..0edb33c06 --- /dev/null +++ b/rds-data/src/model/RollbackTransactionRequest.cc @@ -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. + */ + +#include + +using AlibabaCloud::Rds_data::Model::RollbackTransactionRequest; + +RollbackTransactionRequest::RollbackTransactionRequest() + : RpcServiceRequest("rds-data", "2022-03-30", "RollbackTransaction") { + setMethod(HttpRequest::Method::Post); +} + +RollbackTransactionRequest::~RollbackTransactionRequest() {} + +std::string RollbackTransactionRequest::getTransactionId() const { + return transactionId_; +} + +void RollbackTransactionRequest::setTransactionId(const std::string &transactionId) { + transactionId_ = transactionId; + setBodyParameter(std::string("TransactionId"), transactionId); +} + +std::string RollbackTransactionRequest::getResourceArn() const { + return resourceArn_; +} + +void RollbackTransactionRequest::setResourceArn(const std::string &resourceArn) { + resourceArn_ = resourceArn; + setBodyParameter(std::string("ResourceArn"), resourceArn); +} + +std::string RollbackTransactionRequest::getSecretArn() const { + return secretArn_; +} + +void RollbackTransactionRequest::setSecretArn(const std::string &secretArn) { + secretArn_ = secretArn; + setBodyParameter(std::string("SecretArn"), secretArn); +} + diff --git a/rds-data/src/model/RollbackTransactionResult.cc b/rds-data/src/model/RollbackTransactionResult.cc new file mode 100644 index 000000000..bf3646d7e --- /dev/null +++ b/rds-data/src/model/RollbackTransactionResult.cc @@ -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. + */ + +#include +#include + +using namespace AlibabaCloud::Rds_data; +using namespace AlibabaCloud::Rds_data::Model; + +RollbackTransactionResult::RollbackTransactionResult() : + ServiceResult() +{} + +RollbackTransactionResult::RollbackTransactionResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +RollbackTransactionResult::~RollbackTransactionResult() +{} + +void RollbackTransactionResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto dataNode = value["Data"]; + if(!dataNode["TransactionStatus"].isNull()) + data_.transactionStatus = dataNode["TransactionStatus"].asString(); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + if(!value["Code"].isNull()) + code_ = value["Code"].asString(); + if(!value["Message"].isNull()) + message_ = value["Message"].asString(); + +} + +std::string RollbackTransactionResult::getMessage()const +{ + return message_; +} + +RollbackTransactionResult::Data RollbackTransactionResult::getData()const +{ + return data_; +} + +std::string RollbackTransactionResult::getCode()const +{ + return code_; +} + +bool RollbackTransactionResult::getSuccess()const +{ + return success_; +} + diff --git a/rds-data/src/model/SelectRequest.cc b/rds-data/src/model/SelectRequest.cc new file mode 100644 index 000000000..ffe6154ea --- /dev/null +++ b/rds-data/src/model/SelectRequest.cc @@ -0,0 +1,99 @@ +/* + * 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. + */ + +#include + +using AlibabaCloud::Rds_data::Model::SelectRequest; + +SelectRequest::SelectRequest() + : RpcServiceRequest("rds-data", "2022-03-30", "Select") { + setMethod(HttpRequest::Method::Post); +} + +SelectRequest::~SelectRequest() {} + +std::string SelectRequest::getTransactionId() const { + return transactionId_; +} + +void SelectRequest::setTransactionId(const std::string &transactionId) { + transactionId_ = transactionId; + setBodyParameter(std::string("TransactionId"), transactionId); +} + +long SelectRequest::getPageNumber() const { + return pageNumber_; +} + +void SelectRequest::setPageNumber(long pageNumber) { + pageNumber_ = pageNumber; + setBodyParameter(std::string("PageNumber"), std::to_string(pageNumber)); +} + +std::string SelectRequest::getFilter() const { + return filter_; +} + +void SelectRequest::setFilter(const std::string &filter) { + filter_ = filter; + setBodyParameter(std::string("Filter"), filter); +} + +std::string SelectRequest::getDatabase() const { + return database_; +} + +void SelectRequest::setDatabase(const std::string &database) { + database_ = database; + setBodyParameter(std::string("Database"), database); +} + +long SelectRequest::getPageSize() const { + return pageSize_; +} + +void SelectRequest::setPageSize(long pageSize) { + pageSize_ = pageSize; + setBodyParameter(std::string("PageSize"), std::to_string(pageSize)); +} + +std::string SelectRequest::getResourceArn() const { + return resourceArn_; +} + +void SelectRequest::setResourceArn(const std::string &resourceArn) { + resourceArn_ = resourceArn; + setBodyParameter(std::string("ResourceArn"), resourceArn); +} + +std::string SelectRequest::getTable() const { + return table_; +} + +void SelectRequest::setTable(const std::string &table) { + table_ = table; + setBodyParameter(std::string("Table"), table); +} + +std::string SelectRequest::getSecretArn() const { + return secretArn_; +} + +void SelectRequest::setSecretArn(const std::string &secretArn) { + secretArn_ = secretArn; + setBodyParameter(std::string("SecretArn"), secretArn); +} + diff --git a/rds-data/src/model/SelectResult.cc b/rds-data/src/model/SelectResult.cc new file mode 100644 index 000000000..78a3fda25 --- /dev/null +++ b/rds-data/src/model/SelectResult.cc @@ -0,0 +1,74 @@ +/* + * 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. + */ + +#include +#include + +using namespace AlibabaCloud::Rds_data; +using namespace AlibabaCloud::Rds_data::Model; + +SelectResult::SelectResult() : + ServiceResult() +{} + +SelectResult::SelectResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +SelectResult::~SelectResult() +{} + +void SelectResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto dataNode = value["Data"]; + auto allRecords = dataNode["Records"]["null"]; + for (auto value : allRecords) + data_.records.push_back(value.asString()); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + if(!value["Code"].isNull()) + code_ = value["Code"].asString(); + if(!value["Message"].isNull()) + message_ = value["Message"].asString(); + +} + +std::string SelectResult::getMessage()const +{ + return message_; +} + +SelectResult::Data SelectResult::getData()const +{ + return data_; +} + +std::string SelectResult::getCode()const +{ + return code_; +} + +bool SelectResult::getSuccess()const +{ + return success_; +} + diff --git a/rds-data/src/model/UpdateRequest.cc b/rds-data/src/model/UpdateRequest.cc new file mode 100644 index 000000000..489dddd9a --- /dev/null +++ b/rds-data/src/model/UpdateRequest.cc @@ -0,0 +1,92 @@ +/* + * 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. + */ + +#include + +using AlibabaCloud::Rds_data::Model::UpdateRequest; + +UpdateRequest::UpdateRequest() + : RpcServiceRequest("rds-data", "2022-03-30", "Update") { + setMethod(HttpRequest::Method::Post); +} + +UpdateRequest::~UpdateRequest() {} + +std::string UpdateRequest::getTransactionId() const { + return transactionId_; +} + +void UpdateRequest::setTransactionId(const std::string &transactionId) { + transactionId_ = transactionId; + setBodyParameter(std::string("TransactionId"), transactionId); +} + +std::string UpdateRequest::getFilter() const { + return filter_; +} + +void UpdateRequest::setFilter(const std::string &filter) { + filter_ = filter; + setBodyParameter(std::string("Filter"), filter); +} + +std::string UpdateRequest::getDatabase() const { + return database_; +} + +void UpdateRequest::setDatabase(const std::string &database) { + database_ = database; + setBodyParameter(std::string("Database"), database); +} + +std::map UpdateRequest::getRecord() const { + return record_; +} + +void UpdateRequest::setRecord(const std::map &record) { + record_ = record; + for(auto const &iter1 : record) { + setBodyParameter(std::string("Record") + "." + iter1.first, std::to_string(iter1.second)); + } +} + +std::string UpdateRequest::getResourceArn() const { + return resourceArn_; +} + +void UpdateRequest::setResourceArn(const std::string &resourceArn) { + resourceArn_ = resourceArn; + setBodyParameter(std::string("ResourceArn"), resourceArn); +} + +std::string UpdateRequest::getTable() const { + return table_; +} + +void UpdateRequest::setTable(const std::string &table) { + table_ = table; + setBodyParameter(std::string("Table"), table); +} + +std::string UpdateRequest::getSecretArn() const { + return secretArn_; +} + +void UpdateRequest::setSecretArn(const std::string &secretArn) { + secretArn_ = secretArn; + setBodyParameter(std::string("SecretArn"), secretArn); +} + diff --git a/rds-data/src/model/UpdateResult.cc b/rds-data/src/model/UpdateResult.cc new file mode 100644 index 000000000..f0a2b5c9e --- /dev/null +++ b/rds-data/src/model/UpdateResult.cc @@ -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. + */ + +#include +#include + +using namespace AlibabaCloud::Rds_data; +using namespace AlibabaCloud::Rds_data::Model; + +UpdateResult::UpdateResult() : + ServiceResult() +{} + +UpdateResult::UpdateResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +UpdateResult::~UpdateResult() +{} + +void UpdateResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto dataNode = value["Data"]; + if(!dataNode["NumberOfRecordsUpdated"].isNull()) + data_.numberOfRecordsUpdated = std::stol(dataNode["NumberOfRecordsUpdated"].asString()); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + if(!value["Code"].isNull()) + code_ = value["Code"].asString(); + if(!value["Message"].isNull()) + message_ = value["Message"].asString(); + +} + +std::string UpdateResult::getMessage()const +{ + return message_; +} + +UpdateResult::Data UpdateResult::getData()const +{ + return data_; +} + +std::string UpdateResult::getCode()const +{ + return code_; +} + +bool UpdateResult::getSuccess()const +{ + return success_; +} +