Add some APIs.

VERSION

@@ -1 +1 @@
-1.36.2116
+1.36.2117

quickbi-public/CMakeLists.txt

@@ -71,6 +71,8 @@ set(quickbi-public_public_header_model
 	include/alibabacloud/quickbi-public/model/CreateTicket4CopilotResult.h
 	include/alibabacloud/quickbi-public/model/CreateUserGroupRequest.h
 	include/alibabacloud/quickbi-public/model/CreateUserGroupResult.h
+	include/alibabacloud/quickbi-public/model/CreateWorkspaceRequest.h
+	include/alibabacloud/quickbi-public/model/CreateWorkspaceResult.h
 	include/alibabacloud/quickbi-public/model/DataInterpretationRequest.h
 	include/alibabacloud/quickbi-public/model/DataInterpretationResult.h
 	include/alibabacloud/quickbi-public/model/DataSetBloodRequest.h
@@ -105,6 +107,8 @@ set(quickbi-public_public_header_model
 	include/alibabacloud/quickbi-public/model/GetUserGroupInfoResult.h
 	include/alibabacloud/quickbi-public/model/GetWorksEmbedListRequest.h
 	include/alibabacloud/quickbi-public/model/GetWorksEmbedListResult.h
+	include/alibabacloud/quickbi-public/model/ListAccelerationOfWorkspaceRequest.h
+	include/alibabacloud/quickbi-public/model/ListAccelerationOfWorkspaceResult.h
 	include/alibabacloud/quickbi-public/model/ListApiDatasourceRequest.h
 	include/alibabacloud/quickbi-public/model/ListApiDatasourceResult.h
 	include/alibabacloud/quickbi-public/model/ListByUserGroupIdRequest.h
@@ -145,6 +149,10 @@ set(quickbi-public_public_header_model
 	include/alibabacloud/quickbi-public/model/ModifyApiDatasourceParametersResult.h
 	include/alibabacloud/quickbi-public/model/ModifyCopilotEmbedConfigRequest.h
 	include/alibabacloud/quickbi-public/model/ModifyCopilotEmbedConfigResult.h
+	include/alibabacloud/quickbi-public/model/ModifyDashboardNl2sqlStatusRequest.h
+	include/alibabacloud/quickbi-public/model/ModifyDashboardNl2sqlStatusResult.h
+	include/alibabacloud/quickbi-public/model/QueryAccelerationLogByCubeIdRequest.h
+	include/alibabacloud/quickbi-public/model/QueryAccelerationLogByCubeIdResult.h
 	include/alibabacloud/quickbi-public/model/QueryApprovalInfoRequest.h
 	include/alibabacloud/quickbi-public/model/QueryApprovalInfoResult.h
 	include/alibabacloud/quickbi-public/model/QueryAuditLogRequest.h
@@ -324,6 +332,8 @@ set(quickbi-public_src
 	src/model/CreateTicket4CopilotResult.cc
 	src/model/CreateUserGroupRequest.cc
 	src/model/CreateUserGroupResult.cc
+	src/model/CreateWorkspaceRequest.cc
+	src/model/CreateWorkspaceResult.cc
 	src/model/DataInterpretationRequest.cc
 	src/model/DataInterpretationResult.cc
 	src/model/DataSetBloodRequest.cc
@@ -358,6 +368,8 @@ set(quickbi-public_src
 	src/model/GetUserGroupInfoResult.cc
 	src/model/GetWorksEmbedListRequest.cc
 	src/model/GetWorksEmbedListResult.cc
+	src/model/ListAccelerationOfWorkspaceRequest.cc
+	src/model/ListAccelerationOfWorkspaceResult.cc
 	src/model/ListApiDatasourceRequest.cc
 	src/model/ListApiDatasourceResult.cc
 	src/model/ListByUserGroupIdRequest.cc
@@ -398,6 +410,10 @@ set(quickbi-public_src
 	src/model/ModifyApiDatasourceParametersResult.cc
 	src/model/ModifyCopilotEmbedConfigRequest.cc
 	src/model/ModifyCopilotEmbedConfigResult.cc
+	src/model/ModifyDashboardNl2sqlStatusRequest.cc
+	src/model/ModifyDashboardNl2sqlStatusResult.cc
+	src/model/QueryAccelerationLogByCubeIdRequest.cc
+	src/model/QueryAccelerationLogByCubeIdResult.cc
 	src/model/QueryApprovalInfoRequest.cc
 	src/model/QueryApprovalInfoResult.cc
 	src/model/QueryAuditLogRequest.cc

quickbi-public/include/alibabacloud/quickbi-public/Quickbi_publicClient.h

@@ -72,6 +72,8 @@
 #include "model/CreateTicket4CopilotResult.h"
 #include "model/CreateUserGroupRequest.h"
 #include "model/CreateUserGroupResult.h"
+#include "model/CreateWorkspaceRequest.h"
+#include "model/CreateWorkspaceResult.h"
 #include "model/DataInterpretationRequest.h"
 #include "model/DataInterpretationResult.h"
 #include "model/DataSetBloodRequest.h"
@@ -106,6 +108,8 @@
 #include "model/GetUserGroupInfoResult.h"
 #include "model/GetWorksEmbedListRequest.h"
 #include "model/GetWorksEmbedListResult.h"
+#include "model/ListAccelerationOfWorkspaceRequest.h"
+#include "model/ListAccelerationOfWorkspaceResult.h"
 #include "model/ListApiDatasourceRequest.h"
 #include "model/ListApiDatasourceResult.h"
 #include "model/ListByUserGroupIdRequest.h"
@@ -146,6 +150,10 @@
 #include "model/ModifyApiDatasourceParametersResult.h"
 #include "model/ModifyCopilotEmbedConfigRequest.h"
 #include "model/ModifyCopilotEmbedConfigResult.h"
+#include "model/ModifyDashboardNl2sqlStatusRequest.h"
+#include "model/ModifyDashboardNl2sqlStatusResult.h"
+#include "model/QueryAccelerationLogByCubeIdRequest.h"
+#include "model/QueryAccelerationLogByCubeIdResult.h"
 #include "model/QueryApprovalInfoRequest.h"
 #include "model/QueryApprovalInfoResult.h"
 #include "model/QueryAuditLogRequest.h"
@@ -356,6 +364,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::CreateUserGroupResult> CreateUserGroupOutcome;
 			typedef std::future<CreateUserGroupOutcome> CreateUserGroupOutcomeCallable;
 			typedef std::function<void(const Quickbi_publicClient*, const Model::CreateUserGroupRequest&, const CreateUserGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateUserGroupAsyncHandler;
+			typedef Outcome<Error, Model::CreateWorkspaceResult> CreateWorkspaceOutcome;
+			typedef std::future<CreateWorkspaceOutcome> CreateWorkspaceOutcomeCallable;
+			typedef std::function<void(const Quickbi_publicClient*, const Model::CreateWorkspaceRequest&, const CreateWorkspaceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateWorkspaceAsyncHandler;
 			typedef Outcome<Error, Model::DataInterpretationResult> DataInterpretationOutcome;
 			typedef std::future<DataInterpretationOutcome> DataInterpretationOutcomeCallable;
 			typedef std::function<void(const Quickbi_publicClient*, const Model::DataInterpretationRequest&, const DataInterpretationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DataInterpretationAsyncHandler;
@@ -407,6 +418,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::GetWorksEmbedListResult> GetWorksEmbedListOutcome;
 			typedef std::future<GetWorksEmbedListOutcome> GetWorksEmbedListOutcomeCallable;
 			typedef std::function<void(const Quickbi_publicClient*, const Model::GetWorksEmbedListRequest&, const GetWorksEmbedListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetWorksEmbedListAsyncHandler;
+			typedef Outcome<Error, Model::ListAccelerationOfWorkspaceResult> ListAccelerationOfWorkspaceOutcome;
+			typedef std::future<ListAccelerationOfWorkspaceOutcome> ListAccelerationOfWorkspaceOutcomeCallable;
+			typedef std::function<void(const Quickbi_publicClient*, const Model::ListAccelerationOfWorkspaceRequest&, const ListAccelerationOfWorkspaceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListAccelerationOfWorkspaceAsyncHandler;
 			typedef Outcome<Error, Model::ListApiDatasourceResult> ListApiDatasourceOutcome;
 			typedef std::future<ListApiDatasourceOutcome> ListApiDatasourceOutcomeCallable;
 			typedef std::function<void(const Quickbi_publicClient*, const Model::ListApiDatasourceRequest&, const ListApiDatasourceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListApiDatasourceAsyncHandler;
@@ -467,6 +481,12 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::ModifyCopilotEmbedConfigResult> ModifyCopilotEmbedConfigOutcome;
 			typedef std::future<ModifyCopilotEmbedConfigOutcome> ModifyCopilotEmbedConfigOutcomeCallable;
 			typedef std::function<void(const Quickbi_publicClient*, const Model::ModifyCopilotEmbedConfigRequest&, const ModifyCopilotEmbedConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyCopilotEmbedConfigAsyncHandler;
+			typedef Outcome<Error, Model::ModifyDashboardNl2sqlStatusResult> ModifyDashboardNl2sqlStatusOutcome;
+			typedef std::future<ModifyDashboardNl2sqlStatusOutcome> ModifyDashboardNl2sqlStatusOutcomeCallable;
+			typedef std::function<void(const Quickbi_publicClient*, const Model::ModifyDashboardNl2sqlStatusRequest&, const ModifyDashboardNl2sqlStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyDashboardNl2sqlStatusAsyncHandler;
+			typedef Outcome<Error, Model::QueryAccelerationLogByCubeIdResult> QueryAccelerationLogByCubeIdOutcome;
+			typedef std::future<QueryAccelerationLogByCubeIdOutcome> QueryAccelerationLogByCubeIdOutcomeCallable;
+			typedef std::function<void(const Quickbi_publicClient*, const Model::QueryAccelerationLogByCubeIdRequest&, const QueryAccelerationLogByCubeIdOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryAccelerationLogByCubeIdAsyncHandler;
 			typedef Outcome<Error, Model::QueryApprovalInfoResult> QueryApprovalInfoOutcome;
 			typedef std::future<QueryApprovalInfoOutcome> QueryApprovalInfoOutcomeCallable;
 			typedef std::function<void(const Quickbi_publicClient*, const Model::QueryApprovalInfoRequest&, const QueryApprovalInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryApprovalInfoAsyncHandler;
@@ -736,6 +756,9 @@ namespace AlibabaCloud
 			CreateUserGroupOutcome createUserGroup(const Model::CreateUserGroupRequest &request)const;
 			void createUserGroupAsync(const Model::CreateUserGroupRequest& request, const CreateUserGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateUserGroupOutcomeCallable createUserGroupCallable(const Model::CreateUserGroupRequest& request) const;
+			CreateWorkspaceOutcome createWorkspace(const Model::CreateWorkspaceRequest &request)const;
+			void createWorkspaceAsync(const Model::CreateWorkspaceRequest& request, const CreateWorkspaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateWorkspaceOutcomeCallable createWorkspaceCallable(const Model::CreateWorkspaceRequest& request) const;
 			DataInterpretationOutcome dataInterpretation(const Model::DataInterpretationRequest &request)const;
 			void dataInterpretationAsync(const Model::DataInterpretationRequest& request, const DataInterpretationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DataInterpretationOutcomeCallable dataInterpretationCallable(const Model::DataInterpretationRequest& request) const;
@@ -787,6 +810,9 @@ namespace AlibabaCloud
 			GetWorksEmbedListOutcome getWorksEmbedList(const Model::GetWorksEmbedListRequest &request)const;
 			void getWorksEmbedListAsync(const Model::GetWorksEmbedListRequest& request, const GetWorksEmbedListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetWorksEmbedListOutcomeCallable getWorksEmbedListCallable(const Model::GetWorksEmbedListRequest& request) const;
+			ListAccelerationOfWorkspaceOutcome listAccelerationOfWorkspace(const Model::ListAccelerationOfWorkspaceRequest &request)const;
+			void listAccelerationOfWorkspaceAsync(const Model::ListAccelerationOfWorkspaceRequest& request, const ListAccelerationOfWorkspaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListAccelerationOfWorkspaceOutcomeCallable listAccelerationOfWorkspaceCallable(const Model::ListAccelerationOfWorkspaceRequest& request) const;
 			ListApiDatasourceOutcome listApiDatasource(const Model::ListApiDatasourceRequest &request)const;
 			void listApiDatasourceAsync(const Model::ListApiDatasourceRequest& request, const ListApiDatasourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListApiDatasourceOutcomeCallable listApiDatasourceCallable(const Model::ListApiDatasourceRequest& request) const;
@@ -847,6 +873,12 @@ namespace AlibabaCloud
 			ModifyCopilotEmbedConfigOutcome modifyCopilotEmbedConfig(const Model::ModifyCopilotEmbedConfigRequest &request)const;
 			void modifyCopilotEmbedConfigAsync(const Model::ModifyCopilotEmbedConfigRequest& request, const ModifyCopilotEmbedConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ModifyCopilotEmbedConfigOutcomeCallable modifyCopilotEmbedConfigCallable(const Model::ModifyCopilotEmbedConfigRequest& request) const;
+			ModifyDashboardNl2sqlStatusOutcome modifyDashboardNl2sqlStatus(const Model::ModifyDashboardNl2sqlStatusRequest &request)const;
+			void modifyDashboardNl2sqlStatusAsync(const Model::ModifyDashboardNl2sqlStatusRequest& request, const ModifyDashboardNl2sqlStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ModifyDashboardNl2sqlStatusOutcomeCallable modifyDashboardNl2sqlStatusCallable(const Model::ModifyDashboardNl2sqlStatusRequest& request) const;
+			QueryAccelerationLogByCubeIdOutcome queryAccelerationLogByCubeId(const Model::QueryAccelerationLogByCubeIdRequest &request)const;
+			void queryAccelerationLogByCubeIdAsync(const Model::QueryAccelerationLogByCubeIdRequest& request, const QueryAccelerationLogByCubeIdAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			QueryAccelerationLogByCubeIdOutcomeCallable queryAccelerationLogByCubeIdCallable(const Model::QueryAccelerationLogByCubeIdRequest& request) const;
 			QueryApprovalInfoOutcome queryApprovalInfo(const Model::QueryApprovalInfoRequest &request)const;
 			void queryApprovalInfoAsync(const Model::QueryApprovalInfoRequest& request, const QueryApprovalInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			QueryApprovalInfoOutcomeCallable queryApprovalInfoCallable(const Model::QueryApprovalInfoRequest& request) const;

quickbi-public/include/alibabacloud/quickbi-public/model/CreateWorkspaceRequest.h

@@ -0,0 +1,69 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_CREATEWORKSPACEREQUEST_H_
+#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_CREATEWORKSPACEREQUEST_H_
+
+#include <alibabacloud/quickbi-public/Quickbi_publicExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Quickbi_public {
+namespace Model {
+class ALIBABACLOUD_QUICKBI_PUBLIC_EXPORT CreateWorkspaceRequest : public RpcServiceRequest {
+public:
+	CreateWorkspaceRequest();
+	~CreateWorkspaceRequest();
+	bool getAllowViewAll() const;
+	void setAllowViewAll(bool allowViewAll);
+	std::string getAccessPoint() const;
+	void setAccessPoint(const std::string &accessPoint);
+	std::string getWorkspaceName() const;
+	void setWorkspaceName(const std::string &workspaceName);
+	std::string getWorkspaceDescription() const;
+	void setWorkspaceDescription(const std::string &workspaceDescription);
+	bool getOnlyAdminCreateDatasource() const;
+	void setOnlyAdminCreateDatasource(bool onlyAdminCreateDatasource);
+	std::string getSignType() const;
+	void setSignType(const std::string &signType);
+	bool getAllowShare() const;
+	void setAllowShare(bool allowShare);
+	bool getDefaultShareToAll() const;
+	void setDefaultShareToAll(bool defaultShareToAll);
+	bool getAllowPublish() const;
+	void setAllowPublish(bool allowPublish);
+	bool getUseComment() const;
+	void setUseComment(bool useComment);
+
+private:
+	bool allowViewAll_;
+	std::string accessPoint_;
+	std::string workspaceName_;
+	std::string workspaceDescription_;
+	bool onlyAdminCreateDatasource_;
+	std::string signType_;
+	bool allowShare_;
+	bool defaultShareToAll_;
+	bool allowPublish_;
+	bool useComment_;
+};
+} // namespace Model
+} // namespace Quickbi_public
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_CREATEWORKSPACEREQUEST_H_

quickbi-public/include/alibabacloud/quickbi-public/model/CreateWorkspaceResult.h

@@ -0,0 +1,53 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_CREATEWORKSPACERESULT_H_
+#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_CREATEWORKSPACERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/quickbi-public/Quickbi_publicExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Quickbi_public
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_QUICKBI_PUBLIC_EXPORT CreateWorkspaceResult : public ServiceResult
+			{
+			public:
+
+
+				CreateWorkspaceResult();
+				explicit CreateWorkspaceResult(const std::string &payload);
+				~CreateWorkspaceResult();
+				bool getSuccess()const;
+				std::string getResult()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				bool success_;
+				std::string result_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_CREATEWORKSPACERESULT_H_

quickbi-public/include/alibabacloud/quickbi-public/model/ListAccelerationOfWorkspaceRequest.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_QUICKBI_PUBLIC_MODEL_LISTACCELERATIONOFWORKSPACEREQUEST_H_
+#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_LISTACCELERATIONOFWORKSPACEREQUEST_H_
+
+#include <alibabacloud/quickbi-public/Quickbi_publicExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Quickbi_public {
+namespace Model {
+class ALIBABACLOUD_QUICKBI_PUBLIC_EXPORT ListAccelerationOfWorkspaceRequest : public RpcServiceRequest {
+public:
+	ListAccelerationOfWorkspaceRequest();
+	~ListAccelerationOfWorkspaceRequest();
+	std::string getAccessPoint() const;
+	void setAccessPoint(const std::string &accessPoint);
+	std::string getCubeName() const;
+	void setCubeName(const std::string &cubeName);
+	int getPageSize() const;
+	void setPageSize(int pageSize);
+	std::string getCreatorId() const;
+	void setCreatorId(const std::string &creatorId);
+	std::string getSignType() const;
+	void setSignType(const std::string &signType);
+	int getPageNo() const;
+	void setPageNo(int pageNo);
+	std::string getWorkspaceId() const;
+	void setWorkspaceId(const std::string &workspaceId);
+
+private:
+	std::string accessPoint_;
+	std::string cubeName_;
+	int pageSize_;
+	std::string creatorId_;
+	std::string signType_;
+	int pageNo_;
+	std::string workspaceId_;
+};
+} // namespace Model
+} // namespace Quickbi_public
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_LISTACCELERATIONOFWORKSPACEREQUEST_H_

quickbi-public/include/alibabacloud/quickbi-public/model/ListAccelerationOfWorkspaceResult.h

@@ -0,0 +1,75 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_LISTACCELERATIONOFWORKSPACERESULT_H_
+#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_LISTACCELERATIONOFWORKSPACERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/quickbi-public/Quickbi_publicExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Quickbi_public
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_QUICKBI_PUBLIC_EXPORT ListAccelerationOfWorkspaceResult : public ServiceResult
+			{
+			public:
+				struct Result
+				{
+					struct DataItem
+					{
+						int jobStatus;
+						std::string cubeId;
+						std::string cubeName;
+						std::string size;
+						std::string jobHistoryId;
+						std::string lastModifyTime;
+						std::string creatorName;
+						std::string jobId;
+						std::string enableQuickindexTime;
+					};
+					int pre;
+					int totalNum;
+					int pageNum;
+					int pageSize;
+					int next;
+					std::vector<DataItem> data;
+					int totalPages;
+				};
+
+
+				ListAccelerationOfWorkspaceResult();
+				explicit ListAccelerationOfWorkspaceResult(const std::string &payload);
+				~ListAccelerationOfWorkspaceResult();
+				bool getSuccess()const;
+				Result getResult()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				bool success_;
+				Result result_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_LISTACCELERATIONOFWORKSPACERESULT_H_

quickbi-public/include/alibabacloud/quickbi-public/model/ModifyDashboardNl2sqlStatusRequest.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_MODIFYDASHBOARDNL2SQLSTATUSREQUEST_H_
+#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_MODIFYDASHBOARDNL2SQLSTATUSREQUEST_H_
+
+#include <alibabacloud/quickbi-public/Quickbi_publicExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Quickbi_public {
+namespace Model {
+class ALIBABACLOUD_QUICKBI_PUBLIC_EXPORT ModifyDashboardNl2sqlStatusRequest : public RpcServiceRequest {
+public:
+	ModifyDashboardNl2sqlStatusRequest();
+	~ModifyDashboardNl2sqlStatusRequest();
+	std::string getAccessPoint() const;
+	void setAccessPoint(const std::string &accessPoint);
+	std::string getSignType() const;
+	void setSignType(const std::string &signType);
+	std::string getDashboardIds() const;
+	void setDashboardIds(const std::string &dashboardIds);
+	int getStatus() const;
+	void setStatus(int status);
+
+private:
+	std::string accessPoint_;
+	std::string signType_;
+	std::string dashboardIds_;
+	int status_;
+};
+} // namespace Model
+} // namespace Quickbi_public
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_MODIFYDASHBOARDNL2SQLSTATUSREQUEST_H_

quickbi-public/include/alibabacloud/quickbi-public/model/ModifyDashboardNl2sqlStatusResult.h

@@ -0,0 +1,53 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_MODIFYDASHBOARDNL2SQLSTATUSRESULT_H_
+#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_MODIFYDASHBOARDNL2SQLSTATUSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/quickbi-public/Quickbi_publicExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Quickbi_public
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_QUICKBI_PUBLIC_EXPORT ModifyDashboardNl2sqlStatusResult : public ServiceResult
+			{
+			public:
+
+
+				ModifyDashboardNl2sqlStatusResult();
+				explicit ModifyDashboardNl2sqlStatusResult(const std::string &payload);
+				~ModifyDashboardNl2sqlStatusResult();
+				bool getSuccess()const;
+				std::vector<std::string> getResult()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				bool success_;
+				std::vector<std::string> result_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_MODIFYDASHBOARDNL2SQLSTATUSRESULT_H_

quickbi-public/include/alibabacloud/quickbi-public/model/QueryAccelerationLogByCubeIdRequest.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_QUICKBI_PUBLIC_MODEL_QUERYACCELERATIONLOGBYCUBEIDREQUEST_H_
+#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_QUERYACCELERATIONLOGBYCUBEIDREQUEST_H_
+
+#include <alibabacloud/quickbi-public/Quickbi_publicExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Quickbi_public {
+namespace Model {
+class ALIBABACLOUD_QUICKBI_PUBLIC_EXPORT QueryAccelerationLogByCubeIdRequest : public RpcServiceRequest {
+public:
+	QueryAccelerationLogByCubeIdRequest();
+	~QueryAccelerationLogByCubeIdRequest();
+	std::string getAccessPoint() const;
+	void setAccessPoint(const std::string &accessPoint);
+	std::string getStartDate() const;
+	void setStartDate(const std::string &startDate);
+	int getPageSize() const;
+	void setPageSize(int pageSize);
+	std::string getCubeId() const;
+	void setCubeId(const std::string &cubeId);
+	std::string getSignType() const;
+	void setSignType(const std::string &signType);
+	std::string getEndDate() const;
+	void setEndDate(const std::string &endDate);
+	int getPageNo() const;
+	void setPageNo(int pageNo);
+
+private:
+	std::string accessPoint_;
+	std::string startDate_;
+	int pageSize_;
+	std::string cubeId_;
+	std::string signType_;
+	std::string endDate_;
+	int pageNo_;
+};
+} // namespace Model
+} // namespace Quickbi_public
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_QUERYACCELERATIONLOGBYCUBEIDREQUEST_H_

quickbi-public/include/alibabacloud/quickbi-public/model/QueryAccelerationLogByCubeIdResult.h

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_QUERYACCELERATIONLOGBYCUBEIDRESULT_H_
+#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_QUERYACCELERATIONLOGBYCUBEIDRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/quickbi-public/Quickbi_publicExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Quickbi_public
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_QUICKBI_PUBLIC_EXPORT QueryAccelerationLogByCubeIdResult : public ServiceResult
+			{
+			public:
+				struct Result
+				{
+					struct DataItem
+					{
+						std::string jobStatus;
+						std::string jonStartDate;
+						std::string log;
+						std::string jobHistoryId;
+						std::string duration;
+						std::string jobId;
+					};
+					int pre;
+					int totalNum;
+					int pageNum;
+					int pageSize;
+					int next;
+					std::vector<DataItem> data;
+					int totalPages;
+				};
+
+
+				QueryAccelerationLogByCubeIdResult();
+				explicit QueryAccelerationLogByCubeIdResult(const std::string &payload);
+				~QueryAccelerationLogByCubeIdResult();
+				bool getSuccess()const;
+				Result getResult()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				bool success_;
+				Result result_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_QUERYACCELERATIONLOGBYCUBEIDRESULT_H_

quickbi-public/include/alibabacloud/quickbi-public/model/SmartqQueryAbilityRequest.h

@@ -38,6 +38,8 @@ public:
 	void setUserQuestion(const std::string &userQuestion);
 	std::string getCubeId() const;
 	void setCubeId(const std::string &cubeId);
+	std::string getMultipleCubeIds() const;
+	void setMultipleCubeIds(const std::string &multipleCubeIds);
 	std::string getSignType() const;
 	void setSignType(const std::string &signType);
 
@@ -46,6 +48,7 @@ private:
 	std::string userId_;
 	std::string userQuestion_;
 	std::string cubeId_;
+	std::string multipleCubeIds_;
 	std::string signType_;
 };
 } // namespace Model

quickbi-public/include/alibabacloud/quickbi-public/model/SmartqQueryAbilityResult.h

@@ -44,6 +44,7 @@ namespace AlibabaCloud
 					{
 						std::vector<std::string> row;
 					};
+					std::vector<std::string> dataList;
 					std::string conclusionText;
 					std::string logicSql;
 					std::vector<ValuesItem> values;

quickbi-public/src/Quickbi-publicClient.cc

@@ -951,6 +951,42 @@ Quickbi_publicClient::CreateUserGroupOutcomeCallable Quickbi_publicClient::creat
 	return task->get_future();
 }
 
+Quickbi_publicClient::CreateWorkspaceOutcome Quickbi_publicClient::createWorkspace(const CreateWorkspaceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateWorkspaceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateWorkspaceOutcome(CreateWorkspaceResult(outcome.result()));
+	else
+		return CreateWorkspaceOutcome(outcome.error());
+}
+
+void Quickbi_publicClient::createWorkspaceAsync(const CreateWorkspaceRequest& request, const CreateWorkspaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createWorkspace(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Quickbi_publicClient::CreateWorkspaceOutcomeCallable Quickbi_publicClient::createWorkspaceCallable(const CreateWorkspaceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateWorkspaceOutcome()>>(
+			[this, request]()
+			{
+			return this->createWorkspace(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 Quickbi_publicClient::DataInterpretationOutcome Quickbi_publicClient::dataInterpretation(const DataInterpretationRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1563,6 +1599,42 @@ Quickbi_publicClient::GetWorksEmbedListOutcomeCallable Quickbi_publicClient::get
 	return task->get_future();
 }
 
+Quickbi_publicClient::ListAccelerationOfWorkspaceOutcome Quickbi_publicClient::listAccelerationOfWorkspace(const ListAccelerationOfWorkspaceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListAccelerationOfWorkspaceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListAccelerationOfWorkspaceOutcome(ListAccelerationOfWorkspaceResult(outcome.result()));
+	else
+		return ListAccelerationOfWorkspaceOutcome(outcome.error());
+}
+
+void Quickbi_publicClient::listAccelerationOfWorkspaceAsync(const ListAccelerationOfWorkspaceRequest& request, const ListAccelerationOfWorkspaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listAccelerationOfWorkspace(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Quickbi_publicClient::ListAccelerationOfWorkspaceOutcomeCallable Quickbi_publicClient::listAccelerationOfWorkspaceCallable(const ListAccelerationOfWorkspaceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListAccelerationOfWorkspaceOutcome()>>(
+			[this, request]()
+			{
+			return this->listAccelerationOfWorkspace(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 Quickbi_publicClient::ListApiDatasourceOutcome Quickbi_publicClient::listApiDatasource(const ListApiDatasourceRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2283,6 +2355,78 @@ Quickbi_publicClient::ModifyCopilotEmbedConfigOutcomeCallable Quickbi_publicClie
 	return task->get_future();
 }
 
+Quickbi_publicClient::ModifyDashboardNl2sqlStatusOutcome Quickbi_publicClient::modifyDashboardNl2sqlStatus(const ModifyDashboardNl2sqlStatusRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ModifyDashboardNl2sqlStatusOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ModifyDashboardNl2sqlStatusOutcome(ModifyDashboardNl2sqlStatusResult(outcome.result()));
+	else
+		return ModifyDashboardNl2sqlStatusOutcome(outcome.error());
+}
+
+void Quickbi_publicClient::modifyDashboardNl2sqlStatusAsync(const ModifyDashboardNl2sqlStatusRequest& request, const ModifyDashboardNl2sqlStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, modifyDashboardNl2sqlStatus(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Quickbi_publicClient::ModifyDashboardNl2sqlStatusOutcomeCallable Quickbi_publicClient::modifyDashboardNl2sqlStatusCallable(const ModifyDashboardNl2sqlStatusRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ModifyDashboardNl2sqlStatusOutcome()>>(
+			[this, request]()
+			{
+			return this->modifyDashboardNl2sqlStatus(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+Quickbi_publicClient::QueryAccelerationLogByCubeIdOutcome Quickbi_publicClient::queryAccelerationLogByCubeId(const QueryAccelerationLogByCubeIdRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return QueryAccelerationLogByCubeIdOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return QueryAccelerationLogByCubeIdOutcome(QueryAccelerationLogByCubeIdResult(outcome.result()));
+	else
+		return QueryAccelerationLogByCubeIdOutcome(outcome.error());
+}
+
+void Quickbi_publicClient::queryAccelerationLogByCubeIdAsync(const QueryAccelerationLogByCubeIdRequest& request, const QueryAccelerationLogByCubeIdAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, queryAccelerationLogByCubeId(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Quickbi_publicClient::QueryAccelerationLogByCubeIdOutcomeCallable Quickbi_publicClient::queryAccelerationLogByCubeIdCallable(const QueryAccelerationLogByCubeIdRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<QueryAccelerationLogByCubeIdOutcome()>>(
+			[this, request]()
+			{
+			return this->queryAccelerationLogByCubeId(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 Quickbi_publicClient::QueryApprovalInfoOutcome Quickbi_publicClient::queryApprovalInfo(const QueryApprovalInfoRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

quickbi-public/src/model/CreateWorkspaceRequest.cc

@@ -0,0 +1,117 @@
+/*
+ * 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 <alibabacloud/quickbi-public/model/CreateWorkspaceRequest.h>
+
+using AlibabaCloud::Quickbi_public::Model::CreateWorkspaceRequest;
+
+CreateWorkspaceRequest::CreateWorkspaceRequest()
+    : RpcServiceRequest("quickbi-public", "2022-01-01", "CreateWorkspace") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateWorkspaceRequest::~CreateWorkspaceRequest() {}
+
+bool CreateWorkspaceRequest::getAllowViewAll() const {
+  return allowViewAll_;
+}
+
+void CreateWorkspaceRequest::setAllowViewAll(bool allowViewAll) {
+  allowViewAll_ = allowViewAll;
+  setParameter(std::string("AllowViewAll"), allowViewAll ? "true" : "false");
+}
+
+std::string CreateWorkspaceRequest::getAccessPoint() const {
+  return accessPoint_;
+}
+
+void CreateWorkspaceRequest::setAccessPoint(const std::string &accessPoint) {
+  accessPoint_ = accessPoint;
+  setParameter(std::string("AccessPoint"), accessPoint);
+}
+
+std::string CreateWorkspaceRequest::getWorkspaceName() const {
+  return workspaceName_;
+}
+
+void CreateWorkspaceRequest::setWorkspaceName(const std::string &workspaceName) {
+  workspaceName_ = workspaceName;
+  setParameter(std::string("WorkspaceName"), workspaceName);
+}
+
+std::string CreateWorkspaceRequest::getWorkspaceDescription() const {
+  return workspaceDescription_;
+}
+
+void CreateWorkspaceRequest::setWorkspaceDescription(const std::string &workspaceDescription) {
+  workspaceDescription_ = workspaceDescription;
+  setParameter(std::string("WorkspaceDescription"), workspaceDescription);
+}
+
+bool CreateWorkspaceRequest::getOnlyAdminCreateDatasource() const {
+  return onlyAdminCreateDatasource_;
+}
+
+void CreateWorkspaceRequest::setOnlyAdminCreateDatasource(bool onlyAdminCreateDatasource) {
+  onlyAdminCreateDatasource_ = onlyAdminCreateDatasource;
+  setParameter(std::string("OnlyAdminCreateDatasource"), onlyAdminCreateDatasource ? "true" : "false");
+}
+
+std::string CreateWorkspaceRequest::getSignType() const {
+  return signType_;
+}
+
+void CreateWorkspaceRequest::setSignType(const std::string &signType) {
+  signType_ = signType;
+  setParameter(std::string("SignType"), signType);
+}
+
+bool CreateWorkspaceRequest::getAllowShare() const {
+  return allowShare_;
+}
+
+void CreateWorkspaceRequest::setAllowShare(bool allowShare) {
+  allowShare_ = allowShare;
+  setParameter(std::string("AllowShare"), allowShare ? "true" : "false");
+}
+
+bool CreateWorkspaceRequest::getDefaultShareToAll() const {
+  return defaultShareToAll_;
+}
+
+void CreateWorkspaceRequest::setDefaultShareToAll(bool defaultShareToAll) {
+  defaultShareToAll_ = defaultShareToAll;
+  setParameter(std::string("DefaultShareToAll"), defaultShareToAll ? "true" : "false");
+}
+
+bool CreateWorkspaceRequest::getAllowPublish() const {
+  return allowPublish_;
+}
+
+void CreateWorkspaceRequest::setAllowPublish(bool allowPublish) {
+  allowPublish_ = allowPublish;
+  setParameter(std::string("AllowPublish"), allowPublish ? "true" : "false");
+}
+
+bool CreateWorkspaceRequest::getUseComment() const {
+  return useComment_;
+}
+
+void CreateWorkspaceRequest::setUseComment(bool useComment) {
+  useComment_ = useComment;
+  setParameter(std::string("UseComment"), useComment ? "true" : "false");
+}
+

quickbi-public/src/model/CreateWorkspaceResult.cc

@@ -0,0 +1,58 @@
+/*
+ * 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 <alibabacloud/quickbi-public/model/CreateWorkspaceResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Quickbi_public;
+using namespace AlibabaCloud::Quickbi_public::Model;
+
+CreateWorkspaceResult::CreateWorkspaceResult() :
+	ServiceResult()
+{}
+
+CreateWorkspaceResult::CreateWorkspaceResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateWorkspaceResult::~CreateWorkspaceResult()
+{}
+
+void CreateWorkspaceResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["Result"].isNull())
+		result_ = value["Result"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+
+}
+
+bool CreateWorkspaceResult::getSuccess()const
+{
+	return success_;
+}
+
+std::string CreateWorkspaceResult::getResult()const
+{
+	return result_;
+}
+

quickbi-public/src/model/ListAccelerationOfWorkspaceRequest.cc

@@ -0,0 +1,90 @@
+/*
+ * 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 <alibabacloud/quickbi-public/model/ListAccelerationOfWorkspaceRequest.h>
+
+using AlibabaCloud::Quickbi_public::Model::ListAccelerationOfWorkspaceRequest;
+
+ListAccelerationOfWorkspaceRequest::ListAccelerationOfWorkspaceRequest()
+    : RpcServiceRequest("quickbi-public", "2022-01-01", "ListAccelerationOfWorkspace") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+ListAccelerationOfWorkspaceRequest::~ListAccelerationOfWorkspaceRequest() {}
+
+std::string ListAccelerationOfWorkspaceRequest::getAccessPoint() const {
+  return accessPoint_;
+}
+
+void ListAccelerationOfWorkspaceRequest::setAccessPoint(const std::string &accessPoint) {
+  accessPoint_ = accessPoint;
+  setParameter(std::string("AccessPoint"), accessPoint);
+}
+
+std::string ListAccelerationOfWorkspaceRequest::getCubeName() const {
+  return cubeName_;
+}
+
+void ListAccelerationOfWorkspaceRequest::setCubeName(const std::string &cubeName) {
+  cubeName_ = cubeName;
+  setParameter(std::string("CubeName"), cubeName);
+}
+
+int ListAccelerationOfWorkspaceRequest::getPageSize() const {
+  return pageSize_;
+}
+
+void ListAccelerationOfWorkspaceRequest::setPageSize(int pageSize) {
+  pageSize_ = pageSize;
+  setParameter(std::string("PageSize"), std::to_string(pageSize));
+}
+
+std::string ListAccelerationOfWorkspaceRequest::getCreatorId() const {
+  return creatorId_;
+}
+
+void ListAccelerationOfWorkspaceRequest::setCreatorId(const std::string &creatorId) {
+  creatorId_ = creatorId;
+  setParameter(std::string("CreatorId"), creatorId);
+}
+
+std::string ListAccelerationOfWorkspaceRequest::getSignType() const {
+  return signType_;
+}
+
+void ListAccelerationOfWorkspaceRequest::setSignType(const std::string &signType) {
+  signType_ = signType;
+  setParameter(std::string("SignType"), signType);
+}
+
+int ListAccelerationOfWorkspaceRequest::getPageNo() const {
+  return pageNo_;
+}
+
+void ListAccelerationOfWorkspaceRequest::setPageNo(int pageNo) {
+  pageNo_ = pageNo;
+  setParameter(std::string("PageNo"), std::to_string(pageNo));
+}
+
+std::string ListAccelerationOfWorkspaceRequest::getWorkspaceId() const {
+  return workspaceId_;
+}
+
+void ListAccelerationOfWorkspaceRequest::setWorkspaceId(const std::string &workspaceId) {
+  workspaceId_ = workspaceId;
+  setParameter(std::string("WorkspaceId"), workspaceId);
+}
+

quickbi-public/src/model/ListAccelerationOfWorkspaceResult.cc

@@ -0,0 +1,93 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/quickbi-public/model/ListAccelerationOfWorkspaceResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Quickbi_public;
+using namespace AlibabaCloud::Quickbi_public::Model;
+
+ListAccelerationOfWorkspaceResult::ListAccelerationOfWorkspaceResult() :
+	ServiceResult()
+{}
+
+ListAccelerationOfWorkspaceResult::ListAccelerationOfWorkspaceResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListAccelerationOfWorkspaceResult::~ListAccelerationOfWorkspaceResult()
+{}
+
+void ListAccelerationOfWorkspaceResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto resultNode = value["Result"];
+	if(!resultNode["TotalPages"].isNull())
+		result_.totalPages = std::stoi(resultNode["TotalPages"].asString());
+	if(!resultNode["TotalNum"].isNull())
+		result_.totalNum = std::stoi(resultNode["TotalNum"].asString());
+	if(!resultNode["PageNum"].isNull())
+		result_.pageNum = std::stoi(resultNode["PageNum"].asString());
+	if(!resultNode["PageSize"].isNull())
+		result_.pageSize = std::stoi(resultNode["PageSize"].asString());
+	if(!resultNode["Pre"].isNull())
+		result_.pre = std::stoi(resultNode["Pre"].asString());
+	if(!resultNode["Next"].isNull())
+		result_.next = std::stoi(resultNode["Next"].asString());
+	auto allDataNode = resultNode["Data"]["DataItem"];
+	for (auto resultNodeDataDataItem : allDataNode)
+	{
+		Result::DataItem dataItemObject;
+		if(!resultNodeDataDataItem["CubeId"].isNull())
+			dataItemObject.cubeId = resultNodeDataDataItem["CubeId"].asString();
+		if(!resultNodeDataDataItem["CubeName"].isNull())
+			dataItemObject.cubeName = resultNodeDataDataItem["CubeName"].asString();
+		if(!resultNodeDataDataItem["CreatorName"].isNull())
+			dataItemObject.creatorName = resultNodeDataDataItem["CreatorName"].asString();
+		if(!resultNodeDataDataItem["Size"].isNull())
+			dataItemObject.size = resultNodeDataDataItem["Size"].asString();
+		if(!resultNodeDataDataItem["LastModifyTime"].isNull())
+			dataItemObject.lastModifyTime = resultNodeDataDataItem["LastModifyTime"].asString();
+		if(!resultNodeDataDataItem["EnableQuickindexTime"].isNull())
+			dataItemObject.enableQuickindexTime = resultNodeDataDataItem["EnableQuickindexTime"].asString();
+		if(!resultNodeDataDataItem["JobId"].isNull())
+			dataItemObject.jobId = resultNodeDataDataItem["JobId"].asString();
+		if(!resultNodeDataDataItem["JobStatus"].isNull())
+			dataItemObject.jobStatus = std::stoi(resultNodeDataDataItem["JobStatus"].asString());
+		if(!resultNodeDataDataItem["JobHistoryId"].isNull())
+			dataItemObject.jobHistoryId = resultNodeDataDataItem["JobHistoryId"].asString();
+		result_.data.push_back(dataItemObject);
+	}
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+
+}
+
+bool ListAccelerationOfWorkspaceResult::getSuccess()const
+{
+	return success_;
+}
+
+ListAccelerationOfWorkspaceResult::Result ListAccelerationOfWorkspaceResult::getResult()const
+{
+	return result_;
+}
+

quickbi-public/src/model/ModifyDashboardNl2sqlStatusRequest.cc

@@ -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.
+ */
+
+#include <alibabacloud/quickbi-public/model/ModifyDashboardNl2sqlStatusRequest.h>
+
+using AlibabaCloud::Quickbi_public::Model::ModifyDashboardNl2sqlStatusRequest;
+
+ModifyDashboardNl2sqlStatusRequest::ModifyDashboardNl2sqlStatusRequest()
+    : RpcServiceRequest("quickbi-public", "2022-01-01", "ModifyDashboardNl2sqlStatus") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+ModifyDashboardNl2sqlStatusRequest::~ModifyDashboardNl2sqlStatusRequest() {}
+
+std::string ModifyDashboardNl2sqlStatusRequest::getAccessPoint() const {
+  return accessPoint_;
+}
+
+void ModifyDashboardNl2sqlStatusRequest::setAccessPoint(const std::string &accessPoint) {
+  accessPoint_ = accessPoint;
+  setParameter(std::string("AccessPoint"), accessPoint);
+}
+
+std::string ModifyDashboardNl2sqlStatusRequest::getSignType() const {
+  return signType_;
+}
+
+void ModifyDashboardNl2sqlStatusRequest::setSignType(const std::string &signType) {
+  signType_ = signType;
+  setParameter(std::string("SignType"), signType);
+}
+
+std::string ModifyDashboardNl2sqlStatusRequest::getDashboardIds() const {
+  return dashboardIds_;
+}
+
+void ModifyDashboardNl2sqlStatusRequest::setDashboardIds(const std::string &dashboardIds) {
+  dashboardIds_ = dashboardIds;
+  setParameter(std::string("DashboardIds"), dashboardIds);
+}
+
+int ModifyDashboardNl2sqlStatusRequest::getStatus() const {
+  return status_;
+}
+
+void ModifyDashboardNl2sqlStatusRequest::setStatus(int status) {
+  status_ = status;
+  setParameter(std::string("Status"), std::to_string(status));
+}
+

quickbi-public/src/model/ModifyDashboardNl2sqlStatusResult.cc

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/quickbi-public/model/ModifyDashboardNl2sqlStatusResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Quickbi_public;
+using namespace AlibabaCloud::Quickbi_public::Model;
+
+ModifyDashboardNl2sqlStatusResult::ModifyDashboardNl2sqlStatusResult() :
+	ServiceResult()
+{}
+
+ModifyDashboardNl2sqlStatusResult::ModifyDashboardNl2sqlStatusResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ModifyDashboardNl2sqlStatusResult::~ModifyDashboardNl2sqlStatusResult()
+{}
+
+void ModifyDashboardNl2sqlStatusResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allResult = value["Result"]["Data"];
+	for (const auto &item : allResult)
+		result_.push_back(item.asString());
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+
+}
+
+bool ModifyDashboardNl2sqlStatusResult::getSuccess()const
+{
+	return success_;
+}
+
+std::vector<std::string> ModifyDashboardNl2sqlStatusResult::getResult()const
+{
+	return result_;
+}
+

quickbi-public/src/model/QueryAccelerationLogByCubeIdRequest.cc

@@ -0,0 +1,90 @@
+/*
+ * 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 <alibabacloud/quickbi-public/model/QueryAccelerationLogByCubeIdRequest.h>
+
+using AlibabaCloud::Quickbi_public::Model::QueryAccelerationLogByCubeIdRequest;
+
+QueryAccelerationLogByCubeIdRequest::QueryAccelerationLogByCubeIdRequest()
+    : RpcServiceRequest("quickbi-public", "2022-01-01", "QueryAccelerationLogByCubeId") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+QueryAccelerationLogByCubeIdRequest::~QueryAccelerationLogByCubeIdRequest() {}
+
+std::string QueryAccelerationLogByCubeIdRequest::getAccessPoint() const {
+  return accessPoint_;
+}
+
+void QueryAccelerationLogByCubeIdRequest::setAccessPoint(const std::string &accessPoint) {
+  accessPoint_ = accessPoint;
+  setParameter(std::string("AccessPoint"), accessPoint);
+}
+
+std::string QueryAccelerationLogByCubeIdRequest::getStartDate() const {
+  return startDate_;
+}
+
+void QueryAccelerationLogByCubeIdRequest::setStartDate(const std::string &startDate) {
+  startDate_ = startDate;
+  setParameter(std::string("StartDate"), startDate);
+}
+
+int QueryAccelerationLogByCubeIdRequest::getPageSize() const {
+  return pageSize_;
+}
+
+void QueryAccelerationLogByCubeIdRequest::setPageSize(int pageSize) {
+  pageSize_ = pageSize;
+  setParameter(std::string("PageSize"), std::to_string(pageSize));
+}
+
+std::string QueryAccelerationLogByCubeIdRequest::getCubeId() const {
+  return cubeId_;
+}
+
+void QueryAccelerationLogByCubeIdRequest::setCubeId(const std::string &cubeId) {
+  cubeId_ = cubeId;
+  setParameter(std::string("CubeId"), cubeId);
+}
+
+std::string QueryAccelerationLogByCubeIdRequest::getSignType() const {
+  return signType_;
+}
+
+void QueryAccelerationLogByCubeIdRequest::setSignType(const std::string &signType) {
+  signType_ = signType;
+  setParameter(std::string("SignType"), signType);
+}
+
+std::string QueryAccelerationLogByCubeIdRequest::getEndDate() const {
+  return endDate_;
+}
+
+void QueryAccelerationLogByCubeIdRequest::setEndDate(const std::string &endDate) {
+  endDate_ = endDate;
+  setParameter(std::string("EndDate"), endDate);
+}
+
+int QueryAccelerationLogByCubeIdRequest::getPageNo() const {
+  return pageNo_;
+}
+
+void QueryAccelerationLogByCubeIdRequest::setPageNo(int pageNo) {
+  pageNo_ = pageNo;
+  setParameter(std::string("PageNo"), std::to_string(pageNo));
+}
+

quickbi-public/src/model/QueryAccelerationLogByCubeIdResult.cc

@@ -0,0 +1,87 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/quickbi-public/model/QueryAccelerationLogByCubeIdResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Quickbi_public;
+using namespace AlibabaCloud::Quickbi_public::Model;
+
+QueryAccelerationLogByCubeIdResult::QueryAccelerationLogByCubeIdResult() :
+	ServiceResult()
+{}
+
+QueryAccelerationLogByCubeIdResult::QueryAccelerationLogByCubeIdResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+QueryAccelerationLogByCubeIdResult::~QueryAccelerationLogByCubeIdResult()
+{}
+
+void QueryAccelerationLogByCubeIdResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto resultNode = value["Result"];
+	if(!resultNode["TotalPages"].isNull())
+		result_.totalPages = std::stoi(resultNode["TotalPages"].asString());
+	if(!resultNode["TotalNum"].isNull())
+		result_.totalNum = std::stoi(resultNode["TotalNum"].asString());
+	if(!resultNode["PageNum"].isNull())
+		result_.pageNum = std::stoi(resultNode["PageNum"].asString());
+	if(!resultNode["PageSize"].isNull())
+		result_.pageSize = std::stoi(resultNode["PageSize"].asString());
+	if(!resultNode["Pre"].isNull())
+		result_.pre = std::stoi(resultNode["Pre"].asString());
+	if(!resultNode["Next"].isNull())
+		result_.next = std::stoi(resultNode["Next"].asString());
+	auto allDataNode = resultNode["Data"]["DataItem"];
+	for (auto resultNodeDataDataItem : allDataNode)
+	{
+		Result::DataItem dataItemObject;
+		if(!resultNodeDataDataItem["JobId"].isNull())
+			dataItemObject.jobId = resultNodeDataDataItem["JobId"].asString();
+		if(!resultNodeDataDataItem["JobHistoryId"].isNull())
+			dataItemObject.jobHistoryId = resultNodeDataDataItem["JobHistoryId"].asString();
+		if(!resultNodeDataDataItem["JonStartDate"].isNull())
+			dataItemObject.jonStartDate = resultNodeDataDataItem["JonStartDate"].asString();
+		if(!resultNodeDataDataItem["JobStatus"].isNull())
+			dataItemObject.jobStatus = resultNodeDataDataItem["JobStatus"].asString();
+		if(!resultNodeDataDataItem["Duration"].isNull())
+			dataItemObject.duration = resultNodeDataDataItem["Duration"].asString();
+		if(!resultNodeDataDataItem["Log"].isNull())
+			dataItemObject.log = resultNodeDataDataItem["Log"].asString();
+		result_.data.push_back(dataItemObject);
+	}
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+
+}
+
+bool QueryAccelerationLogByCubeIdResult::getSuccess()const
+{
+	return success_;
+}
+
+QueryAccelerationLogByCubeIdResult::Result QueryAccelerationLogByCubeIdResult::getResult()const
+{
+	return result_;
+}
+

quickbi-public/src/model/SmartqQueryAbilityRequest.cc

@@ -61,6 +61,15 @@ void SmartqQueryAbilityRequest::setCubeId(const std::string &cubeId) {
   setParameter(std::string("CubeId"), cubeId);
 }
 
+std::string SmartqQueryAbilityRequest::getMultipleCubeIds() const {
+  return multipleCubeIds_;
+}
+
+void SmartqQueryAbilityRequest::setMultipleCubeIds(const std::string &multipleCubeIds) {
+  multipleCubeIds_ = multipleCubeIds;
+  setParameter(std::string("MultipleCubeIds"), multipleCubeIds);
+}
+
 std::string SmartqQueryAbilityRequest::getSignType() const {
   return signType_;
 }

quickbi-public/src/model/SmartqQueryAbilityResult.cc

@@ -67,6 +67,9 @@ void SmartqQueryAbilityResult::parse(const std::string &payload)
 			valuesItemObject.row.push_back(value.asString());
 		result_.values.push_back(valuesItemObject);
 	}
+		auto allDataList = resultNode["DataList"]["DataList"];
+		for (auto value : allDataList)
+			result_.dataList.push_back(value.asString());
 	if(!value["Success"].isNull())
 		success_ = value["Success"].asString() == "true";