/** * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. * SPDX-License-Identifier: Apache-2.0. */ #pragma once #include #include #include #include #include #include namespace Aws { namespace Athena { /** *

Amazon Athena is an interactive query service that lets you use standard SQL * to analyze data directly in Amazon S3. You can point Athena at your data in * Amazon S3 and run ad-hoc queries and get results in seconds. Athena is * serverless, so there is no infrastructure to set up or manage. You pay only for * the queries you run. Athena scales automatically—executing queries in * parallel—so results are fast, even with large datasets and complex queries. For * more information, see What is Amazon * Athena in the Amazon Athena User Guide.

If you connect to * Athena using the JDBC driver, use version 1.1.0 of the driver or later with the * Amazon Athena API. Earlier version drivers do not support the API. For more * information and to download the driver, see Accessing * Amazon Athena with JDBC.

For code samples using the Amazon Web * Services SDK for Java, see Examples * and Code Samples in the Amazon Athena User Guide.

*/ class AWS_ATHENA_API AthenaClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* SERVICE_NAME; static const char* ALLOCATION_TAG; typedef AthenaClientConfiguration ClientConfigurationType; typedef AthenaEndpointProvider EndpointProviderType; /** * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ AthenaClient(const Aws::Athena::AthenaClientConfiguration& clientConfiguration = Aws::Athena::AthenaClientConfiguration(), std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG)); /** * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ AthenaClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::Athena::AthenaClientConfiguration& clientConfiguration = Aws::Athena::AthenaClientConfiguration()); /** * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied, * the default http client factory will be used */ AthenaClient(const std::shared_ptr& credentialsProvider, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::Athena::AthenaClientConfiguration& clientConfiguration = Aws::Athena::AthenaClientConfiguration()); /* Legacy constructors due deprecation */ /** * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ AthenaClient(const Aws::Client::ClientConfiguration& clientConfiguration); /** * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ AthenaClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration); /** * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied, * the default http client factory will be used */ AthenaClient(const std::shared_ptr& credentialsProvider, const Aws::Client::ClientConfiguration& clientConfiguration); /* End of legacy constructors due deprecation */ virtual ~AthenaClient(); /** *

Returns the details of a single named query or a list of up to 50 queries, * which you provide as an array of query ID strings. Requires you to have access * to the workgroup in which the queries were saved. Use * ListNamedQueriesInput to get the list of named query IDs in the specified * workgroup. If information could not be retrieved for a submitted query ID, * information about the query ID submitted is listed under * UnprocessedNamedQueryId. Named queries differ from executed queries. Use * BatchGetQueryExecutionInput to get details about each unique query * execution, and ListQueryExecutionsInput to get a list of query execution * IDs.

See Also:

AWS * API Reference

*/ virtual Model::BatchGetNamedQueryOutcome BatchGetNamedQuery(const Model::BatchGetNamedQueryRequest& request) const; /** * A Callable wrapper for BatchGetNamedQuery that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::BatchGetNamedQueryOutcomeCallable BatchGetNamedQueryCallable(const BatchGetNamedQueryRequestT& request) const { return SubmitCallable(&AthenaClient::BatchGetNamedQuery, request); } /** * An Async wrapper for BatchGetNamedQuery that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void BatchGetNamedQueryAsync(const BatchGetNamedQueryRequestT& request, const BatchGetNamedQueryResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AthenaClient::BatchGetNamedQuery, request, handler, context); } /** *

Returns the details of a single prepared statement or a list of up to 256 * prepared statements for the array of prepared statement names that you provide. * Requires you to have access to the workgroup to which the prepared statements * belong. If a prepared statement cannot be retrieved for the name specified, the * statement is listed in * UnprocessedPreparedStatementNames.

See Also:

AWS * API Reference

*/ virtual Model::BatchGetPreparedStatementOutcome BatchGetPreparedStatement(const Model::BatchGetPreparedStatementRequest& request) const; /** * A Callable wrapper for BatchGetPreparedStatement that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::BatchGetPreparedStatementOutcomeCallable BatchGetPreparedStatementCallable(const BatchGetPreparedStatementRequestT& request) const { return SubmitCallable(&AthenaClient::BatchGetPreparedStatement, request); } /** * An Async wrapper for BatchGetPreparedStatement that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void BatchGetPreparedStatementAsync(const BatchGetPreparedStatementRequestT& request, const BatchGetPreparedStatementResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AthenaClient::BatchGetPreparedStatement, request, handler, context); } /** *

Returns the details of a single query execution or a list of up to 50 query * executions, which you provide as an array of query execution ID strings. * Requires you to have access to the workgroup in which the queries ran. To get a * list of query execution IDs, use ListQueryExecutionsInput$WorkGroup. * Query executions differ from named (saved) queries. Use * BatchGetNamedQueryInput to get details about named queries.

See * Also:

AWS * API Reference

*/ virtual Model::BatchGetQueryExecutionOutcome BatchGetQueryExecution(const Model::BatchGetQueryExecutionRequest& request) const; /** * A Callable wrapper for BatchGetQueryExecution that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::BatchGetQueryExecutionOutcomeCallable BatchGetQueryExecutionCallable(const BatchGetQueryExecutionRequestT& request) const { return SubmitCallable(&AthenaClient::BatchGetQueryExecution, request); } /** * An Async wrapper for BatchGetQueryExecution that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void BatchGetQueryExecutionAsync(const BatchGetQueryExecutionRequestT& request, const BatchGetQueryExecutionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AthenaClient::BatchGetQueryExecution, request, handler, context); } /** *

Cancels the capacity reservation with the specified name. Cancelled * reservations remain in your account and will be deleted 45 days after * cancellation. During the 45 days, you cannot re-purpose or reuse a reservation * that has been cancelled, but you can refer to its tags and view it for * historical reference.

See Also:

AWS * API Reference

*/ virtual Model::CancelCapacityReservationOutcome CancelCapacityReservation(const Model::CancelCapacityReservationRequest& request) const; /** * A Callable wrapper for CancelCapacityReservation that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CancelCapacityReservationOutcomeCallable CancelCapacityReservationCallable(const CancelCapacityReservationRequestT& request) const { return SubmitCallable(&AthenaClient::CancelCapacityReservation, request); } /** * An Async wrapper for CancelCapacityReservation that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CancelCapacityReservationAsync(const CancelCapacityReservationRequestT& request, const CancelCapacityReservationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AthenaClient::CancelCapacityReservation, request, handler, context); } /** *

Creates a capacity reservation with the specified name and number of * requested data processing units.

See Also:

AWS * API Reference

*/ virtual Model::CreateCapacityReservationOutcome CreateCapacityReservation(const Model::CreateCapacityReservationRequest& request) const; /** * A Callable wrapper for CreateCapacityReservation that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateCapacityReservationOutcomeCallable CreateCapacityReservationCallable(const CreateCapacityReservationRequestT& request) const { return SubmitCallable(&AthenaClient::CreateCapacityReservation, request); } /** * An Async wrapper for CreateCapacityReservation that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateCapacityReservationAsync(const CreateCapacityReservationRequestT& request, const CreateCapacityReservationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AthenaClient::CreateCapacityReservation, request, handler, context); } /** *

Creates (registers) a data catalog with the specified name and properties. * Catalogs created are visible to all users of the same Amazon Web Services * account.

See Also:

AWS * API Reference

*/ virtual Model::CreateDataCatalogOutcome CreateDataCatalog(const Model::CreateDataCatalogRequest& request) const; /** * A Callable wrapper for CreateDataCatalog that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateDataCatalogOutcomeCallable CreateDataCatalogCallable(const CreateDataCatalogRequestT& request) const { return SubmitCallable(&AthenaClient::CreateDataCatalog, request); } /** * An Async wrapper for CreateDataCatalog that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateDataCatalogAsync(const CreateDataCatalogRequestT& request, const CreateDataCatalogResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AthenaClient::CreateDataCatalog, request, handler, context); } /** *

Creates a named query in the specified workgroup. Requires that you have * access to the workgroup.

For code samples using the Amazon Web Services * SDK for Java, see Examples * and Code Samples in the Amazon Athena User Guide.

See * Also:

AWS * API Reference

*/ virtual Model::CreateNamedQueryOutcome CreateNamedQuery(const Model::CreateNamedQueryRequest& request) const; /** * A Callable wrapper for CreateNamedQuery that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateNamedQueryOutcomeCallable CreateNamedQueryCallable(const CreateNamedQueryRequestT& request) const { return SubmitCallable(&AthenaClient::CreateNamedQuery, request); } /** * An Async wrapper for CreateNamedQuery that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateNamedQueryAsync(const CreateNamedQueryRequestT& request, const CreateNamedQueryResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AthenaClient::CreateNamedQuery, request, handler, context); } /** *

Creates an empty ipynb file in the specified Apache Spark * enabled workgroup. Throws an error if a file in the workgroup with the same name * already exists.

See Also:

AWS * API Reference

*/ virtual Model::CreateNotebookOutcome CreateNotebook(const Model::CreateNotebookRequest& request) const; /** * A Callable wrapper for CreateNotebook that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateNotebookOutcomeCallable CreateNotebookCallable(const CreateNotebookRequestT& request) const { return SubmitCallable(&AthenaClient::CreateNotebook, request); } /** * An Async wrapper for CreateNotebook that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateNotebookAsync(const CreateNotebookRequestT& request, const CreateNotebookResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AthenaClient::CreateNotebook, request, handler, context); } /** *

Creates a prepared statement for use with SQL queries in * Athena.

See Also:

AWS * API Reference

*/ virtual Model::CreatePreparedStatementOutcome CreatePreparedStatement(const Model::CreatePreparedStatementRequest& request) const; /** * A Callable wrapper for CreatePreparedStatement that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreatePreparedStatementOutcomeCallable CreatePreparedStatementCallable(const CreatePreparedStatementRequestT& request) const { return SubmitCallable(&AthenaClient::CreatePreparedStatement, request); } /** * An Async wrapper for CreatePreparedStatement that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreatePreparedStatementAsync(const CreatePreparedStatementRequestT& request, const CreatePreparedStatementResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AthenaClient::CreatePreparedStatement, request, handler, context); } /** *

Gets an authentication token and the URL at which the notebook can be * accessed. During programmatic access, CreatePresignedNotebookUrl * must be called every 10 minutes to refresh the authentication token. For * information about granting programmatic access, see Grant * programmatic access.

See Also:

AWS * API Reference

*/ virtual Model::CreatePresignedNotebookUrlOutcome CreatePresignedNotebookUrl(const Model::CreatePresignedNotebookUrlRequest& request) const; /** * A Callable wrapper for CreatePresignedNotebookUrl that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreatePresignedNotebookUrlOutcomeCallable CreatePresignedNotebookUrlCallable(const CreatePresignedNotebookUrlRequestT& request) const { return SubmitCallable(&AthenaClient::CreatePresignedNotebookUrl, request); } /** * An Async wrapper for CreatePresignedNotebookUrl that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreatePresignedNotebookUrlAsync(const CreatePresignedNotebookUrlRequestT& request, const CreatePresignedNotebookUrlResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AthenaClient::CreatePresignedNotebookUrl, request, handler, context); } /** *

Creates a workgroup with the specified name. A workgroup can be an Apache * Spark enabled workgroup or an Athena SQL workgroup.

See Also:

* AWS * API Reference

*/ virtual Model::CreateWorkGroupOutcome CreateWorkGroup(const Model::CreateWorkGroupRequest& request) const; /** * A Callable wrapper for CreateWorkGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateWorkGroupOutcomeCallable CreateWorkGroupCallable(const CreateWorkGroupRequestT& request) const { return SubmitCallable(&AthenaClient::CreateWorkGroup, request); } /** * An Async wrapper for CreateWorkGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateWorkGroupAsync(const CreateWorkGroupRequestT& request, const CreateWorkGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AthenaClient::CreateWorkGroup, request, handler, context); } /** *

Deletes a cancelled capacity reservation. A reservation must be cancelled * before it can be deleted. A deleted reservation is immediately removed from your * account and can no longer be referenced, including by its ARN. A deleted * reservation cannot be called by GetCapacityReservation, and deleted * reservations do not appear in the output of * ListCapacityReservations.

See Also:

AWS * API Reference

*/ virtual Model::DeleteCapacityReservationOutcome DeleteCapacityReservation(const Model::DeleteCapacityReservationRequest& request) const; /** * A Callable wrapper for DeleteCapacityReservation that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteCapacityReservationOutcomeCallable DeleteCapacityReservationCallable(const DeleteCapacityReservationRequestT& request) const { return SubmitCallable(&AthenaClient::DeleteCapacityReservation, request); } /** * An Async wrapper for DeleteCapacityReservation that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteCapacityReservationAsync(const DeleteCapacityReservationRequestT& request, const DeleteCapacityReservationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AthenaClient::DeleteCapacityReservation, request, handler, context); } /** *

Deletes a data catalog.

See Also:

AWS * API Reference

*/ virtual Model::DeleteDataCatalogOutcome DeleteDataCatalog(const Model::DeleteDataCatalogRequest& request) const; /** * A Callable wrapper for DeleteDataCatalog that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteDataCatalogOutcomeCallable DeleteDataCatalogCallable(const DeleteDataCatalogRequestT& request) const { return SubmitCallable(&AthenaClient::DeleteDataCatalog, request); } /** * An Async wrapper for DeleteDataCatalog that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteDataCatalogAsync(const DeleteDataCatalogRequestT& request, const DeleteDataCatalogResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AthenaClient::DeleteDataCatalog, request, handler, context); } /** *

Deletes the named query if you have access to the workgroup in which the * query was saved.

For code samples using the Amazon Web Services SDK for * Java, see Examples * and Code Samples in the Amazon Athena User Guide.

See * Also:

AWS * API Reference

*/ virtual Model::DeleteNamedQueryOutcome DeleteNamedQuery(const Model::DeleteNamedQueryRequest& request) const; /** * A Callable wrapper for DeleteNamedQuery that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteNamedQueryOutcomeCallable DeleteNamedQueryCallable(const DeleteNamedQueryRequestT& request) const { return SubmitCallable(&AthenaClient::DeleteNamedQuery, request); } /** * An Async wrapper for DeleteNamedQuery that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteNamedQueryAsync(const DeleteNamedQueryRequestT& request, const DeleteNamedQueryResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AthenaClient::DeleteNamedQuery, request, handler, context); } /** *

Deletes the specified notebook.

See Also:

AWS * API Reference

*/ virtual Model::DeleteNotebookOutcome DeleteNotebook(const Model::DeleteNotebookRequest& request) const; /** * A Callable wrapper for DeleteNotebook that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteNotebookOutcomeCallable DeleteNotebookCallable(const DeleteNotebookRequestT& request) const { return SubmitCallable(&AthenaClient::DeleteNotebook, request); } /** * An Async wrapper for DeleteNotebook that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteNotebookAsync(const DeleteNotebookRequestT& request, const DeleteNotebookResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AthenaClient::DeleteNotebook, request, handler, context); } /** *

Deletes the prepared statement with the specified name from the specified * workgroup.

See Also:

AWS * API Reference

*/ virtual Model::DeletePreparedStatementOutcome DeletePreparedStatement(const Model::DeletePreparedStatementRequest& request) const; /** * A Callable wrapper for DeletePreparedStatement that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeletePreparedStatementOutcomeCallable DeletePreparedStatementCallable(const DeletePreparedStatementRequestT& request) const { return SubmitCallable(&AthenaClient::DeletePreparedStatement, request); } /** * An Async wrapper for DeletePreparedStatement that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeletePreparedStatementAsync(const DeletePreparedStatementRequestT& request, const DeletePreparedStatementResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AthenaClient::DeletePreparedStatement, request, handler, context); } /** *

Deletes the workgroup with the specified name. The primary workgroup cannot * be deleted.

See Also:

AWS * API Reference

*/ virtual Model::DeleteWorkGroupOutcome DeleteWorkGroup(const Model::DeleteWorkGroupRequest& request) const; /** * A Callable wrapper for DeleteWorkGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteWorkGroupOutcomeCallable DeleteWorkGroupCallable(const DeleteWorkGroupRequestT& request) const { return SubmitCallable(&AthenaClient::DeleteWorkGroup, request); } /** * An Async wrapper for DeleteWorkGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteWorkGroupAsync(const DeleteWorkGroupRequestT& request, const DeleteWorkGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AthenaClient::DeleteWorkGroup, request, handler, context); } /** *

Exports the specified notebook and its metadata.

See Also:

* AWS * API Reference

*/ virtual Model::ExportNotebookOutcome ExportNotebook(const Model::ExportNotebookRequest& request) const; /** * A Callable wrapper for ExportNotebook that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ExportNotebookOutcomeCallable ExportNotebookCallable(const ExportNotebookRequestT& request) const { return SubmitCallable(&AthenaClient::ExportNotebook, request); } /** * An Async wrapper for ExportNotebook that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ExportNotebookAsync(const ExportNotebookRequestT& request, const ExportNotebookResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AthenaClient::ExportNotebook, request, handler, context); } /** *

Describes a previously submitted calculation execution.

See * Also:

AWS * API Reference

*/ virtual Model::GetCalculationExecutionOutcome GetCalculationExecution(const Model::GetCalculationExecutionRequest& request) const; /** * A Callable wrapper for GetCalculationExecution that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetCalculationExecutionOutcomeCallable GetCalculationExecutionCallable(const GetCalculationExecutionRequestT& request) const { return SubmitCallable(&AthenaClient::GetCalculationExecution, request); } /** * An Async wrapper for GetCalculationExecution that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetCalculationExecutionAsync(const GetCalculationExecutionRequestT& request, const GetCalculationExecutionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AthenaClient::GetCalculationExecution, request, handler, context); } /** *

Retrieves the unencrypted code that was executed for the * calculation.

See Also:

AWS * API Reference

*/ virtual Model::GetCalculationExecutionCodeOutcome GetCalculationExecutionCode(const Model::GetCalculationExecutionCodeRequest& request) const; /** * A Callable wrapper for GetCalculationExecutionCode that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetCalculationExecutionCodeOutcomeCallable GetCalculationExecutionCodeCallable(const GetCalculationExecutionCodeRequestT& request) const { return SubmitCallable(&AthenaClient::GetCalculationExecutionCode, request); } /** * An Async wrapper for GetCalculationExecutionCode that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetCalculationExecutionCodeAsync(const GetCalculationExecutionCodeRequestT& request, const GetCalculationExecutionCodeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AthenaClient::GetCalculationExecutionCode, request, handler, context); } /** *

Gets the status of a current calculation.

See Also:

AWS * API Reference

*/ virtual Model::GetCalculationExecutionStatusOutcome GetCalculationExecutionStatus(const Model::GetCalculationExecutionStatusRequest& request) const; /** * A Callable wrapper for GetCalculationExecutionStatus that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetCalculationExecutionStatusOutcomeCallable GetCalculationExecutionStatusCallable(const GetCalculationExecutionStatusRequestT& request) const { return SubmitCallable(&AthenaClient::GetCalculationExecutionStatus, request); } /** * An Async wrapper for GetCalculationExecutionStatus that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetCalculationExecutionStatusAsync(const GetCalculationExecutionStatusRequestT& request, const GetCalculationExecutionStatusResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AthenaClient::GetCalculationExecutionStatus, request, handler, context); } /** *

Gets the capacity assignment configuration for a capacity reservation, if one * exists.

See Also:

AWS * API Reference

*/ virtual Model::GetCapacityAssignmentConfigurationOutcome GetCapacityAssignmentConfiguration(const Model::GetCapacityAssignmentConfigurationRequest& request) const; /** * A Callable wrapper for GetCapacityAssignmentConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetCapacityAssignmentConfigurationOutcomeCallable GetCapacityAssignmentConfigurationCallable(const GetCapacityAssignmentConfigurationRequestT& request) const { return SubmitCallable(&AthenaClient::GetCapacityAssignmentConfiguration, request); } /** * An Async wrapper for GetCapacityAssignmentConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetCapacityAssignmentConfigurationAsync(const GetCapacityAssignmentConfigurationRequestT& request, const GetCapacityAssignmentConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AthenaClient::GetCapacityAssignmentConfiguration, request, handler, context); } /** *

Returns information about the capacity reservation with the specified * name.

See Also:

AWS * API Reference

*/ virtual Model::GetCapacityReservationOutcome GetCapacityReservation(const Model::GetCapacityReservationRequest& request) const; /** * A Callable wrapper for GetCapacityReservation that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetCapacityReservationOutcomeCallable GetCapacityReservationCallable(const GetCapacityReservationRequestT& request) const { return SubmitCallable(&AthenaClient::GetCapacityReservation, request); } /** * An Async wrapper for GetCapacityReservation that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetCapacityReservationAsync(const GetCapacityReservationRequestT& request, const GetCapacityReservationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AthenaClient::GetCapacityReservation, request, handler, context); } /** *

Returns the specified data catalog.

See Also:

AWS * API Reference

*/ virtual Model::GetDataCatalogOutcome GetDataCatalog(const Model::GetDataCatalogRequest& request) const; /** * A Callable wrapper for GetDataCatalog that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetDataCatalogOutcomeCallable GetDataCatalogCallable(const GetDataCatalogRequestT& request) const { return SubmitCallable(&AthenaClient::GetDataCatalog, request); } /** * An Async wrapper for GetDataCatalog that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetDataCatalogAsync(const GetDataCatalogRequestT& request, const GetDataCatalogResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AthenaClient::GetDataCatalog, request, handler, context); } /** *

Returns a database object for the specified database and data * catalog.

See Also:

AWS * API Reference

*/ virtual Model::GetDatabaseOutcome GetDatabase(const Model::GetDatabaseRequest& request) const; /** * A Callable wrapper for GetDatabase that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetDatabaseOutcomeCallable GetDatabaseCallable(const GetDatabaseRequestT& request) const { return SubmitCallable(&AthenaClient::GetDatabase, request); } /** * An Async wrapper for GetDatabase that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetDatabaseAsync(const GetDatabaseRequestT& request, const GetDatabaseResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AthenaClient::GetDatabase, request, handler, context); } /** *

Returns information about a single query. Requires that you have access to * the workgroup in which the query was saved.

See Also:

AWS * API Reference

*/ virtual Model::GetNamedQueryOutcome GetNamedQuery(const Model::GetNamedQueryRequest& request) const; /** * A Callable wrapper for GetNamedQuery that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetNamedQueryOutcomeCallable GetNamedQueryCallable(const GetNamedQueryRequestT& request) const { return SubmitCallable(&AthenaClient::GetNamedQuery, request); } /** * An Async wrapper for GetNamedQuery that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetNamedQueryAsync(const GetNamedQueryRequestT& request, const GetNamedQueryResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AthenaClient::GetNamedQuery, request, handler, context); } /** *

Retrieves notebook metadata for the specified notebook ID.

See * Also:

AWS * API Reference

*/ virtual Model::GetNotebookMetadataOutcome GetNotebookMetadata(const Model::GetNotebookMetadataRequest& request) const; /** * A Callable wrapper for GetNotebookMetadata that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetNotebookMetadataOutcomeCallable GetNotebookMetadataCallable(const GetNotebookMetadataRequestT& request) const { return SubmitCallable(&AthenaClient::GetNotebookMetadata, request); } /** * An Async wrapper for GetNotebookMetadata that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetNotebookMetadataAsync(const GetNotebookMetadataRequestT& request, const GetNotebookMetadataResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AthenaClient::GetNotebookMetadata, request, handler, context); } /** *

Retrieves the prepared statement with the specified name from the specified * workgroup.

See Also:

AWS * API Reference

*/ virtual Model::GetPreparedStatementOutcome GetPreparedStatement(const Model::GetPreparedStatementRequest& request) const; /** * A Callable wrapper for GetPreparedStatement that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetPreparedStatementOutcomeCallable GetPreparedStatementCallable(const GetPreparedStatementRequestT& request) const { return SubmitCallable(&AthenaClient::GetPreparedStatement, request); } /** * An Async wrapper for GetPreparedStatement that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetPreparedStatementAsync(const GetPreparedStatementRequestT& request, const GetPreparedStatementResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AthenaClient::GetPreparedStatement, request, handler, context); } /** *

Returns information about a single execution of a query if you have access to * the workgroup in which the query ran. Each time a query executes, information * about the query execution is saved with a unique ID.

See Also:

* AWS * API Reference

*/ virtual Model::GetQueryExecutionOutcome GetQueryExecution(const Model::GetQueryExecutionRequest& request) const; /** * A Callable wrapper for GetQueryExecution that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetQueryExecutionOutcomeCallable GetQueryExecutionCallable(const GetQueryExecutionRequestT& request) const { return SubmitCallable(&AthenaClient::GetQueryExecution, request); } /** * An Async wrapper for GetQueryExecution that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetQueryExecutionAsync(const GetQueryExecutionRequestT& request, const GetQueryExecutionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AthenaClient::GetQueryExecution, request, handler, context); } /** *

Streams the results of a single query execution specified by * QueryExecutionId from the Athena query results location in Amazon * S3. For more information, see Working with * query results, recent queries, and output files in the Amazon Athena User * Guide. This request does not execute the query but returns results. Use * StartQueryExecution to run a query.

To stream query results * successfully, the IAM principal with permission to call * GetQueryResults also must have permissions to the Amazon S3 * GetObject action for the Athena query results location.

*

IAM principals with permission to the Amazon S3 * GetObject action for the query results location are able to * retrieve query results from Amazon S3 even if permission to the * GetQueryResults action is denied. To restrict user or role access, * ensure that Amazon S3 permissions to the Athena query location are denied.

*

See Also:

AWS * API Reference

*/ virtual Model::GetQueryResultsOutcome GetQueryResults(const Model::GetQueryResultsRequest& request) const; /** * A Callable wrapper for GetQueryResults that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetQueryResultsOutcomeCallable GetQueryResultsCallable(const GetQueryResultsRequestT& request) const { return SubmitCallable(&AthenaClient::GetQueryResults, request); } /** * An Async wrapper for GetQueryResults that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetQueryResultsAsync(const GetQueryResultsRequestT& request, const GetQueryResultsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AthenaClient::GetQueryResults, request, handler, context); } /** *

Returns query execution runtime statistics related to a single execution of a * query if you have access to the workgroup in which the query ran. Query * execution runtime statistics are returned only when * QueryExecutionStatus$State is in a SUCCEEDED or FAILED state. Stage-level * input and output row count and data size statistics are not shown when a query * has row-level filters defined in Lake Formation.

See Also:

AWS * API Reference

*/ virtual Model::GetQueryRuntimeStatisticsOutcome GetQueryRuntimeStatistics(const Model::GetQueryRuntimeStatisticsRequest& request) const; /** * A Callable wrapper for GetQueryRuntimeStatistics that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetQueryRuntimeStatisticsOutcomeCallable GetQueryRuntimeStatisticsCallable(const GetQueryRuntimeStatisticsRequestT& request) const { return SubmitCallable(&AthenaClient::GetQueryRuntimeStatistics, request); } /** * An Async wrapper for GetQueryRuntimeStatistics that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetQueryRuntimeStatisticsAsync(const GetQueryRuntimeStatisticsRequestT& request, const GetQueryRuntimeStatisticsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AthenaClient::GetQueryRuntimeStatistics, request, handler, context); } /** *

Gets the full details of a previously created session, including the session * status and configuration.

See Also:

AWS * API Reference

*/ virtual Model::GetSessionOutcome GetSession(const Model::GetSessionRequest& request) const; /** * A Callable wrapper for GetSession that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetSessionOutcomeCallable GetSessionCallable(const GetSessionRequestT& request) const { return SubmitCallable(&AthenaClient::GetSession, request); } /** * An Async wrapper for GetSession that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetSessionAsync(const GetSessionRequestT& request, const GetSessionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AthenaClient::GetSession, request, handler, context); } /** *

Gets the current status of a session.

See Also:

AWS * API Reference

*/ virtual Model::GetSessionStatusOutcome GetSessionStatus(const Model::GetSessionStatusRequest& request) const; /** * A Callable wrapper for GetSessionStatus that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetSessionStatusOutcomeCallable GetSessionStatusCallable(const GetSessionStatusRequestT& request) const { return SubmitCallable(&AthenaClient::GetSessionStatus, request); } /** * An Async wrapper for GetSessionStatus that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetSessionStatusAsync(const GetSessionStatusRequestT& request, const GetSessionStatusResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AthenaClient::GetSessionStatus, request, handler, context); } /** *

Returns table metadata for the specified catalog, database, and * table.

See Also:

AWS * API Reference

*/ virtual Model::GetTableMetadataOutcome GetTableMetadata(const Model::GetTableMetadataRequest& request) const; /** * A Callable wrapper for GetTableMetadata that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetTableMetadataOutcomeCallable GetTableMetadataCallable(const GetTableMetadataRequestT& request) const { return SubmitCallable(&AthenaClient::GetTableMetadata, request); } /** * An Async wrapper for GetTableMetadata that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetTableMetadataAsync(const GetTableMetadataRequestT& request, const GetTableMetadataResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AthenaClient::GetTableMetadata, request, handler, context); } /** *

Returns information about the workgroup with the specified * name.

See Also:

AWS * API Reference

*/ virtual Model::GetWorkGroupOutcome GetWorkGroup(const Model::GetWorkGroupRequest& request) const; /** * A Callable wrapper for GetWorkGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetWorkGroupOutcomeCallable GetWorkGroupCallable(const GetWorkGroupRequestT& request) const { return SubmitCallable(&AthenaClient::GetWorkGroup, request); } /** * An Async wrapper for GetWorkGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetWorkGroupAsync(const GetWorkGroupRequestT& request, const GetWorkGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AthenaClient::GetWorkGroup, request, handler, context); } /** *

Imports a single ipynb file to a Spark enabled workgroup. The * maximum file size that can be imported is 10 megabytes. If an ipynb * file with the same name already exists in the workgroup, throws an * error.

See Also:

AWS * API Reference

*/ virtual Model::ImportNotebookOutcome ImportNotebook(const Model::ImportNotebookRequest& request) const; /** * A Callable wrapper for ImportNotebook that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ImportNotebookOutcomeCallable ImportNotebookCallable(const ImportNotebookRequestT& request) const { return SubmitCallable(&AthenaClient::ImportNotebook, request); } /** * An Async wrapper for ImportNotebook that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ImportNotebookAsync(const ImportNotebookRequestT& request, const ImportNotebookResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AthenaClient::ImportNotebook, request, handler, context); } /** *

Returns the supported DPU sizes for the supported application runtimes (for * example, Athena notebook version 1).

See Also:

AWS * API Reference

*/ virtual Model::ListApplicationDPUSizesOutcome ListApplicationDPUSizes(const Model::ListApplicationDPUSizesRequest& request) const; /** * A Callable wrapper for ListApplicationDPUSizes that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListApplicationDPUSizesOutcomeCallable ListApplicationDPUSizesCallable(const ListApplicationDPUSizesRequestT& request) const { return SubmitCallable(&AthenaClient::ListApplicationDPUSizes, request); } /** * An Async wrapper for ListApplicationDPUSizes that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListApplicationDPUSizesAsync(const ListApplicationDPUSizesRequestT& request, const ListApplicationDPUSizesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AthenaClient::ListApplicationDPUSizes, request, handler, context); } /** *

Lists the calculations that have been submitted to a session in descending * order. Newer calculations are listed first; older calculations are listed * later.

See Also:

AWS * API Reference

*/ virtual Model::ListCalculationExecutionsOutcome ListCalculationExecutions(const Model::ListCalculationExecutionsRequest& request) const; /** * A Callable wrapper for ListCalculationExecutions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListCalculationExecutionsOutcomeCallable ListCalculationExecutionsCallable(const ListCalculationExecutionsRequestT& request) const { return SubmitCallable(&AthenaClient::ListCalculationExecutions, request); } /** * An Async wrapper for ListCalculationExecutions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListCalculationExecutionsAsync(const ListCalculationExecutionsRequestT& request, const ListCalculationExecutionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AthenaClient::ListCalculationExecutions, request, handler, context); } /** *

Lists the capacity reservations for the current account.

See * Also:

AWS * API Reference

*/ virtual Model::ListCapacityReservationsOutcome ListCapacityReservations(const Model::ListCapacityReservationsRequest& request) const; /** * A Callable wrapper for ListCapacityReservations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListCapacityReservationsOutcomeCallable ListCapacityReservationsCallable(const ListCapacityReservationsRequestT& request) const { return SubmitCallable(&AthenaClient::ListCapacityReservations, request); } /** * An Async wrapper for ListCapacityReservations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListCapacityReservationsAsync(const ListCapacityReservationsRequestT& request, const ListCapacityReservationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AthenaClient::ListCapacityReservations, request, handler, context); } /** *

Lists the data catalogs in the current Amazon Web Services account.

*

In the Athena console, data catalogs are listed as "data sources" on * the Data sources page under the Data source name column.

*

See Also:

AWS * API Reference

*/ virtual Model::ListDataCatalogsOutcome ListDataCatalogs(const Model::ListDataCatalogsRequest& request) const; /** * A Callable wrapper for ListDataCatalogs that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListDataCatalogsOutcomeCallable ListDataCatalogsCallable(const ListDataCatalogsRequestT& request) const { return SubmitCallable(&AthenaClient::ListDataCatalogs, request); } /** * An Async wrapper for ListDataCatalogs that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListDataCatalogsAsync(const ListDataCatalogsRequestT& request, const ListDataCatalogsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AthenaClient::ListDataCatalogs, request, handler, context); } /** *

Lists the databases in the specified data catalog.

See Also:

* AWS * API Reference

*/ virtual Model::ListDatabasesOutcome ListDatabases(const Model::ListDatabasesRequest& request) const; /** * A Callable wrapper for ListDatabases that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListDatabasesOutcomeCallable ListDatabasesCallable(const ListDatabasesRequestT& request) const { return SubmitCallable(&AthenaClient::ListDatabases, request); } /** * An Async wrapper for ListDatabases that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListDatabasesAsync(const ListDatabasesRequestT& request, const ListDatabasesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AthenaClient::ListDatabases, request, handler, context); } /** *

Returns a list of engine versions that are available to choose from, * including the Auto option.

See Also:

AWS * API Reference

*/ virtual Model::ListEngineVersionsOutcome ListEngineVersions(const Model::ListEngineVersionsRequest& request) const; /** * A Callable wrapper for ListEngineVersions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListEngineVersionsOutcomeCallable ListEngineVersionsCallable(const ListEngineVersionsRequestT& request) const { return SubmitCallable(&AthenaClient::ListEngineVersions, request); } /** * An Async wrapper for ListEngineVersions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListEngineVersionsAsync(const ListEngineVersionsRequestT& request, const ListEngineVersionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AthenaClient::ListEngineVersions, request, handler, context); } /** *

Lists, in descending order, the executors that joined a session. Newer * executors are listed first; older executors are listed later. The result can be * optionally filtered by state.

See Also:

AWS * API Reference

*/ virtual Model::ListExecutorsOutcome ListExecutors(const Model::ListExecutorsRequest& request) const; /** * A Callable wrapper for ListExecutors that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListExecutorsOutcomeCallable ListExecutorsCallable(const ListExecutorsRequestT& request) const { return SubmitCallable(&AthenaClient::ListExecutors, request); } /** * An Async wrapper for ListExecutors that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListExecutorsAsync(const ListExecutorsRequestT& request, const ListExecutorsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AthenaClient::ListExecutors, request, handler, context); } /** *

Provides a list of available query IDs only for queries saved in the * specified workgroup. Requires that you have access to the specified workgroup. * If a workgroup is not specified, lists the saved queries for the primary * workgroup.

For code samples using the Amazon Web Services SDK for Java, * see Examples * and Code Samples in the Amazon Athena User Guide.

See * Also:

AWS * API Reference

*/ virtual Model::ListNamedQueriesOutcome ListNamedQueries(const Model::ListNamedQueriesRequest& request) const; /** * A Callable wrapper for ListNamedQueries that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListNamedQueriesOutcomeCallable ListNamedQueriesCallable(const ListNamedQueriesRequestT& request) const { return SubmitCallable(&AthenaClient::ListNamedQueries, request); } /** * An Async wrapper for ListNamedQueries that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListNamedQueriesAsync(const ListNamedQueriesRequestT& request, const ListNamedQueriesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AthenaClient::ListNamedQueries, request, handler, context); } /** *

Displays the notebook files for the specified workgroup in paginated * format.

See Also:

AWS * API Reference

*/ virtual Model::ListNotebookMetadataOutcome ListNotebookMetadata(const Model::ListNotebookMetadataRequest& request) const; /** * A Callable wrapper for ListNotebookMetadata that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListNotebookMetadataOutcomeCallable ListNotebookMetadataCallable(const ListNotebookMetadataRequestT& request) const { return SubmitCallable(&AthenaClient::ListNotebookMetadata, request); } /** * An Async wrapper for ListNotebookMetadata that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListNotebookMetadataAsync(const ListNotebookMetadataRequestT& request, const ListNotebookMetadataResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AthenaClient::ListNotebookMetadata, request, handler, context); } /** *

Lists, in descending order, the sessions that have been created in a notebook * that are in an active state like CREATING, CREATED, * IDLE or BUSY. Newer sessions are listed first; older * sessions are listed later.

See Also:

AWS * API Reference

*/ virtual Model::ListNotebookSessionsOutcome ListNotebookSessions(const Model::ListNotebookSessionsRequest& request) const; /** * A Callable wrapper for ListNotebookSessions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListNotebookSessionsOutcomeCallable ListNotebookSessionsCallable(const ListNotebookSessionsRequestT& request) const { return SubmitCallable(&AthenaClient::ListNotebookSessions, request); } /** * An Async wrapper for ListNotebookSessions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListNotebookSessionsAsync(const ListNotebookSessionsRequestT& request, const ListNotebookSessionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AthenaClient::ListNotebookSessions, request, handler, context); } /** *

Lists the prepared statements in the specified workgroup.

See * Also:

AWS * API Reference

*/ virtual Model::ListPreparedStatementsOutcome ListPreparedStatements(const Model::ListPreparedStatementsRequest& request) const; /** * A Callable wrapper for ListPreparedStatements that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListPreparedStatementsOutcomeCallable ListPreparedStatementsCallable(const ListPreparedStatementsRequestT& request) const { return SubmitCallable(&AthenaClient::ListPreparedStatements, request); } /** * An Async wrapper for ListPreparedStatements that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListPreparedStatementsAsync(const ListPreparedStatementsRequestT& request, const ListPreparedStatementsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AthenaClient::ListPreparedStatements, request, handler, context); } /** *

Provides a list of available query execution IDs for the queries in the * specified workgroup. If a workgroup is not specified, returns a list of query * execution IDs for the primary workgroup. Requires you to have access to the * workgroup in which the queries ran.

For code samples using the Amazon Web * Services SDK for Java, see Examples * and Code Samples in the Amazon Athena User Guide.

See * Also:

AWS * API Reference

*/ virtual Model::ListQueryExecutionsOutcome ListQueryExecutions(const Model::ListQueryExecutionsRequest& request) const; /** * A Callable wrapper for ListQueryExecutions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListQueryExecutionsOutcomeCallable ListQueryExecutionsCallable(const ListQueryExecutionsRequestT& request) const { return SubmitCallable(&AthenaClient::ListQueryExecutions, request); } /** * An Async wrapper for ListQueryExecutions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListQueryExecutionsAsync(const ListQueryExecutionsRequestT& request, const ListQueryExecutionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AthenaClient::ListQueryExecutions, request, handler, context); } /** *

Lists the sessions in a workgroup that are in an active state like * CREATING, CREATED, IDLE, or * BUSY. Newer sessions are listed first; older sessions are listed * later.

See Also:

AWS * API Reference

*/ virtual Model::ListSessionsOutcome ListSessions(const Model::ListSessionsRequest& request) const; /** * A Callable wrapper for ListSessions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListSessionsOutcomeCallable ListSessionsCallable(const ListSessionsRequestT& request) const { return SubmitCallable(&AthenaClient::ListSessions, request); } /** * An Async wrapper for ListSessions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListSessionsAsync(const ListSessionsRequestT& request, const ListSessionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AthenaClient::ListSessions, request, handler, context); } /** *

Lists the metadata for the tables in the specified data catalog * database.

See Also:

AWS * API Reference

*/ virtual Model::ListTableMetadataOutcome ListTableMetadata(const Model::ListTableMetadataRequest& request) const; /** * A Callable wrapper for ListTableMetadata that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListTableMetadataOutcomeCallable ListTableMetadataCallable(const ListTableMetadataRequestT& request) const { return SubmitCallable(&AthenaClient::ListTableMetadata, request); } /** * An Async wrapper for ListTableMetadata that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListTableMetadataAsync(const ListTableMetadataRequestT& request, const ListTableMetadataResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AthenaClient::ListTableMetadata, request, handler, context); } /** *

Lists the tags associated with an Athena resource.

See Also:

* AWS * API Reference

*/ virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const; /** * A Callable wrapper for ListTagsForResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const ListTagsForResourceRequestT& request) const { return SubmitCallable(&AthenaClient::ListTagsForResource, request); } /** * An Async wrapper for ListTagsForResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListTagsForResourceAsync(const ListTagsForResourceRequestT& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AthenaClient::ListTagsForResource, request, handler, context); } /** *

Lists available workgroups for the account.

See Also:

AWS * API Reference

*/ virtual Model::ListWorkGroupsOutcome ListWorkGroups(const Model::ListWorkGroupsRequest& request) const; /** * A Callable wrapper for ListWorkGroups that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListWorkGroupsOutcomeCallable ListWorkGroupsCallable(const ListWorkGroupsRequestT& request) const { return SubmitCallable(&AthenaClient::ListWorkGroups, request); } /** * An Async wrapper for ListWorkGroups that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListWorkGroupsAsync(const ListWorkGroupsRequestT& request, const ListWorkGroupsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AthenaClient::ListWorkGroups, request, handler, context); } /** *

Puts a new capacity assignment configuration for a specified capacity * reservation. If a capacity assignment configuration already exists for the * capacity reservation, replaces the existing capacity assignment * configuration.

See Also:

AWS * API Reference

*/ virtual Model::PutCapacityAssignmentConfigurationOutcome PutCapacityAssignmentConfiguration(const Model::PutCapacityAssignmentConfigurationRequest& request) const; /** * A Callable wrapper for PutCapacityAssignmentConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutCapacityAssignmentConfigurationOutcomeCallable PutCapacityAssignmentConfigurationCallable(const PutCapacityAssignmentConfigurationRequestT& request) const { return SubmitCallable(&AthenaClient::PutCapacityAssignmentConfiguration, request); } /** * An Async wrapper for PutCapacityAssignmentConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutCapacityAssignmentConfigurationAsync(const PutCapacityAssignmentConfigurationRequestT& request, const PutCapacityAssignmentConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AthenaClient::PutCapacityAssignmentConfiguration, request, handler, context); } /** *

Submits calculations for execution within a session. You can supply the code * to run as an inline code block within the request.

See Also:

AWS * API Reference

*/ virtual Model::StartCalculationExecutionOutcome StartCalculationExecution(const Model::StartCalculationExecutionRequest& request) const; /** * A Callable wrapper for StartCalculationExecution that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StartCalculationExecutionOutcomeCallable StartCalculationExecutionCallable(const StartCalculationExecutionRequestT& request) const { return SubmitCallable(&AthenaClient::StartCalculationExecution, request); } /** * An Async wrapper for StartCalculationExecution that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StartCalculationExecutionAsync(const StartCalculationExecutionRequestT& request, const StartCalculationExecutionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AthenaClient::StartCalculationExecution, request, handler, context); } /** *

Runs the SQL query statements contained in the Query. Requires * you to have access to the workgroup in which the query ran. Running queries * against an external catalog requires GetDataCatalog permission to the * catalog. For code samples using the Amazon Web Services SDK for Java, see Examples * and Code Samples in the Amazon Athena User Guide.

See * Also:

AWS * API Reference

*/ virtual Model::StartQueryExecutionOutcome StartQueryExecution(const Model::StartQueryExecutionRequest& request) const; /** * A Callable wrapper for StartQueryExecution that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StartQueryExecutionOutcomeCallable StartQueryExecutionCallable(const StartQueryExecutionRequestT& request) const { return SubmitCallable(&AthenaClient::StartQueryExecution, request); } /** * An Async wrapper for StartQueryExecution that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StartQueryExecutionAsync(const StartQueryExecutionRequestT& request, const StartQueryExecutionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AthenaClient::StartQueryExecution, request, handler, context); } /** *

Creates a session for running calculations within a workgroup. The session is * ready when it reaches an IDLE state.

See Also:

AWS * API Reference

*/ virtual Model::StartSessionOutcome StartSession(const Model::StartSessionRequest& request) const; /** * A Callable wrapper for StartSession that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StartSessionOutcomeCallable StartSessionCallable(const StartSessionRequestT& request) const { return SubmitCallable(&AthenaClient::StartSession, request); } /** * An Async wrapper for StartSession that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StartSessionAsync(const StartSessionRequestT& request, const StartSessionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AthenaClient::StartSession, request, handler, context); } /** *

Requests the cancellation of a calculation. A * StopCalculationExecution call on a calculation that is already in a * terminal state (for example, STOPPED, FAILED, or * COMPLETED) succeeds but has no effect.

Cancelling a * calculation is done on a best effort basis. If a calculation cannot be * cancelled, you can be charged for its completion. If you are concerned about * being charged for a calculation that cannot be cancelled, consider terminating * the session in which the calculation is running.

See * Also:

AWS * API Reference

*/ virtual Model::StopCalculationExecutionOutcome StopCalculationExecution(const Model::StopCalculationExecutionRequest& request) const; /** * A Callable wrapper for StopCalculationExecution that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StopCalculationExecutionOutcomeCallable StopCalculationExecutionCallable(const StopCalculationExecutionRequestT& request) const { return SubmitCallable(&AthenaClient::StopCalculationExecution, request); } /** * An Async wrapper for StopCalculationExecution that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StopCalculationExecutionAsync(const StopCalculationExecutionRequestT& request, const StopCalculationExecutionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AthenaClient::StopCalculationExecution, request, handler, context); } /** *

Stops a query execution. Requires you to have access to the workgroup in * which the query ran.

For code samples using the Amazon Web Services SDK * for Java, see Examples * and Code Samples in the Amazon Athena User Guide.

See * Also:

AWS * API Reference

*/ virtual Model::StopQueryExecutionOutcome StopQueryExecution(const Model::StopQueryExecutionRequest& request) const; /** * A Callable wrapper for StopQueryExecution that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StopQueryExecutionOutcomeCallable StopQueryExecutionCallable(const StopQueryExecutionRequestT& request) const { return SubmitCallable(&AthenaClient::StopQueryExecution, request); } /** * An Async wrapper for StopQueryExecution that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StopQueryExecutionAsync(const StopQueryExecutionRequestT& request, const StopQueryExecutionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AthenaClient::StopQueryExecution, request, handler, context); } /** *

Adds one or more tags to an Athena resource. A tag is a label that you assign * to a resource. Each tag consists of a key and an optional value, both of which * you define. For example, you can use tags to categorize Athena workgroups, data * catalogs, or capacity reservations by purpose, owner, or environment. Use a * consistent set of tag keys to make it easier to search and filter the resources * in your account. For best practices, see Tagging * Best Practices. Tag keys can be from 1 to 128 UTF-8 Unicode characters, and * tag values can be from 0 to 256 UTF-8 Unicode characters. Tags can use letters * and numbers representable in UTF-8, and the following characters: + - = . _ : / * @. Tag keys and values are case-sensitive. Tag keys must be unique per resource. * If you specify more than one tag, separate them by commas.

See * Also:

AWS * API Reference

*/ virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const; /** * A Callable wrapper for TagResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const { return SubmitCallable(&AthenaClient::TagResource, request); } /** * An Async wrapper for TagResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void TagResourceAsync(const TagResourceRequestT& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AthenaClient::TagResource, request, handler, context); } /** *

Terminates an active session. A TerminateSession call on a * session that is already inactive (for example, in a FAILED, * TERMINATED or TERMINATING state) succeeds but has no * effect. Calculations running in the session when TerminateSession * is called are forcefully stopped, but may display as FAILED instead * of STOPPED.

See Also:

AWS * API Reference

*/ virtual Model::TerminateSessionOutcome TerminateSession(const Model::TerminateSessionRequest& request) const; /** * A Callable wrapper for TerminateSession that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::TerminateSessionOutcomeCallable TerminateSessionCallable(const TerminateSessionRequestT& request) const { return SubmitCallable(&AthenaClient::TerminateSession, request); } /** * An Async wrapper for TerminateSession that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void TerminateSessionAsync(const TerminateSessionRequestT& request, const TerminateSessionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AthenaClient::TerminateSession, request, handler, context); } /** *

Removes one or more tags from an Athena resource.

See Also:

* AWS * API Reference

*/ virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const; /** * A Callable wrapper for UntagResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const { return SubmitCallable(&AthenaClient::UntagResource, request); } /** * An Async wrapper for UntagResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UntagResourceAsync(const UntagResourceRequestT& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AthenaClient::UntagResource, request, handler, context); } /** *

Updates the number of requested data processing units for the capacity * reservation with the specified name.

See Also:

AWS * API Reference

*/ virtual Model::UpdateCapacityReservationOutcome UpdateCapacityReservation(const Model::UpdateCapacityReservationRequest& request) const; /** * A Callable wrapper for UpdateCapacityReservation that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateCapacityReservationOutcomeCallable UpdateCapacityReservationCallable(const UpdateCapacityReservationRequestT& request) const { return SubmitCallable(&AthenaClient::UpdateCapacityReservation, request); } /** * An Async wrapper for UpdateCapacityReservation that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateCapacityReservationAsync(const UpdateCapacityReservationRequestT& request, const UpdateCapacityReservationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AthenaClient::UpdateCapacityReservation, request, handler, context); } /** *

Updates the data catalog that has the specified name.

See * Also:

AWS * API Reference

*/ virtual Model::UpdateDataCatalogOutcome UpdateDataCatalog(const Model::UpdateDataCatalogRequest& request) const; /** * A Callable wrapper for UpdateDataCatalog that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateDataCatalogOutcomeCallable UpdateDataCatalogCallable(const UpdateDataCatalogRequestT& request) const { return SubmitCallable(&AthenaClient::UpdateDataCatalog, request); } /** * An Async wrapper for UpdateDataCatalog that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateDataCatalogAsync(const UpdateDataCatalogRequestT& request, const UpdateDataCatalogResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AthenaClient::UpdateDataCatalog, request, handler, context); } /** *

Updates a NamedQuery object. The database or workgroup cannot be * updated.

See Also:

AWS * API Reference

*/ virtual Model::UpdateNamedQueryOutcome UpdateNamedQuery(const Model::UpdateNamedQueryRequest& request) const; /** * A Callable wrapper for UpdateNamedQuery that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateNamedQueryOutcomeCallable UpdateNamedQueryCallable(const UpdateNamedQueryRequestT& request) const { return SubmitCallable(&AthenaClient::UpdateNamedQuery, request); } /** * An Async wrapper for UpdateNamedQuery that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateNamedQueryAsync(const UpdateNamedQueryRequestT& request, const UpdateNamedQueryResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AthenaClient::UpdateNamedQuery, request, handler, context); } /** *

Updates the contents of a Spark notebook.

See Also:

AWS * API Reference

*/ virtual Model::UpdateNotebookOutcome UpdateNotebook(const Model::UpdateNotebookRequest& request) const; /** * A Callable wrapper for UpdateNotebook that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateNotebookOutcomeCallable UpdateNotebookCallable(const UpdateNotebookRequestT& request) const { return SubmitCallable(&AthenaClient::UpdateNotebook, request); } /** * An Async wrapper for UpdateNotebook that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateNotebookAsync(const UpdateNotebookRequestT& request, const UpdateNotebookResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AthenaClient::UpdateNotebook, request, handler, context); } /** *

Updates the metadata for a notebook.

See Also:

AWS * API Reference

*/ virtual Model::UpdateNotebookMetadataOutcome UpdateNotebookMetadata(const Model::UpdateNotebookMetadataRequest& request) const; /** * A Callable wrapper for UpdateNotebookMetadata that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateNotebookMetadataOutcomeCallable UpdateNotebookMetadataCallable(const UpdateNotebookMetadataRequestT& request) const { return SubmitCallable(&AthenaClient::UpdateNotebookMetadata, request); } /** * An Async wrapper for UpdateNotebookMetadata that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateNotebookMetadataAsync(const UpdateNotebookMetadataRequestT& request, const UpdateNotebookMetadataResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AthenaClient::UpdateNotebookMetadata, request, handler, context); } /** *

Updates a prepared statement.

See Also:

AWS * API Reference

*/ virtual Model::UpdatePreparedStatementOutcome UpdatePreparedStatement(const Model::UpdatePreparedStatementRequest& request) const; /** * A Callable wrapper for UpdatePreparedStatement that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdatePreparedStatementOutcomeCallable UpdatePreparedStatementCallable(const UpdatePreparedStatementRequestT& request) const { return SubmitCallable(&AthenaClient::UpdatePreparedStatement, request); } /** * An Async wrapper for UpdatePreparedStatement that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdatePreparedStatementAsync(const UpdatePreparedStatementRequestT& request, const UpdatePreparedStatementResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AthenaClient::UpdatePreparedStatement, request, handler, context); } /** *

Updates the workgroup with the specified name. The workgroup's name cannot be * changed. Only ConfigurationUpdates can be specified.

See * Also:

AWS * API Reference

*/ virtual Model::UpdateWorkGroupOutcome UpdateWorkGroup(const Model::UpdateWorkGroupRequest& request) const; /** * A Callable wrapper for UpdateWorkGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateWorkGroupOutcomeCallable UpdateWorkGroupCallable(const UpdateWorkGroupRequestT& request) const { return SubmitCallable(&AthenaClient::UpdateWorkGroup, request); } /** * An Async wrapper for UpdateWorkGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateWorkGroupAsync(const UpdateWorkGroupRequestT& request, const UpdateWorkGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AthenaClient::UpdateWorkGroup, request, handler, context); } void OverrideEndpoint(const Aws::String& endpoint); std::shared_ptr& accessEndpointProvider(); private: friend class Aws::Client::ClientWithAsyncTemplateMethods; void init(const AthenaClientConfiguration& clientConfiguration); AthenaClientConfiguration m_clientConfiguration; std::shared_ptr m_executor; std::shared_ptr m_endpointProvider; }; } // namespace Athena } // namespace Aws