/* * Copyright Amazon.com, Inc. or its affiliates. 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. * A copy of the License is located at * * http://aws.amazon.com/apache2.0 * * or in the "license" file accompanying this file. This file 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. */ /* * Do not modify this file. This file is generated from the athena-2017-05-18.normal.json service model. */ using System; using System.Collections.Generic; using Amazon.Runtime; using Amazon.Athena.Model; namespace Amazon.Athena { ///

/// Interface for accessing 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. /// ///

public partial interface IAmazonAthena : IAmazonService, IDisposable { #if BCL45 || AWS_ASYNC_ENUMERABLES_API ///

/// Paginators for the service ///

IAthenaPaginatorFactory Paginators { get; } #endif #region BatchGetNamedQuery ///

/// 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. ///

/// Container for the necessary parameters to execute the BatchGetNamedQuery service method. /// /// The response from the BatchGetNamedQuery service method, as returned by Athena. /// /// Indicates a platform issue, which may be due to a transient condition or outage. /// /// /// Indicates that something is wrong with the input to the request. For example, a required /// parameter may be missing or out of range. /// /// REST API Reference for BatchGetNamedQuery Operation BatchGetNamedQueryResponse BatchGetNamedQuery(BatchGetNamedQueryRequest request); ///

/// Initiates the asynchronous execution of the BatchGetNamedQuery operation. ///

/// /// Container for the necessary parameters to execute the BatchGetNamedQuery operation on AmazonAthenaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndBatchGetNamedQuery /// operation. /// REST API Reference for BatchGetNamedQuery Operation IAsyncResult BeginBatchGetNamedQuery(BatchGetNamedQueryRequest request, AsyncCallback callback, object state); ///

/// Finishes the asynchronous execution of the BatchGetNamedQuery operation. ///

/// /// The IAsyncResult returned by the call to BeginBatchGetNamedQuery. /// /// Returns a BatchGetNamedQueryResult from Athena. /// REST API Reference for BatchGetNamedQuery Operation BatchGetNamedQueryResponse EndBatchGetNamedQuery(IAsyncResult asyncResult); #endregion #region BatchGetPreparedStatement ///

/// 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. ///

/// Container for the necessary parameters to execute the BatchGetPreparedStatement service method. /// /// The response from the BatchGetPreparedStatement service method, as returned by Athena. /// /// Indicates a platform issue, which may be due to a transient condition or outage. /// /// /// Indicates that something is wrong with the input to the request. For example, a required /// parameter may be missing or out of range. /// /// REST API Reference for BatchGetPreparedStatement Operation BatchGetPreparedStatementResponse BatchGetPreparedStatement(BatchGetPreparedStatementRequest request); ///

/// Initiates the asynchronous execution of the BatchGetPreparedStatement operation. ///

/// /// Container for the necessary parameters to execute the BatchGetPreparedStatement operation on AmazonAthenaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndBatchGetPreparedStatement /// operation. /// REST API Reference for BatchGetPreparedStatement Operation IAsyncResult BeginBatchGetPreparedStatement(BatchGetPreparedStatementRequest request, AsyncCallback callback, object state); ///

/// Finishes the asynchronous execution of the BatchGetPreparedStatement operation. ///

/// /// The IAsyncResult returned by the call to BeginBatchGetPreparedStatement. /// /// Returns a BatchGetPreparedStatementResult from Athena. /// REST API Reference for BatchGetPreparedStatement Operation BatchGetPreparedStatementResponse EndBatchGetPreparedStatement(IAsyncResult asyncResult); #endregion #region BatchGetQueryExecution ///

/// 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. ///

/// Container for the necessary parameters to execute the BatchGetQueryExecution service method. /// /// The response from the BatchGetQueryExecution service method, as returned by Athena. /// /// Indicates a platform issue, which may be due to a transient condition or outage. /// /// /// Indicates that something is wrong with the input to the request. For example, a required /// parameter may be missing or out of range. /// /// REST API Reference for BatchGetQueryExecution Operation BatchGetQueryExecutionResponse BatchGetQueryExecution(BatchGetQueryExecutionRequest request); ///

/// Initiates the asynchronous execution of the BatchGetQueryExecution operation. ///

/// /// Container for the necessary parameters to execute the BatchGetQueryExecution operation on AmazonAthenaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndBatchGetQueryExecution /// operation. /// REST API Reference for BatchGetQueryExecution Operation IAsyncResult BeginBatchGetQueryExecution(BatchGetQueryExecutionRequest request, AsyncCallback callback, object state); ///

/// Finishes the asynchronous execution of the BatchGetQueryExecution operation. ///

/// /// The IAsyncResult returned by the call to BeginBatchGetQueryExecution. /// /// Returns a BatchGetQueryExecutionResult from Athena. /// REST API Reference for BatchGetQueryExecution Operation BatchGetQueryExecutionResponse EndBatchGetQueryExecution(IAsyncResult asyncResult); #endregion #region CancelCapacityReservation ///

/// 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. ///

/// Container for the necessary parameters to execute the CancelCapacityReservation service method. /// /// The response from the CancelCapacityReservation service method, as returned by Athena. /// /// Indicates a platform issue, which may be due to a transient condition or outage. /// /// /// Indicates that something is wrong with the input to the request. For example, a required /// parameter may be missing or out of range. /// /// REST API Reference for CancelCapacityReservation Operation CancelCapacityReservationResponse CancelCapacityReservation(CancelCapacityReservationRequest request); ///

/// Initiates the asynchronous execution of the CancelCapacityReservation operation. ///

/// /// Container for the necessary parameters to execute the CancelCapacityReservation operation on AmazonAthenaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCancelCapacityReservation /// operation. /// REST API Reference for CancelCapacityReservation Operation IAsyncResult BeginCancelCapacityReservation(CancelCapacityReservationRequest request, AsyncCallback callback, object state); ///

/// Finishes the asynchronous execution of the CancelCapacityReservation operation. ///

/// /// The IAsyncResult returned by the call to BeginCancelCapacityReservation. /// /// Returns a CancelCapacityReservationResult from Athena. /// REST API Reference for CancelCapacityReservation Operation CancelCapacityReservationResponse EndCancelCapacityReservation(IAsyncResult asyncResult); #endregion #region CreateCapacityReservation ///

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

/// Container for the necessary parameters to execute the CreateCapacityReservation service method. /// /// The response from the CreateCapacityReservation service method, as returned by Athena. /// /// Indicates a platform issue, which may be due to a transient condition or outage. /// /// /// Indicates that something is wrong with the input to the request. For example, a required /// parameter may be missing or out of range. /// /// REST API Reference for CreateCapacityReservation Operation CreateCapacityReservationResponse CreateCapacityReservation(CreateCapacityReservationRequest request); ///

/// Initiates the asynchronous execution of the CreateCapacityReservation operation. ///

/// /// Container for the necessary parameters to execute the CreateCapacityReservation operation on AmazonAthenaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateCapacityReservation /// operation. /// REST API Reference for CreateCapacityReservation Operation IAsyncResult BeginCreateCapacityReservation(CreateCapacityReservationRequest request, AsyncCallback callback, object state); ///

/// Finishes the asynchronous execution of the CreateCapacityReservation operation. ///

/// /// The IAsyncResult returned by the call to BeginCreateCapacityReservation. /// /// Returns a CreateCapacityReservationResult from Athena. /// REST API Reference for CreateCapacityReservation Operation CreateCapacityReservationResponse EndCreateCapacityReservation(IAsyncResult asyncResult); #endregion #region CreateDataCatalog ///

/// 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. ///

/// Container for the necessary parameters to execute the CreateDataCatalog service method. /// /// The response from the CreateDataCatalog service method, as returned by Athena. /// /// Indicates a platform issue, which may be due to a transient condition or outage. /// /// /// Indicates that something is wrong with the input to the request. For example, a required /// parameter may be missing or out of range. /// /// REST API Reference for CreateDataCatalog Operation CreateDataCatalogResponse CreateDataCatalog(CreateDataCatalogRequest request); ///

/// Initiates the asynchronous execution of the CreateDataCatalog operation. ///

/// /// Container for the necessary parameters to execute the CreateDataCatalog operation on AmazonAthenaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateDataCatalog /// operation. /// REST API Reference for CreateDataCatalog Operation IAsyncResult BeginCreateDataCatalog(CreateDataCatalogRequest request, AsyncCallback callback, object state); ///

/// Finishes the asynchronous execution of the CreateDataCatalog operation. ///

/// /// The IAsyncResult returned by the call to BeginCreateDataCatalog. /// /// Returns a CreateDataCatalogResult from Athena. /// REST API Reference for CreateDataCatalog Operation CreateDataCatalogResponse EndCreateDataCatalog(IAsyncResult asyncResult); #endregion #region CreateNamedQuery ///

/// 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. /// ///

/// Container for the necessary parameters to execute the CreateNamedQuery service method. /// /// The response from the CreateNamedQuery service method, as returned by Athena. /// /// Indicates a platform issue, which may be due to a transient condition or outage. /// /// /// Indicates that something is wrong with the input to the request. For example, a required /// parameter may be missing or out of range. /// /// REST API Reference for CreateNamedQuery Operation CreateNamedQueryResponse CreateNamedQuery(CreateNamedQueryRequest request); ///

/// Initiates the asynchronous execution of the CreateNamedQuery operation. ///

/// /// Container for the necessary parameters to execute the CreateNamedQuery operation on AmazonAthenaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateNamedQuery /// operation. /// REST API Reference for CreateNamedQuery Operation IAsyncResult BeginCreateNamedQuery(CreateNamedQueryRequest request, AsyncCallback callback, object state); ///

/// Finishes the asynchronous execution of the CreateNamedQuery operation. ///

/// /// The IAsyncResult returned by the call to BeginCreateNamedQuery. /// /// Returns a CreateNamedQueryResult from Athena. /// REST API Reference for CreateNamedQuery Operation CreateNamedQueryResponse EndCreateNamedQuery(IAsyncResult asyncResult); #endregion #region CreateNotebook ///

/// 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. ///

/// Container for the necessary parameters to execute the CreateNotebook service method. /// /// The response from the CreateNotebook service method, as returned by Athena. /// /// Indicates a platform issue, which may be due to a transient condition or outage. /// /// /// Indicates that something is wrong with the input to the request. For example, a required /// parameter may be missing or out of range. /// /// /// Indicates that the request was throttled. /// /// REST API Reference for CreateNotebook Operation CreateNotebookResponse CreateNotebook(CreateNotebookRequest request); ///

/// Initiates the asynchronous execution of the CreateNotebook operation. ///

/// /// Container for the necessary parameters to execute the CreateNotebook operation on AmazonAthenaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateNotebook /// operation. /// REST API Reference for CreateNotebook Operation IAsyncResult BeginCreateNotebook(CreateNotebookRequest request, AsyncCallback callback, object state); ///

/// Finishes the asynchronous execution of the CreateNotebook operation. ///

/// /// The IAsyncResult returned by the call to BeginCreateNotebook. /// /// Returns a CreateNotebookResult from Athena. /// REST API Reference for CreateNotebook Operation CreateNotebookResponse EndCreateNotebook(IAsyncResult asyncResult); #endregion #region CreatePreparedStatement ///

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

/// Container for the necessary parameters to execute the CreatePreparedStatement service method. /// /// The response from the CreatePreparedStatement service method, as returned by Athena. /// /// Indicates a platform issue, which may be due to a transient condition or outage. /// /// /// Indicates that something is wrong with the input to the request. For example, a required /// parameter may be missing or out of range. /// /// REST API Reference for CreatePreparedStatement Operation CreatePreparedStatementResponse CreatePreparedStatement(CreatePreparedStatementRequest request); ///

/// Initiates the asynchronous execution of the CreatePreparedStatement operation. ///

/// /// Container for the necessary parameters to execute the CreatePreparedStatement operation on AmazonAthenaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreatePreparedStatement /// operation. /// REST API Reference for CreatePreparedStatement Operation IAsyncResult BeginCreatePreparedStatement(CreatePreparedStatementRequest request, AsyncCallback callback, object state); ///

/// Finishes the asynchronous execution of the CreatePreparedStatement operation. ///

/// /// The IAsyncResult returned by the call to BeginCreatePreparedStatement. /// /// Returns a CreatePreparedStatementResult from Athena. /// REST API Reference for CreatePreparedStatement Operation CreatePreparedStatementResponse EndCreatePreparedStatement(IAsyncResult asyncResult); #endregion #region CreatePresignedNotebookUrl ///

/// 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. ///

/// Container for the necessary parameters to execute the CreatePresignedNotebookUrl service method. /// /// The response from the CreatePresignedNotebookUrl service method, as returned by Athena. /// /// Indicates a platform issue, which may be due to a transient condition or outage. /// /// /// Indicates that something is wrong with the input to the request. For example, a required /// parameter may be missing or out of range. /// /// /// A resource, such as a workgroup, was not found. /// /// REST API Reference for CreatePresignedNotebookUrl Operation CreatePresignedNotebookUrlResponse CreatePresignedNotebookUrl(CreatePresignedNotebookUrlRequest request); ///

/// Initiates the asynchronous execution of the CreatePresignedNotebookUrl operation. ///

/// /// Container for the necessary parameters to execute the CreatePresignedNotebookUrl operation on AmazonAthenaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreatePresignedNotebookUrl /// operation. /// REST API Reference for CreatePresignedNotebookUrl Operation IAsyncResult BeginCreatePresignedNotebookUrl(CreatePresignedNotebookUrlRequest request, AsyncCallback callback, object state); ///

/// Finishes the asynchronous execution of the CreatePresignedNotebookUrl operation. ///

/// /// The IAsyncResult returned by the call to BeginCreatePresignedNotebookUrl. /// /// Returns a CreatePresignedNotebookUrlResult from Athena. /// REST API Reference for CreatePresignedNotebookUrl Operation CreatePresignedNotebookUrlResponse EndCreatePresignedNotebookUrl(IAsyncResult asyncResult); #endregion #region CreateWorkGroup ///

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

/// Container for the necessary parameters to execute the CreateWorkGroup service method. /// /// The response from the CreateWorkGroup service method, as returned by Athena. /// /// Indicates a platform issue, which may be due to a transient condition or outage. /// /// /// Indicates that something is wrong with the input to the request. For example, a required /// parameter may be missing or out of range. /// /// REST API Reference for CreateWorkGroup Operation CreateWorkGroupResponse CreateWorkGroup(CreateWorkGroupRequest request); ///

/// Initiates the asynchronous execution of the CreateWorkGroup operation. ///

/// /// Container for the necessary parameters to execute the CreateWorkGroup operation on AmazonAthenaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateWorkGroup /// operation. /// REST API Reference for CreateWorkGroup Operation IAsyncResult BeginCreateWorkGroup(CreateWorkGroupRequest request, AsyncCallback callback, object state); ///

/// Finishes the asynchronous execution of the CreateWorkGroup operation. ///

/// /// The IAsyncResult returned by the call to BeginCreateWorkGroup. /// /// Returns a CreateWorkGroupResult from Athena. /// REST API Reference for CreateWorkGroup Operation CreateWorkGroupResponse EndCreateWorkGroup(IAsyncResult asyncResult); #endregion #region DeleteCapacityReservation ///

/// 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. ///

/// Container for the necessary parameters to execute the DeleteCapacityReservation service method. /// /// The response from the DeleteCapacityReservation service method, as returned by Athena. /// /// Indicates a platform issue, which may be due to a transient condition or outage. /// /// /// Indicates that something is wrong with the input to the request. For example, a required /// parameter may be missing or out of range. /// /// REST API Reference for DeleteCapacityReservation Operation DeleteCapacityReservationResponse DeleteCapacityReservation(DeleteCapacityReservationRequest request); ///

/// Initiates the asynchronous execution of the DeleteCapacityReservation operation. ///

/// /// Container for the necessary parameters to execute the DeleteCapacityReservation operation on AmazonAthenaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteCapacityReservation /// operation. /// REST API Reference for DeleteCapacityReservation Operation IAsyncResult BeginDeleteCapacityReservation(DeleteCapacityReservationRequest request, AsyncCallback callback, object state); ///

/// Finishes the asynchronous execution of the DeleteCapacityReservation operation. ///

/// /// The IAsyncResult returned by the call to BeginDeleteCapacityReservation. /// /// Returns a DeleteCapacityReservationResult from Athena. /// REST API Reference for DeleteCapacityReservation Operation DeleteCapacityReservationResponse EndDeleteCapacityReservation(IAsyncResult asyncResult); #endregion #region DeleteDataCatalog ///

/// Deletes a data catalog. ///

/// Container for the necessary parameters to execute the DeleteDataCatalog service method. /// /// The response from the DeleteDataCatalog service method, as returned by Athena. /// /// Indicates a platform issue, which may be due to a transient condition or outage. /// /// /// Indicates that something is wrong with the input to the request. For example, a required /// parameter may be missing or out of range. /// /// REST API Reference for DeleteDataCatalog Operation DeleteDataCatalogResponse DeleteDataCatalog(DeleteDataCatalogRequest request); ///

/// Initiates the asynchronous execution of the DeleteDataCatalog operation. ///

/// /// Container for the necessary parameters to execute the DeleteDataCatalog operation on AmazonAthenaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteDataCatalog /// operation. /// REST API Reference for DeleteDataCatalog Operation IAsyncResult BeginDeleteDataCatalog(DeleteDataCatalogRequest request, AsyncCallback callback, object state); ///

/// Finishes the asynchronous execution of the DeleteDataCatalog operation. ///

/// /// The IAsyncResult returned by the call to BeginDeleteDataCatalog. /// /// Returns a DeleteDataCatalogResult from Athena. /// REST API Reference for DeleteDataCatalog Operation DeleteDataCatalogResponse EndDeleteDataCatalog(IAsyncResult asyncResult); #endregion #region DeleteNamedQuery ///

/// 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. /// ///

/// Container for the necessary parameters to execute the DeleteNamedQuery service method. /// /// The response from the DeleteNamedQuery service method, as returned by Athena. /// /// Indicates a platform issue, which may be due to a transient condition or outage. /// /// /// Indicates that something is wrong with the input to the request. For example, a required /// parameter may be missing or out of range. /// /// REST API Reference for DeleteNamedQuery Operation DeleteNamedQueryResponse DeleteNamedQuery(DeleteNamedQueryRequest request); ///

/// Initiates the asynchronous execution of the DeleteNamedQuery operation. ///

/// /// Container for the necessary parameters to execute the DeleteNamedQuery operation on AmazonAthenaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteNamedQuery /// operation. /// REST API Reference for DeleteNamedQuery Operation IAsyncResult BeginDeleteNamedQuery(DeleteNamedQueryRequest request, AsyncCallback callback, object state); ///

/// Finishes the asynchronous execution of the DeleteNamedQuery operation. ///

/// /// The IAsyncResult returned by the call to BeginDeleteNamedQuery. /// /// Returns a DeleteNamedQueryResult from Athena. /// REST API Reference for DeleteNamedQuery Operation DeleteNamedQueryResponse EndDeleteNamedQuery(IAsyncResult asyncResult); #endregion #region DeleteNotebook ///

/// Deletes the specified notebook. ///

/// Container for the necessary parameters to execute the DeleteNotebook service method. /// /// The response from the DeleteNotebook service method, as returned by Athena. /// /// Indicates a platform issue, which may be due to a transient condition or outage. /// /// /// Indicates that something is wrong with the input to the request. For example, a required /// parameter may be missing or out of range. /// /// /// Indicates that the request was throttled. /// /// REST API Reference for DeleteNotebook Operation DeleteNotebookResponse DeleteNotebook(DeleteNotebookRequest request); ///

/// Initiates the asynchronous execution of the DeleteNotebook operation. ///

/// /// Container for the necessary parameters to execute the DeleteNotebook operation on AmazonAthenaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteNotebook /// operation. /// REST API Reference for DeleteNotebook Operation IAsyncResult BeginDeleteNotebook(DeleteNotebookRequest request, AsyncCallback callback, object state); ///

/// Finishes the asynchronous execution of the DeleteNotebook operation. ///

/// /// The IAsyncResult returned by the call to BeginDeleteNotebook. /// /// Returns a DeleteNotebookResult from Athena. /// REST API Reference for DeleteNotebook Operation DeleteNotebookResponse EndDeleteNotebook(IAsyncResult asyncResult); #endregion #region DeletePreparedStatement ///

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

/// Container for the necessary parameters to execute the DeletePreparedStatement service method. /// /// The response from the DeletePreparedStatement service method, as returned by Athena. /// /// Indicates a platform issue, which may be due to a transient condition or outage. /// /// /// Indicates that something is wrong with the input to the request. For example, a required /// parameter may be missing or out of range. /// /// /// A resource, such as a workgroup, was not found. /// /// REST API Reference for DeletePreparedStatement Operation DeletePreparedStatementResponse DeletePreparedStatement(DeletePreparedStatementRequest request); ///

/// Initiates the asynchronous execution of the DeletePreparedStatement operation. ///

/// /// Container for the necessary parameters to execute the DeletePreparedStatement operation on AmazonAthenaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeletePreparedStatement /// operation. /// REST API Reference for DeletePreparedStatement Operation IAsyncResult BeginDeletePreparedStatement(DeletePreparedStatementRequest request, AsyncCallback callback, object state); ///

/// Finishes the asynchronous execution of the DeletePreparedStatement operation. ///

/// /// The IAsyncResult returned by the call to BeginDeletePreparedStatement. /// /// Returns a DeletePreparedStatementResult from Athena. /// REST API Reference for DeletePreparedStatement Operation DeletePreparedStatementResponse EndDeletePreparedStatement(IAsyncResult asyncResult); #endregion #region DeleteWorkGroup ///

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

/// Container for the necessary parameters to execute the DeleteWorkGroup service method. /// /// The response from the DeleteWorkGroup service method, as returned by Athena. /// /// Indicates a platform issue, which may be due to a transient condition or outage. /// /// /// Indicates that something is wrong with the input to the request. For example, a required /// parameter may be missing or out of range. /// /// REST API Reference for DeleteWorkGroup Operation DeleteWorkGroupResponse DeleteWorkGroup(DeleteWorkGroupRequest request); ///

/// Initiates the asynchronous execution of the DeleteWorkGroup operation. ///

/// /// Container for the necessary parameters to execute the DeleteWorkGroup operation on AmazonAthenaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteWorkGroup /// operation. /// REST API Reference for DeleteWorkGroup Operation IAsyncResult BeginDeleteWorkGroup(DeleteWorkGroupRequest request, AsyncCallback callback, object state); ///

/// Finishes the asynchronous execution of the DeleteWorkGroup operation. ///

/// /// The IAsyncResult returned by the call to BeginDeleteWorkGroup. /// /// Returns a DeleteWorkGroupResult from Athena. /// REST API Reference for DeleteWorkGroup Operation DeleteWorkGroupResponse EndDeleteWorkGroup(IAsyncResult asyncResult); #endregion #region ExportNotebook ///

/// Exports the specified notebook and its metadata. ///

/// Container for the necessary parameters to execute the ExportNotebook service method. /// /// The response from the ExportNotebook service method, as returned by Athena. /// /// Indicates a platform issue, which may be due to a transient condition or outage. /// /// /// Indicates that something is wrong with the input to the request. For example, a required /// parameter may be missing or out of range. /// /// /// Indicates that the request was throttled. /// /// REST API Reference for ExportNotebook Operation ExportNotebookResponse ExportNotebook(ExportNotebookRequest request); ///

/// Initiates the asynchronous execution of the ExportNotebook operation. ///

/// /// Container for the necessary parameters to execute the ExportNotebook operation on AmazonAthenaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndExportNotebook /// operation. /// REST API Reference for ExportNotebook Operation IAsyncResult BeginExportNotebook(ExportNotebookRequest request, AsyncCallback callback, object state); ///

/// Finishes the asynchronous execution of the ExportNotebook operation. ///

/// /// The IAsyncResult returned by the call to BeginExportNotebook. /// /// Returns a ExportNotebookResult from Athena. /// REST API Reference for ExportNotebook Operation ExportNotebookResponse EndExportNotebook(IAsyncResult asyncResult); #endregion #region GetCalculationExecution ///

/// Describes a previously submitted calculation execution. ///

/// Container for the necessary parameters to execute the GetCalculationExecution service method. /// /// The response from the GetCalculationExecution service method, as returned by Athena. /// /// Indicates a platform issue, which may be due to a transient condition or outage. /// /// /// Indicates that something is wrong with the input to the request. For example, a required /// parameter may be missing or out of range. /// /// /// A resource, such as a workgroup, was not found. /// /// REST API Reference for GetCalculationExecution Operation GetCalculationExecutionResponse GetCalculationExecution(GetCalculationExecutionRequest request); ///

/// Initiates the asynchronous execution of the GetCalculationExecution operation. ///

/// /// Container for the necessary parameters to execute the GetCalculationExecution operation on AmazonAthenaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetCalculationExecution /// operation. /// REST API Reference for GetCalculationExecution Operation IAsyncResult BeginGetCalculationExecution(GetCalculationExecutionRequest request, AsyncCallback callback, object state); ///

/// Finishes the asynchronous execution of the GetCalculationExecution operation. ///

/// /// The IAsyncResult returned by the call to BeginGetCalculationExecution. /// /// Returns a GetCalculationExecutionResult from Athena. /// REST API Reference for GetCalculationExecution Operation GetCalculationExecutionResponse EndGetCalculationExecution(IAsyncResult asyncResult); #endregion #region GetCalculationExecutionCode ///

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

/// Container for the necessary parameters to execute the GetCalculationExecutionCode service method. /// /// The response from the GetCalculationExecutionCode service method, as returned by Athena. /// /// Indicates a platform issue, which may be due to a transient condition or outage. /// /// /// Indicates that something is wrong with the input to the request. For example, a required /// parameter may be missing or out of range. /// /// /// A resource, such as a workgroup, was not found. /// /// REST API Reference for GetCalculationExecutionCode Operation GetCalculationExecutionCodeResponse GetCalculationExecutionCode(GetCalculationExecutionCodeRequest request); ///

/// Initiates the asynchronous execution of the GetCalculationExecutionCode operation. ///

/// /// Container for the necessary parameters to execute the GetCalculationExecutionCode operation on AmazonAthenaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetCalculationExecutionCode /// operation. /// REST API Reference for GetCalculationExecutionCode Operation IAsyncResult BeginGetCalculationExecutionCode(GetCalculationExecutionCodeRequest request, AsyncCallback callback, object state); ///

/// Finishes the asynchronous execution of the GetCalculationExecutionCode operation. ///

/// /// The IAsyncResult returned by the call to BeginGetCalculationExecutionCode. /// /// Returns a GetCalculationExecutionCodeResult from Athena. /// REST API Reference for GetCalculationExecutionCode Operation GetCalculationExecutionCodeResponse EndGetCalculationExecutionCode(IAsyncResult asyncResult); #endregion #region GetCalculationExecutionStatus ///

/// Gets the status of a current calculation. ///

/// Container for the necessary parameters to execute the GetCalculationExecutionStatus service method. /// /// The response from the GetCalculationExecutionStatus service method, as returned by Athena. /// /// Indicates a platform issue, which may be due to a transient condition or outage. /// /// /// Indicates that something is wrong with the input to the request. For example, a required /// parameter may be missing or out of range. /// /// /// A resource, such as a workgroup, was not found. /// /// REST API Reference for GetCalculationExecutionStatus Operation GetCalculationExecutionStatusResponse GetCalculationExecutionStatus(GetCalculationExecutionStatusRequest request); ///

/// Initiates the asynchronous execution of the GetCalculationExecutionStatus operation. ///

/// /// Container for the necessary parameters to execute the GetCalculationExecutionStatus operation on AmazonAthenaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetCalculationExecutionStatus /// operation. /// REST API Reference for GetCalculationExecutionStatus Operation IAsyncResult BeginGetCalculationExecutionStatus(GetCalculationExecutionStatusRequest request, AsyncCallback callback, object state); ///

/// Finishes the asynchronous execution of the GetCalculationExecutionStatus operation. ///

/// /// The IAsyncResult returned by the call to BeginGetCalculationExecutionStatus. /// /// Returns a GetCalculationExecutionStatusResult from Athena. /// REST API Reference for GetCalculationExecutionStatus Operation GetCalculationExecutionStatusResponse EndGetCalculationExecutionStatus(IAsyncResult asyncResult); #endregion #region GetCapacityAssignmentConfiguration ///

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

/// Container for the necessary parameters to execute the GetCapacityAssignmentConfiguration service method. /// /// The response from the GetCapacityAssignmentConfiguration service method, as returned by Athena. /// /// Indicates a platform issue, which may be due to a transient condition or outage. /// /// /// Indicates that something is wrong with the input to the request. For example, a required /// parameter may be missing or out of range. /// /// REST API Reference for GetCapacityAssignmentConfiguration Operation GetCapacityAssignmentConfigurationResponse GetCapacityAssignmentConfiguration(GetCapacityAssignmentConfigurationRequest request); ///

/// Initiates the asynchronous execution of the GetCapacityAssignmentConfiguration operation. ///

/// /// Container for the necessary parameters to execute the GetCapacityAssignmentConfiguration operation on AmazonAthenaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetCapacityAssignmentConfiguration /// operation. /// REST API Reference for GetCapacityAssignmentConfiguration Operation IAsyncResult BeginGetCapacityAssignmentConfiguration(GetCapacityAssignmentConfigurationRequest request, AsyncCallback callback, object state); ///

/// Finishes the asynchronous execution of the GetCapacityAssignmentConfiguration operation. ///

/// /// The IAsyncResult returned by the call to BeginGetCapacityAssignmentConfiguration. /// /// Returns a GetCapacityAssignmentConfigurationResult from Athena. /// REST API Reference for GetCapacityAssignmentConfiguration Operation GetCapacityAssignmentConfigurationResponse EndGetCapacityAssignmentConfiguration(IAsyncResult asyncResult); #endregion #region GetCapacityReservation ///

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

/// Container for the necessary parameters to execute the GetCapacityReservation service method. /// /// The response from the GetCapacityReservation service method, as returned by Athena. /// /// Indicates a platform issue, which may be due to a transient condition or outage. /// /// /// Indicates that something is wrong with the input to the request. For example, a required /// parameter may be missing or out of range. /// /// REST API Reference for GetCapacityReservation Operation GetCapacityReservationResponse GetCapacityReservation(GetCapacityReservationRequest request); ///

/// Initiates the asynchronous execution of the GetCapacityReservation operation. ///

/// /// Container for the necessary parameters to execute the GetCapacityReservation operation on AmazonAthenaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetCapacityReservation /// operation. /// REST API Reference for GetCapacityReservation Operation IAsyncResult BeginGetCapacityReservation(GetCapacityReservationRequest request, AsyncCallback callback, object state); ///

/// Finishes the asynchronous execution of the GetCapacityReservation operation. ///

/// /// The IAsyncResult returned by the call to BeginGetCapacityReservation. /// /// Returns a GetCapacityReservationResult from Athena. /// REST API Reference for GetCapacityReservation Operation GetCapacityReservationResponse EndGetCapacityReservation(IAsyncResult asyncResult); #endregion #region GetDatabase ///

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

/// Container for the necessary parameters to execute the GetDatabase service method. /// /// The response from the GetDatabase service method, as returned by Athena. /// /// Indicates a platform issue, which may be due to a transient condition or outage. /// /// /// Indicates that something is wrong with the input to the request. For example, a required /// parameter may be missing or out of range. /// /// /// An exception that Athena received when it called a custom metastore. Occurs if the /// error is not caused by user input (InvalidRequestException) or from the /// Athena platform (InternalServerException). For example, if a user-created /// Lambda function is missing permissions, the Lambda 4XX exception is returned /// in a MetadataException. /// /// REST API Reference for GetDatabase Operation GetDatabaseResponse GetDatabase(GetDatabaseRequest request); ///

/// Initiates the asynchronous execution of the GetDatabase operation. ///

/// /// Container for the necessary parameters to execute the GetDatabase operation on AmazonAthenaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetDatabase /// operation. /// REST API Reference for GetDatabase Operation IAsyncResult BeginGetDatabase(GetDatabaseRequest request, AsyncCallback callback, object state); ///

/// Finishes the asynchronous execution of the GetDatabase operation. ///

/// /// The IAsyncResult returned by the call to BeginGetDatabase. /// /// Returns a GetDatabaseResult from Athena. /// REST API Reference for GetDatabase Operation GetDatabaseResponse EndGetDatabase(IAsyncResult asyncResult); #endregion #region GetDataCatalog ///

/// Returns the specified data catalog. ///

/// Container for the necessary parameters to execute the GetDataCatalog service method. /// /// The response from the GetDataCatalog service method, as returned by Athena. /// /// Indicates a platform issue, which may be due to a transient condition or outage. /// /// /// Indicates that something is wrong with the input to the request. For example, a required /// parameter may be missing or out of range. /// /// REST API Reference for GetDataCatalog Operation GetDataCatalogResponse GetDataCatalog(GetDataCatalogRequest request); ///

/// Initiates the asynchronous execution of the GetDataCatalog operation. ///

/// /// Container for the necessary parameters to execute the GetDataCatalog operation on AmazonAthenaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetDataCatalog /// operation. /// REST API Reference for GetDataCatalog Operation IAsyncResult BeginGetDataCatalog(GetDataCatalogRequest request, AsyncCallback callback, object state); ///

/// Finishes the asynchronous execution of the GetDataCatalog operation. ///

/// /// The IAsyncResult returned by the call to BeginGetDataCatalog. /// /// Returns a GetDataCatalogResult from Athena. /// REST API Reference for GetDataCatalog Operation GetDataCatalogResponse EndGetDataCatalog(IAsyncResult asyncResult); #endregion #region GetNamedQuery ///

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

/// Container for the necessary parameters to execute the GetNamedQuery service method. /// /// The response from the GetNamedQuery service method, as returned by Athena. /// /// Indicates a platform issue, which may be due to a transient condition or outage. /// /// /// Indicates that something is wrong with the input to the request. For example, a required /// parameter may be missing or out of range. /// /// REST API Reference for GetNamedQuery Operation GetNamedQueryResponse GetNamedQuery(GetNamedQueryRequest request); ///

/// Initiates the asynchronous execution of the GetNamedQuery operation. ///

/// /// Container for the necessary parameters to execute the GetNamedQuery operation on AmazonAthenaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetNamedQuery /// operation. /// REST API Reference for GetNamedQuery Operation IAsyncResult BeginGetNamedQuery(GetNamedQueryRequest request, AsyncCallback callback, object state); ///

/// Finishes the asynchronous execution of the GetNamedQuery operation. ///

/// /// The IAsyncResult returned by the call to BeginGetNamedQuery. /// /// Returns a GetNamedQueryResult from Athena. /// REST API Reference for GetNamedQuery Operation GetNamedQueryResponse EndGetNamedQuery(IAsyncResult asyncResult); #endregion #region GetNotebookMetadata ///

/// Retrieves notebook metadata for the specified notebook ID. ///

/// Container for the necessary parameters to execute the GetNotebookMetadata service method. /// /// The response from the GetNotebookMetadata service method, as returned by Athena. /// /// Indicates a platform issue, which may be due to a transient condition or outage. /// /// /// Indicates that something is wrong with the input to the request. For example, a required /// parameter may be missing or out of range. /// /// /// Indicates that the request was throttled. /// /// REST API Reference for GetNotebookMetadata Operation GetNotebookMetadataResponse GetNotebookMetadata(GetNotebookMetadataRequest request); ///

/// Initiates the asynchronous execution of the GetNotebookMetadata operation. ///

/// /// Container for the necessary parameters to execute the GetNotebookMetadata operation on AmazonAthenaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetNotebookMetadata /// operation. /// REST API Reference for GetNotebookMetadata Operation IAsyncResult BeginGetNotebookMetadata(GetNotebookMetadataRequest request, AsyncCallback callback, object state); ///

/// Finishes the asynchronous execution of the GetNotebookMetadata operation. ///

/// /// The IAsyncResult returned by the call to BeginGetNotebookMetadata. /// /// Returns a GetNotebookMetadataResult from Athena. /// REST API Reference for GetNotebookMetadata Operation GetNotebookMetadataResponse EndGetNotebookMetadata(IAsyncResult asyncResult); #endregion #region GetPreparedStatement ///

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

/// Container for the necessary parameters to execute the GetPreparedStatement service method. /// /// The response from the GetPreparedStatement service method, as returned by Athena. /// /// Indicates a platform issue, which may be due to a transient condition or outage. /// /// /// Indicates that something is wrong with the input to the request. For example, a required /// parameter may be missing or out of range. /// /// /// A resource, such as a workgroup, was not found. /// /// REST API Reference for GetPreparedStatement Operation GetPreparedStatementResponse GetPreparedStatement(GetPreparedStatementRequest request); ///

/// Initiates the asynchronous execution of the GetPreparedStatement operation. ///

/// /// Container for the necessary parameters to execute the GetPreparedStatement operation on AmazonAthenaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetPreparedStatement /// operation. /// REST API Reference for GetPreparedStatement Operation IAsyncResult BeginGetPreparedStatement(GetPreparedStatementRequest request, AsyncCallback callback, object state); ///

/// Finishes the asynchronous execution of the GetPreparedStatement operation. ///

/// /// The IAsyncResult returned by the call to BeginGetPreparedStatement. /// /// Returns a GetPreparedStatementResult from Athena. /// REST API Reference for GetPreparedStatement Operation GetPreparedStatementResponse EndGetPreparedStatement(IAsyncResult asyncResult); #endregion #region GetQueryExecution ///

/// 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. ///

/// Container for the necessary parameters to execute the GetQueryExecution service method. /// /// The response from the GetQueryExecution service method, as returned by Athena. /// /// Indicates a platform issue, which may be due to a transient condition or outage. /// /// /// Indicates that something is wrong with the input to the request. For example, a required /// parameter may be missing or out of range. /// /// REST API Reference for GetQueryExecution Operation GetQueryExecutionResponse GetQueryExecution(GetQueryExecutionRequest request); ///

/// Initiates the asynchronous execution of the GetQueryExecution operation. ///

/// /// Container for the necessary parameters to execute the GetQueryExecution operation on AmazonAthenaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetQueryExecution /// operation. /// REST API Reference for GetQueryExecution Operation IAsyncResult BeginGetQueryExecution(GetQueryExecutionRequest request, AsyncCallback callback, object state); ///

/// Finishes the asynchronous execution of the GetQueryExecution operation. ///

/// /// The IAsyncResult returned by the call to BeginGetQueryExecution. /// /// Returns a GetQueryExecutionResult from Athena. /// REST API Reference for GetQueryExecution Operation GetQueryExecutionResponse EndGetQueryExecution(IAsyncResult asyncResult); #endregion #region GetQueryResults ///

/// 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. /// /// ///

/// Container for the necessary parameters to execute the GetQueryResults service method. /// /// The response from the GetQueryResults service method, as returned by Athena. /// /// Indicates a platform issue, which may be due to a transient condition or outage. /// /// /// Indicates that something is wrong with the input to the request. For example, a required /// parameter may be missing or out of range. /// /// /// Indicates that the request was throttled. /// /// REST API Reference for GetQueryResults Operation GetQueryResultsResponse GetQueryResults(GetQueryResultsRequest request); ///

/// Initiates the asynchronous execution of the GetQueryResults operation. ///

/// /// Container for the necessary parameters to execute the GetQueryResults operation on AmazonAthenaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetQueryResults /// operation. /// REST API Reference for GetQueryResults Operation IAsyncResult BeginGetQueryResults(GetQueryResultsRequest request, AsyncCallback callback, object state); ///

/// Finishes the asynchronous execution of the GetQueryResults operation. ///

/// /// The IAsyncResult returned by the call to BeginGetQueryResults. /// /// Returns a GetQueryResultsResult from Athena. /// REST API Reference for GetQueryResults Operation GetQueryResultsResponse EndGetQueryResults(IAsyncResult asyncResult); #endregion #region GetQueryRuntimeStatistics ///

/// 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. ///

/// Container for the necessary parameters to execute the GetQueryRuntimeStatistics service method. /// /// The response from the GetQueryRuntimeStatistics service method, as returned by Athena. /// /// Indicates a platform issue, which may be due to a transient condition or outage. /// /// /// Indicates that something is wrong with the input to the request. For example, a required /// parameter may be missing or out of range. /// /// REST API Reference for GetQueryRuntimeStatistics Operation GetQueryRuntimeStatisticsResponse GetQueryRuntimeStatistics(GetQueryRuntimeStatisticsRequest request); ///

/// Initiates the asynchronous execution of the GetQueryRuntimeStatistics operation. ///

/// /// Container for the necessary parameters to execute the GetQueryRuntimeStatistics operation on AmazonAthenaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetQueryRuntimeStatistics /// operation. /// REST API Reference for GetQueryRuntimeStatistics Operation IAsyncResult BeginGetQueryRuntimeStatistics(GetQueryRuntimeStatisticsRequest request, AsyncCallback callback, object state); ///

/// Finishes the asynchronous execution of the GetQueryRuntimeStatistics operation. ///

/// /// The IAsyncResult returned by the call to BeginGetQueryRuntimeStatistics. /// /// Returns a GetQueryRuntimeStatisticsResult from Athena. /// REST API Reference for GetQueryRuntimeStatistics Operation GetQueryRuntimeStatisticsResponse EndGetQueryRuntimeStatistics(IAsyncResult asyncResult); #endregion #region GetSession ///

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

/// Container for the necessary parameters to execute the GetSession service method. /// /// The response from the GetSession service method, as returned by Athena. /// /// Indicates a platform issue, which may be due to a transient condition or outage. /// /// /// Indicates that something is wrong with the input to the request. For example, a required /// parameter may be missing or out of range. /// /// /// A resource, such as a workgroup, was not found. /// /// REST API Reference for GetSession Operation GetSessionResponse GetSession(GetSessionRequest request); ///

/// Initiates the asynchronous execution of the GetSession operation. ///

/// /// Container for the necessary parameters to execute the GetSession operation on AmazonAthenaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetSession /// operation. /// REST API Reference for GetSession Operation IAsyncResult BeginGetSession(GetSessionRequest request, AsyncCallback callback, object state); ///

/// Finishes the asynchronous execution of the GetSession operation. ///

/// /// The IAsyncResult returned by the call to BeginGetSession. /// /// Returns a GetSessionResult from Athena. /// REST API Reference for GetSession Operation GetSessionResponse EndGetSession(IAsyncResult asyncResult); #endregion #region GetSessionStatus ///

/// Gets the current status of a session. ///

/// Container for the necessary parameters to execute the GetSessionStatus service method. /// /// The response from the GetSessionStatus service method, as returned by Athena. /// /// Indicates a platform issue, which may be due to a transient condition or outage. /// /// /// Indicates that something is wrong with the input to the request. For example, a required /// parameter may be missing or out of range. /// /// /// A resource, such as a workgroup, was not found. /// /// REST API Reference for GetSessionStatus Operation GetSessionStatusResponse GetSessionStatus(GetSessionStatusRequest request); ///

/// Initiates the asynchronous execution of the GetSessionStatus operation. ///

/// /// Container for the necessary parameters to execute the GetSessionStatus operation on AmazonAthenaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetSessionStatus /// operation. /// REST API Reference for GetSessionStatus Operation IAsyncResult BeginGetSessionStatus(GetSessionStatusRequest request, AsyncCallback callback, object state); ///

/// Finishes the asynchronous execution of the GetSessionStatus operation. ///

/// /// The IAsyncResult returned by the call to BeginGetSessionStatus. /// /// Returns a GetSessionStatusResult from Athena. /// REST API Reference for GetSessionStatus Operation GetSessionStatusResponse EndGetSessionStatus(IAsyncResult asyncResult); #endregion #region GetTableMetadata ///

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

/// Container for the necessary parameters to execute the GetTableMetadata service method. /// /// The response from the GetTableMetadata service method, as returned by Athena. /// /// Indicates a platform issue, which may be due to a transient condition or outage. /// /// /// Indicates that something is wrong with the input to the request. For example, a required /// parameter may be missing or out of range. /// /// /// An exception that Athena received when it called a custom metastore. Occurs if the /// error is not caused by user input (InvalidRequestException) or from the /// Athena platform (InternalServerException). For example, if a user-created /// Lambda function is missing permissions, the Lambda 4XX exception is returned /// in a MetadataException. /// /// REST API Reference for GetTableMetadata Operation GetTableMetadataResponse GetTableMetadata(GetTableMetadataRequest request); ///

/// Initiates the asynchronous execution of the GetTableMetadata operation. ///

/// /// Container for the necessary parameters to execute the GetTableMetadata operation on AmazonAthenaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetTableMetadata /// operation. /// REST API Reference for GetTableMetadata Operation IAsyncResult BeginGetTableMetadata(GetTableMetadataRequest request, AsyncCallback callback, object state); ///

/// Finishes the asynchronous execution of the GetTableMetadata operation. ///

/// /// The IAsyncResult returned by the call to BeginGetTableMetadata. /// /// Returns a GetTableMetadataResult from Athena. /// REST API Reference for GetTableMetadata Operation GetTableMetadataResponse EndGetTableMetadata(IAsyncResult asyncResult); #endregion #region GetWorkGroup ///

/// Returns information about the workgroup with the specified name. ///

/// Container for the necessary parameters to execute the GetWorkGroup service method. /// /// The response from the GetWorkGroup service method, as returned by Athena. /// /// Indicates a platform issue, which may be due to a transient condition or outage. /// /// /// Indicates that something is wrong with the input to the request. For example, a required /// parameter may be missing or out of range. /// /// REST API Reference for GetWorkGroup Operation GetWorkGroupResponse GetWorkGroup(GetWorkGroupRequest request); ///

/// Initiates the asynchronous execution of the GetWorkGroup operation. ///

/// /// Container for the necessary parameters to execute the GetWorkGroup operation on AmazonAthenaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetWorkGroup /// operation. /// REST API Reference for GetWorkGroup Operation IAsyncResult BeginGetWorkGroup(GetWorkGroupRequest request, AsyncCallback callback, object state); ///

/// Finishes the asynchronous execution of the GetWorkGroup operation. ///

/// /// The IAsyncResult returned by the call to BeginGetWorkGroup. /// /// Returns a GetWorkGroupResult from Athena. /// REST API Reference for GetWorkGroup Operation GetWorkGroupResponse EndGetWorkGroup(IAsyncResult asyncResult); #endregion #region ImportNotebook ///

/// 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. ///

/// Container for the necessary parameters to execute the ImportNotebook service method. /// /// The response from the ImportNotebook service method, as returned by Athena. /// /// Indicates a platform issue, which may be due to a transient condition or outage. /// /// /// Indicates that something is wrong with the input to the request. For example, a required /// parameter may be missing or out of range. /// /// /// Indicates that the request was throttled. /// /// REST API Reference for ImportNotebook Operation ImportNotebookResponse ImportNotebook(ImportNotebookRequest request); ///

/// Initiates the asynchronous execution of the ImportNotebook operation. ///

/// /// Container for the necessary parameters to execute the ImportNotebook operation on AmazonAthenaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndImportNotebook /// operation. /// REST API Reference for ImportNotebook Operation IAsyncResult BeginImportNotebook(ImportNotebookRequest request, AsyncCallback callback, object state); ///

/// Finishes the asynchronous execution of the ImportNotebook operation. ///

/// /// The IAsyncResult returned by the call to BeginImportNotebook. /// /// Returns a ImportNotebookResult from Athena. /// REST API Reference for ImportNotebook Operation ImportNotebookResponse EndImportNotebook(IAsyncResult asyncResult); #endregion #region ListApplicationDPUSizes ///

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

/// Container for the necessary parameters to execute the ListApplicationDPUSizes service method. /// /// The response from the ListApplicationDPUSizes service method, as returned by Athena. /// /// Indicates a platform issue, which may be due to a transient condition or outage. /// /// /// Indicates that something is wrong with the input to the request. For example, a required /// parameter may be missing or out of range. /// /// /// Indicates that the request was throttled. /// /// REST API Reference for ListApplicationDPUSizes Operation ListApplicationDPUSizesResponse ListApplicationDPUSizes(ListApplicationDPUSizesRequest request); ///

/// Initiates the asynchronous execution of the ListApplicationDPUSizes operation. ///

/// /// Container for the necessary parameters to execute the ListApplicationDPUSizes operation on AmazonAthenaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListApplicationDPUSizes /// operation. /// REST API Reference for ListApplicationDPUSizes Operation IAsyncResult BeginListApplicationDPUSizes(ListApplicationDPUSizesRequest request, AsyncCallback callback, object state); ///

/// Finishes the asynchronous execution of the ListApplicationDPUSizes operation. ///

/// /// The IAsyncResult returned by the call to BeginListApplicationDPUSizes. /// /// Returns a ListApplicationDPUSizesResult from Athena. /// REST API Reference for ListApplicationDPUSizes Operation ListApplicationDPUSizesResponse EndListApplicationDPUSizes(IAsyncResult asyncResult); #endregion #region ListCalculationExecutions ///

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

/// Container for the necessary parameters to execute the ListCalculationExecutions service method. /// /// The response from the ListCalculationExecutions service method, as returned by Athena. /// /// Indicates a platform issue, which may be due to a transient condition or outage. /// /// /// Indicates that something is wrong with the input to the request. For example, a required /// parameter may be missing or out of range. /// /// /// A resource, such as a workgroup, was not found. /// /// REST API Reference for ListCalculationExecutions Operation ListCalculationExecutionsResponse ListCalculationExecutions(ListCalculationExecutionsRequest request); ///

/// Initiates the asynchronous execution of the ListCalculationExecutions operation. ///

/// /// Container for the necessary parameters to execute the ListCalculationExecutions operation on AmazonAthenaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListCalculationExecutions /// operation. /// REST API Reference for ListCalculationExecutions Operation IAsyncResult BeginListCalculationExecutions(ListCalculationExecutionsRequest request, AsyncCallback callback, object state); ///

/// Finishes the asynchronous execution of the ListCalculationExecutions operation. ///

/// /// The IAsyncResult returned by the call to BeginListCalculationExecutions. /// /// Returns a ListCalculationExecutionsResult from Athena. /// REST API Reference for ListCalculationExecutions Operation ListCalculationExecutionsResponse EndListCalculationExecutions(IAsyncResult asyncResult); #endregion #region ListCapacityReservations ///

/// Lists the capacity reservations for the current account. ///

/// Container for the necessary parameters to execute the ListCapacityReservations service method. /// /// The response from the ListCapacityReservations service method, as returned by Athena. /// /// Indicates a platform issue, which may be due to a transient condition or outage. /// /// /// Indicates that something is wrong with the input to the request. For example, a required /// parameter may be missing or out of range. /// /// REST API Reference for ListCapacityReservations Operation ListCapacityReservationsResponse ListCapacityReservations(ListCapacityReservationsRequest request); ///

/// Initiates the asynchronous execution of the ListCapacityReservations operation. ///

/// /// Container for the necessary parameters to execute the ListCapacityReservations operation on AmazonAthenaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListCapacityReservations /// operation. /// REST API Reference for ListCapacityReservations Operation IAsyncResult BeginListCapacityReservations(ListCapacityReservationsRequest request, AsyncCallback callback, object state); ///

/// Finishes the asynchronous execution of the ListCapacityReservations operation. ///

/// /// The IAsyncResult returned by the call to BeginListCapacityReservations. /// /// Returns a ListCapacityReservationsResult from Athena. /// REST API Reference for ListCapacityReservations Operation ListCapacityReservationsResponse EndListCapacityReservations(IAsyncResult asyncResult); #endregion #region ListDatabases ///

/// Lists the databases in the specified data catalog. ///

/// Container for the necessary parameters to execute the ListDatabases service method. /// /// The response from the ListDatabases service method, as returned by Athena. /// /// Indicates a platform issue, which may be due to a transient condition or outage. /// /// /// Indicates that something is wrong with the input to the request. For example, a required /// parameter may be missing or out of range. /// /// /// An exception that Athena received when it called a custom metastore. Occurs if the /// error is not caused by user input (InvalidRequestException) or from the /// Athena platform (InternalServerException). For example, if a user-created /// Lambda function is missing permissions, the Lambda 4XX exception is returned /// in a MetadataException. /// /// REST API Reference for ListDatabases Operation ListDatabasesResponse ListDatabases(ListDatabasesRequest request); ///

/// Initiates the asynchronous execution of the ListDatabases operation. ///

/// /// Container for the necessary parameters to execute the ListDatabases operation on AmazonAthenaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListDatabases /// operation. /// REST API Reference for ListDatabases Operation IAsyncResult BeginListDatabases(ListDatabasesRequest request, AsyncCallback callback, object state); ///

/// Finishes the asynchronous execution of the ListDatabases operation. ///

/// /// The IAsyncResult returned by the call to BeginListDatabases. /// /// Returns a ListDatabasesResult from Athena. /// REST API Reference for ListDatabases Operation ListDatabasesResponse EndListDatabases(IAsyncResult asyncResult); #endregion #region ListDataCatalogs ///

/// 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. /// /// ///

/// Container for the necessary parameters to execute the ListDataCatalogs service method. /// /// The response from the ListDataCatalogs service method, as returned by Athena. /// /// Indicates a platform issue, which may be due to a transient condition or outage. /// /// /// Indicates that something is wrong with the input to the request. For example, a required /// parameter may be missing or out of range. /// /// REST API Reference for ListDataCatalogs Operation ListDataCatalogsResponse ListDataCatalogs(ListDataCatalogsRequest request); ///

/// Initiates the asynchronous execution of the ListDataCatalogs operation. ///

/// /// Container for the necessary parameters to execute the ListDataCatalogs operation on AmazonAthenaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListDataCatalogs /// operation. /// REST API Reference for ListDataCatalogs Operation IAsyncResult BeginListDataCatalogs(ListDataCatalogsRequest request, AsyncCallback callback, object state); ///

/// Finishes the asynchronous execution of the ListDataCatalogs operation. ///

/// /// The IAsyncResult returned by the call to BeginListDataCatalogs. /// /// Returns a ListDataCatalogsResult from Athena. /// REST API Reference for ListDataCatalogs Operation ListDataCatalogsResponse EndListDataCatalogs(IAsyncResult asyncResult); #endregion #region ListEngineVersions ///

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

/// Container for the necessary parameters to execute the ListEngineVersions service method. /// /// The response from the ListEngineVersions service method, as returned by Athena. /// /// Indicates a platform issue, which may be due to a transient condition or outage. /// /// /// Indicates that something is wrong with the input to the request. For example, a required /// parameter may be missing or out of range. /// /// REST API Reference for ListEngineVersions Operation ListEngineVersionsResponse ListEngineVersions(ListEngineVersionsRequest request); ///

/// Initiates the asynchronous execution of the ListEngineVersions operation. ///

/// /// Container for the necessary parameters to execute the ListEngineVersions operation on AmazonAthenaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListEngineVersions /// operation. /// REST API Reference for ListEngineVersions Operation IAsyncResult BeginListEngineVersions(ListEngineVersionsRequest request, AsyncCallback callback, object state); ///

/// Finishes the asynchronous execution of the ListEngineVersions operation. ///

/// /// The IAsyncResult returned by the call to BeginListEngineVersions. /// /// Returns a ListEngineVersionsResult from Athena. /// REST API Reference for ListEngineVersions Operation ListEngineVersionsResponse EndListEngineVersions(IAsyncResult asyncResult); #endregion #region ListExecutors ///

/// 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. ///

/// Container for the necessary parameters to execute the ListExecutors service method. /// /// The response from the ListExecutors service method, as returned by Athena. /// /// Indicates a platform issue, which may be due to a transient condition or outage. /// /// /// Indicates that something is wrong with the input to the request. For example, a required /// parameter may be missing or out of range. /// /// /// A resource, such as a workgroup, was not found. /// /// REST API Reference for ListExecutors Operation ListExecutorsResponse ListExecutors(ListExecutorsRequest request); ///

/// Initiates the asynchronous execution of the ListExecutors operation. ///

/// /// Container for the necessary parameters to execute the ListExecutors operation on AmazonAthenaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListExecutors /// operation. /// REST API Reference for ListExecutors Operation IAsyncResult BeginListExecutors(ListExecutorsRequest request, AsyncCallback callback, object state); ///

/// Finishes the asynchronous execution of the ListExecutors operation. ///

/// /// The IAsyncResult returned by the call to BeginListExecutors. /// /// Returns a ListExecutorsResult from Athena. /// REST API Reference for ListExecutors Operation ListExecutorsResponse EndListExecutors(IAsyncResult asyncResult); #endregion #region ListNamedQueries ///

/// 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. /// ///

/// Container for the necessary parameters to execute the ListNamedQueries service method. /// /// The response from the ListNamedQueries service method, as returned by Athena. /// /// Indicates a platform issue, which may be due to a transient condition or outage. /// /// /// Indicates that something is wrong with the input to the request. For example, a required /// parameter may be missing or out of range. /// /// REST API Reference for ListNamedQueries Operation ListNamedQueriesResponse ListNamedQueries(ListNamedQueriesRequest request); ///

/// Initiates the asynchronous execution of the ListNamedQueries operation. ///

/// /// Container for the necessary parameters to execute the ListNamedQueries operation on AmazonAthenaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListNamedQueries /// operation. /// REST API Reference for ListNamedQueries Operation IAsyncResult BeginListNamedQueries(ListNamedQueriesRequest request, AsyncCallback callback, object state); ///

/// Finishes the asynchronous execution of the ListNamedQueries operation. ///

/// /// The IAsyncResult returned by the call to BeginListNamedQueries. /// /// Returns a ListNamedQueriesResult from Athena. /// REST API Reference for ListNamedQueries Operation ListNamedQueriesResponse EndListNamedQueries(IAsyncResult asyncResult); #endregion #region ListNotebookMetadata ///

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

/// Container for the necessary parameters to execute the ListNotebookMetadata service method. /// /// The response from the ListNotebookMetadata service method, as returned by Athena. /// /// Indicates a platform issue, which may be due to a transient condition or outage. /// /// /// Indicates that something is wrong with the input to the request. For example, a required /// parameter may be missing or out of range. /// /// /// Indicates that the request was throttled. /// /// REST API Reference for ListNotebookMetadata Operation ListNotebookMetadataResponse ListNotebookMetadata(ListNotebookMetadataRequest request); ///

/// Initiates the asynchronous execution of the ListNotebookMetadata operation. ///

/// /// Container for the necessary parameters to execute the ListNotebookMetadata operation on AmazonAthenaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListNotebookMetadata /// operation. /// REST API Reference for ListNotebookMetadata Operation IAsyncResult BeginListNotebookMetadata(ListNotebookMetadataRequest request, AsyncCallback callback, object state); ///

/// Finishes the asynchronous execution of the ListNotebookMetadata operation. ///

/// /// The IAsyncResult returned by the call to BeginListNotebookMetadata. /// /// Returns a ListNotebookMetadataResult from Athena. /// REST API Reference for ListNotebookMetadata Operation ListNotebookMetadataResponse EndListNotebookMetadata(IAsyncResult asyncResult); #endregion #region ListNotebookSessions ///

/// 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. ///

/// Container for the necessary parameters to execute the ListNotebookSessions service method. /// /// The response from the ListNotebookSessions service method, as returned by Athena. /// /// Indicates a platform issue, which may be due to a transient condition or outage. /// /// /// Indicates that something is wrong with the input to the request. For example, a required /// parameter may be missing or out of range. /// /// /// A resource, such as a workgroup, was not found. /// /// REST API Reference for ListNotebookSessions Operation ListNotebookSessionsResponse ListNotebookSessions(ListNotebookSessionsRequest request); ///

/// Initiates the asynchronous execution of the ListNotebookSessions operation. ///

/// /// Container for the necessary parameters to execute the ListNotebookSessions operation on AmazonAthenaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListNotebookSessions /// operation. /// REST API Reference for ListNotebookSessions Operation IAsyncResult BeginListNotebookSessions(ListNotebookSessionsRequest request, AsyncCallback callback, object state); ///

/// Finishes the asynchronous execution of the ListNotebookSessions operation. ///

/// /// The IAsyncResult returned by the call to BeginListNotebookSessions. /// /// Returns a ListNotebookSessionsResult from Athena. /// REST API Reference for ListNotebookSessions Operation ListNotebookSessionsResponse EndListNotebookSessions(IAsyncResult asyncResult); #endregion #region ListPreparedStatements ///

/// Lists the prepared statements in the specified workgroup. ///

/// Container for the necessary parameters to execute the ListPreparedStatements service method. /// /// The response from the ListPreparedStatements service method, as returned by Athena. /// /// Indicates a platform issue, which may be due to a transient condition or outage. /// /// /// Indicates that something is wrong with the input to the request. For example, a required /// parameter may be missing or out of range. /// /// REST API Reference for ListPreparedStatements Operation ListPreparedStatementsResponse ListPreparedStatements(ListPreparedStatementsRequest request); ///

/// Initiates the asynchronous execution of the ListPreparedStatements operation. ///

/// /// Container for the necessary parameters to execute the ListPreparedStatements operation on AmazonAthenaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListPreparedStatements /// operation. /// REST API Reference for ListPreparedStatements Operation IAsyncResult BeginListPreparedStatements(ListPreparedStatementsRequest request, AsyncCallback callback, object state); ///

/// Finishes the asynchronous execution of the ListPreparedStatements operation. ///

/// /// The IAsyncResult returned by the call to BeginListPreparedStatements. /// /// Returns a ListPreparedStatementsResult from Athena. /// REST API Reference for ListPreparedStatements Operation ListPreparedStatementsResponse EndListPreparedStatements(IAsyncResult asyncResult); #endregion #region ListQueryExecutions ///

/// 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. /// ///

/// Container for the necessary parameters to execute the ListQueryExecutions service method. /// /// The response from the ListQueryExecutions service method, as returned by Athena. /// /// Indicates a platform issue, which may be due to a transient condition or outage. /// /// /// Indicates that something is wrong with the input to the request. For example, a required /// parameter may be missing or out of range. /// /// REST API Reference for ListQueryExecutions Operation ListQueryExecutionsResponse ListQueryExecutions(ListQueryExecutionsRequest request); ///

/// Initiates the asynchronous execution of the ListQueryExecutions operation. ///

/// /// Container for the necessary parameters to execute the ListQueryExecutions operation on AmazonAthenaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListQueryExecutions /// operation. /// REST API Reference for ListQueryExecutions Operation IAsyncResult BeginListQueryExecutions(ListQueryExecutionsRequest request, AsyncCallback callback, object state); ///

/// Finishes the asynchronous execution of the ListQueryExecutions operation. ///

/// /// The IAsyncResult returned by the call to BeginListQueryExecutions. /// /// Returns a ListQueryExecutionsResult from Athena. /// REST API Reference for ListQueryExecutions Operation ListQueryExecutionsResponse EndListQueryExecutions(IAsyncResult asyncResult); #endregion #region ListSessions ///

/// 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. ///

/// Container for the necessary parameters to execute the ListSessions service method. /// /// The response from the ListSessions service method, as returned by Athena. /// /// Indicates a platform issue, which may be due to a transient condition or outage. /// /// /// Indicates that something is wrong with the input to the request. For example, a required /// parameter may be missing or out of range. /// /// /// A resource, such as a workgroup, was not found. /// /// REST API Reference for ListSessions Operation ListSessionsResponse ListSessions(ListSessionsRequest request); ///

/// Initiates the asynchronous execution of the ListSessions operation. ///

/// /// Container for the necessary parameters to execute the ListSessions operation on AmazonAthenaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListSessions /// operation. /// REST API Reference for ListSessions Operation IAsyncResult BeginListSessions(ListSessionsRequest request, AsyncCallback callback, object state); ///

/// Finishes the asynchronous execution of the ListSessions operation. ///

/// /// The IAsyncResult returned by the call to BeginListSessions. /// /// Returns a ListSessionsResult from Athena. /// REST API Reference for ListSessions Operation ListSessionsResponse EndListSessions(IAsyncResult asyncResult); #endregion #region ListTableMetadata ///

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

/// Container for the necessary parameters to execute the ListTableMetadata service method. /// /// The response from the ListTableMetadata service method, as returned by Athena. /// /// Indicates a platform issue, which may be due to a transient condition or outage. /// /// /// Indicates that something is wrong with the input to the request. For example, a required /// parameter may be missing or out of range. /// /// /// An exception that Athena received when it called a custom metastore. Occurs if the /// error is not caused by user input (InvalidRequestException) or from the /// Athena platform (InternalServerException). For example, if a user-created /// Lambda function is missing permissions, the Lambda 4XX exception is returned /// in a MetadataException. /// /// REST API Reference for ListTableMetadata Operation ListTableMetadataResponse ListTableMetadata(ListTableMetadataRequest request); ///

/// Initiates the asynchronous execution of the ListTableMetadata operation. ///

/// /// Container for the necessary parameters to execute the ListTableMetadata operation on AmazonAthenaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListTableMetadata /// operation. /// REST API Reference for ListTableMetadata Operation IAsyncResult BeginListTableMetadata(ListTableMetadataRequest request, AsyncCallback callback, object state); ///

/// Finishes the asynchronous execution of the ListTableMetadata operation. ///

/// /// The IAsyncResult returned by the call to BeginListTableMetadata. /// /// Returns a ListTableMetadataResult from Athena. /// REST API Reference for ListTableMetadata Operation ListTableMetadataResponse EndListTableMetadata(IAsyncResult asyncResult); #endregion #region ListTagsForResource ///

/// Lists the tags associated with an Athena resource. ///

/// Container for the necessary parameters to execute the ListTagsForResource service method. /// /// The response from the ListTagsForResource service method, as returned by Athena. /// /// Indicates a platform issue, which may be due to a transient condition or outage. /// /// /// Indicates that something is wrong with the input to the request. For example, a required /// parameter may be missing or out of range. /// /// /// A resource, such as a workgroup, was not found. /// /// REST API Reference for ListTagsForResource Operation ListTagsForResourceResponse ListTagsForResource(ListTagsForResourceRequest request); ///

/// Initiates the asynchronous execution of the ListTagsForResource operation. ///

/// /// Container for the necessary parameters to execute the ListTagsForResource operation on AmazonAthenaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListTagsForResource /// operation. /// REST API Reference for ListTagsForResource Operation IAsyncResult BeginListTagsForResource(ListTagsForResourceRequest request, AsyncCallback callback, object state); ///

/// Finishes the asynchronous execution of the ListTagsForResource operation. ///

/// /// The IAsyncResult returned by the call to BeginListTagsForResource. /// /// Returns a ListTagsForResourceResult from Athena. /// REST API Reference for ListTagsForResource Operation ListTagsForResourceResponse EndListTagsForResource(IAsyncResult asyncResult); #endregion #region ListWorkGroups ///

/// Lists available workgroups for the account. ///

/// Container for the necessary parameters to execute the ListWorkGroups service method. /// /// The response from the ListWorkGroups service method, as returned by Athena. /// /// Indicates a platform issue, which may be due to a transient condition or outage. /// /// /// Indicates that something is wrong with the input to the request. For example, a required /// parameter may be missing or out of range. /// /// REST API Reference for ListWorkGroups Operation ListWorkGroupsResponse ListWorkGroups(ListWorkGroupsRequest request); ///

/// Initiates the asynchronous execution of the ListWorkGroups operation. ///

/// /// Container for the necessary parameters to execute the ListWorkGroups operation on AmazonAthenaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListWorkGroups /// operation. /// REST API Reference for ListWorkGroups Operation IAsyncResult BeginListWorkGroups(ListWorkGroupsRequest request, AsyncCallback callback, object state); ///

/// Finishes the asynchronous execution of the ListWorkGroups operation. ///

/// /// The IAsyncResult returned by the call to BeginListWorkGroups. /// /// Returns a ListWorkGroupsResult from Athena. /// REST API Reference for ListWorkGroups Operation ListWorkGroupsResponse EndListWorkGroups(IAsyncResult asyncResult); #endregion #region PutCapacityAssignmentConfiguration ///

/// 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. ///

/// Container for the necessary parameters to execute the PutCapacityAssignmentConfiguration service method. /// /// The response from the PutCapacityAssignmentConfiguration service method, as returned by Athena. /// /// Indicates a platform issue, which may be due to a transient condition or outage. /// /// /// Indicates that something is wrong with the input to the request. For example, a required /// parameter may be missing or out of range. /// /// REST API Reference for PutCapacityAssignmentConfiguration Operation PutCapacityAssignmentConfigurationResponse PutCapacityAssignmentConfiguration(PutCapacityAssignmentConfigurationRequest request); ///

/// Initiates the asynchronous execution of the PutCapacityAssignmentConfiguration operation. ///

/// /// Container for the necessary parameters to execute the PutCapacityAssignmentConfiguration operation on AmazonAthenaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndPutCapacityAssignmentConfiguration /// operation. /// REST API Reference for PutCapacityAssignmentConfiguration Operation IAsyncResult BeginPutCapacityAssignmentConfiguration(PutCapacityAssignmentConfigurationRequest request, AsyncCallback callback, object state); ///

/// Finishes the asynchronous execution of the PutCapacityAssignmentConfiguration operation. ///

/// /// The IAsyncResult returned by the call to BeginPutCapacityAssignmentConfiguration. /// /// Returns a PutCapacityAssignmentConfigurationResult from Athena. /// REST API Reference for PutCapacityAssignmentConfiguration Operation PutCapacityAssignmentConfigurationResponse EndPutCapacityAssignmentConfiguration(IAsyncResult asyncResult); #endregion #region StartCalculationExecution ///

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

/// Container for the necessary parameters to execute the StartCalculationExecution service method. /// /// The response from the StartCalculationExecution service method, as returned by Athena. /// /// Indicates a platform issue, which may be due to a transient condition or outage. /// /// /// Indicates that something is wrong with the input to the request. For example, a required /// parameter may be missing or out of range. /// /// /// A resource, such as a workgroup, was not found. /// /// REST API Reference for StartCalculationExecution Operation StartCalculationExecutionResponse StartCalculationExecution(StartCalculationExecutionRequest request); ///

/// Initiates the asynchronous execution of the StartCalculationExecution operation. ///

/// /// Container for the necessary parameters to execute the StartCalculationExecution operation on AmazonAthenaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndStartCalculationExecution /// operation. /// REST API Reference for StartCalculationExecution Operation IAsyncResult BeginStartCalculationExecution(StartCalculationExecutionRequest request, AsyncCallback callback, object state); ///

/// Finishes the asynchronous execution of the StartCalculationExecution operation. ///

/// /// The IAsyncResult returned by the call to BeginStartCalculationExecution. /// /// Returns a StartCalculationExecutionResult from Athena. /// REST API Reference for StartCalculationExecution Operation StartCalculationExecutionResponse EndStartCalculationExecution(IAsyncResult asyncResult); #endregion #region StartQueryExecution ///

/// 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. ///

/// Container for the necessary parameters to execute the StartQueryExecution service method. /// /// The response from the StartQueryExecution service method, as returned by Athena. /// /// Indicates a platform issue, which may be due to a transient condition or outage. /// /// /// Indicates that something is wrong with the input to the request. For example, a required /// parameter may be missing or out of range. /// /// /// Indicates that the request was throttled. /// /// REST API Reference for StartQueryExecution Operation StartQueryExecutionResponse StartQueryExecution(StartQueryExecutionRequest request); ///

/// Initiates the asynchronous execution of the StartQueryExecution operation. ///

/// /// Container for the necessary parameters to execute the StartQueryExecution operation on AmazonAthenaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndStartQueryExecution /// operation. /// REST API Reference for StartQueryExecution Operation IAsyncResult BeginStartQueryExecution(StartQueryExecutionRequest request, AsyncCallback callback, object state); ///

/// Finishes the asynchronous execution of the StartQueryExecution operation. ///

/// /// The IAsyncResult returned by the call to BeginStartQueryExecution. /// /// Returns a StartQueryExecutionResult from Athena. /// REST API Reference for StartQueryExecution Operation StartQueryExecutionResponse EndStartQueryExecution(IAsyncResult asyncResult); #endregion #region StartSession ///

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

/// Container for the necessary parameters to execute the StartSession service method. /// /// The response from the StartSession service method, as returned by Athena. /// /// Indicates a platform issue, which may be due to a transient condition or outage. /// /// /// Indicates that something is wrong with the input to the request. For example, a required /// parameter may be missing or out of range. /// /// /// A resource, such as a workgroup, was not found. /// /// /// The specified session already exists. /// /// /// Indicates that the request was throttled. /// /// REST API Reference for StartSession Operation StartSessionResponse StartSession(StartSessionRequest request); ///

/// Initiates the asynchronous execution of the StartSession operation. ///

/// /// Container for the necessary parameters to execute the StartSession operation on AmazonAthenaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndStartSession /// operation. /// REST API Reference for StartSession Operation IAsyncResult BeginStartSession(StartSessionRequest request, AsyncCallback callback, object state); ///

/// Finishes the asynchronous execution of the StartSession operation. ///

/// /// The IAsyncResult returned by the call to BeginStartSession. /// /// Returns a StartSessionResult from Athena. /// REST API Reference for StartSession Operation StartSessionResponse EndStartSession(IAsyncResult asyncResult); #endregion #region StopCalculationExecution ///

/// 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. /// /// ///

/// Container for the necessary parameters to execute the StopCalculationExecution service method. /// /// The response from the StopCalculationExecution service method, as returned by Athena. /// /// Indicates a platform issue, which may be due to a transient condition or outage. /// /// /// Indicates that something is wrong with the input to the request. For example, a required /// parameter may be missing or out of range. /// /// /// A resource, such as a workgroup, was not found. /// /// REST API Reference for StopCalculationExecution Operation StopCalculationExecutionResponse StopCalculationExecution(StopCalculationExecutionRequest request); ///

/// Initiates the asynchronous execution of the StopCalculationExecution operation. ///

/// /// Container for the necessary parameters to execute the StopCalculationExecution operation on AmazonAthenaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndStopCalculationExecution /// operation. /// REST API Reference for StopCalculationExecution Operation IAsyncResult BeginStopCalculationExecution(StopCalculationExecutionRequest request, AsyncCallback callback, object state); ///

/// Finishes the asynchronous execution of the StopCalculationExecution operation. ///

/// /// The IAsyncResult returned by the call to BeginStopCalculationExecution. /// /// Returns a StopCalculationExecutionResult from Athena. /// REST API Reference for StopCalculationExecution Operation StopCalculationExecutionResponse EndStopCalculationExecution(IAsyncResult asyncResult); #endregion #region StopQueryExecution ///

/// 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. /// ///

/// Container for the necessary parameters to execute the StopQueryExecution service method. /// /// The response from the StopQueryExecution service method, as returned by Athena. /// /// Indicates a platform issue, which may be due to a transient condition or outage. /// /// /// Indicates that something is wrong with the input to the request. For example, a required /// parameter may be missing or out of range. /// /// REST API Reference for StopQueryExecution Operation StopQueryExecutionResponse StopQueryExecution(StopQueryExecutionRequest request); ///

/// Initiates the asynchronous execution of the StopQueryExecution operation. ///

/// /// Container for the necessary parameters to execute the StopQueryExecution operation on AmazonAthenaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndStopQueryExecution /// operation. /// REST API Reference for StopQueryExecution Operation IAsyncResult BeginStopQueryExecution(StopQueryExecutionRequest request, AsyncCallback callback, object state); ///

/// Finishes the asynchronous execution of the StopQueryExecution operation. ///

/// /// The IAsyncResult returned by the call to BeginStopQueryExecution. /// /// Returns a StopQueryExecutionResult from Athena. /// REST API Reference for StopQueryExecution Operation StopQueryExecutionResponse EndStopQueryExecution(IAsyncResult asyncResult); #endregion #region TagResource ///

/// 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. ///

/// Container for the necessary parameters to execute the TagResource service method. /// /// The response from the TagResource service method, as returned by Athena. /// /// Indicates a platform issue, which may be due to a transient condition or outage. /// /// /// Indicates that something is wrong with the input to the request. For example, a required /// parameter may be missing or out of range. /// /// /// A resource, such as a workgroup, was not found. /// /// REST API Reference for TagResource Operation TagResourceResponse TagResource(TagResourceRequest request); ///

/// Initiates the asynchronous execution of the TagResource operation. ///

/// /// Container for the necessary parameters to execute the TagResource operation on AmazonAthenaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndTagResource /// operation. /// REST API Reference for TagResource Operation IAsyncResult BeginTagResource(TagResourceRequest request, AsyncCallback callback, object state); ///

/// Finishes the asynchronous execution of the TagResource operation. ///

/// /// The IAsyncResult returned by the call to BeginTagResource. /// /// Returns a TagResourceResult from Athena. /// REST API Reference for TagResource Operation TagResourceResponse EndTagResource(IAsyncResult asyncResult); #endregion #region TerminateSession ///

/// 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. ///

/// Container for the necessary parameters to execute the TerminateSession service method. /// /// The response from the TerminateSession service method, as returned by Athena. /// /// Indicates a platform issue, which may be due to a transient condition or outage. /// /// /// Indicates that something is wrong with the input to the request. For example, a required /// parameter may be missing or out of range. /// /// /// A resource, such as a workgroup, was not found. /// /// REST API Reference for TerminateSession Operation TerminateSessionResponse TerminateSession(TerminateSessionRequest request); ///

/// Initiates the asynchronous execution of the TerminateSession operation. ///

/// /// Container for the necessary parameters to execute the TerminateSession operation on AmazonAthenaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndTerminateSession /// operation. /// REST API Reference for TerminateSession Operation IAsyncResult BeginTerminateSession(TerminateSessionRequest request, AsyncCallback callback, object state); ///

/// Finishes the asynchronous execution of the TerminateSession operation. ///

/// /// The IAsyncResult returned by the call to BeginTerminateSession. /// /// Returns a TerminateSessionResult from Athena. /// REST API Reference for TerminateSession Operation TerminateSessionResponse EndTerminateSession(IAsyncResult asyncResult); #endregion #region UntagResource ///

/// Removes one or more tags from an Athena resource. ///

/// Container for the necessary parameters to execute the UntagResource service method. /// /// The response from the UntagResource service method, as returned by Athena. /// /// Indicates a platform issue, which may be due to a transient condition or outage. /// /// /// Indicates that something is wrong with the input to the request. For example, a required /// parameter may be missing or out of range. /// /// /// A resource, such as a workgroup, was not found. /// /// REST API Reference for UntagResource Operation UntagResourceResponse UntagResource(UntagResourceRequest request); ///

/// Initiates the asynchronous execution of the UntagResource operation. ///

/// /// Container for the necessary parameters to execute the UntagResource operation on AmazonAthenaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUntagResource /// operation. /// REST API Reference for UntagResource Operation IAsyncResult BeginUntagResource(UntagResourceRequest request, AsyncCallback callback, object state); ///

/// Finishes the asynchronous execution of the UntagResource operation. ///

/// /// The IAsyncResult returned by the call to BeginUntagResource. /// /// Returns a UntagResourceResult from Athena. /// REST API Reference for UntagResource Operation UntagResourceResponse EndUntagResource(IAsyncResult asyncResult); #endregion #region UpdateCapacityReservation ///

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

/// Container for the necessary parameters to execute the UpdateCapacityReservation service method. /// /// The response from the UpdateCapacityReservation service method, as returned by Athena. /// /// Indicates a platform issue, which may be due to a transient condition or outage. /// /// /// Indicates that something is wrong with the input to the request. For example, a required /// parameter may be missing or out of range. /// /// REST API Reference for UpdateCapacityReservation Operation UpdateCapacityReservationResponse UpdateCapacityReservation(UpdateCapacityReservationRequest request); ///

/// Initiates the asynchronous execution of the UpdateCapacityReservation operation. ///

/// /// Container for the necessary parameters to execute the UpdateCapacityReservation operation on AmazonAthenaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateCapacityReservation /// operation. /// REST API Reference for UpdateCapacityReservation Operation IAsyncResult BeginUpdateCapacityReservation(UpdateCapacityReservationRequest request, AsyncCallback callback, object state); ///

/// Finishes the asynchronous execution of the UpdateCapacityReservation operation. ///

/// /// The IAsyncResult returned by the call to BeginUpdateCapacityReservation. /// /// Returns a UpdateCapacityReservationResult from Athena. /// REST API Reference for UpdateCapacityReservation Operation UpdateCapacityReservationResponse EndUpdateCapacityReservation(IAsyncResult asyncResult); #endregion #region UpdateDataCatalog ///

/// Updates the data catalog that has the specified name. ///

/// Container for the necessary parameters to execute the UpdateDataCatalog service method. /// /// The response from the UpdateDataCatalog service method, as returned by Athena. /// /// Indicates a platform issue, which may be due to a transient condition or outage. /// /// /// Indicates that something is wrong with the input to the request. For example, a required /// parameter may be missing or out of range. /// /// REST API Reference for UpdateDataCatalog Operation UpdateDataCatalogResponse UpdateDataCatalog(UpdateDataCatalogRequest request); ///

/// Initiates the asynchronous execution of the UpdateDataCatalog operation. ///

/// /// Container for the necessary parameters to execute the UpdateDataCatalog operation on AmazonAthenaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateDataCatalog /// operation. /// REST API Reference for UpdateDataCatalog Operation IAsyncResult BeginUpdateDataCatalog(UpdateDataCatalogRequest request, AsyncCallback callback, object state); ///

/// Finishes the asynchronous execution of the UpdateDataCatalog operation. ///

/// /// The IAsyncResult returned by the call to BeginUpdateDataCatalog. /// /// Returns a UpdateDataCatalogResult from Athena. /// REST API Reference for UpdateDataCatalog Operation UpdateDataCatalogResponse EndUpdateDataCatalog(IAsyncResult asyncResult); #endregion #region UpdateNamedQuery ///

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

/// Container for the necessary parameters to execute the UpdateNamedQuery service method. /// /// The response from the UpdateNamedQuery service method, as returned by Athena. /// /// Indicates a platform issue, which may be due to a transient condition or outage. /// /// /// Indicates that something is wrong with the input to the request. For example, a required /// parameter may be missing or out of range. /// /// REST API Reference for UpdateNamedQuery Operation UpdateNamedQueryResponse UpdateNamedQuery(UpdateNamedQueryRequest request); ///

/// Initiates the asynchronous execution of the UpdateNamedQuery operation. ///

/// /// Container for the necessary parameters to execute the UpdateNamedQuery operation on AmazonAthenaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateNamedQuery /// operation. /// REST API Reference for UpdateNamedQuery Operation IAsyncResult BeginUpdateNamedQuery(UpdateNamedQueryRequest request, AsyncCallback callback, object state); ///

/// Finishes the asynchronous execution of the UpdateNamedQuery operation. ///

/// /// The IAsyncResult returned by the call to BeginUpdateNamedQuery. /// /// Returns a UpdateNamedQueryResult from Athena. /// REST API Reference for UpdateNamedQuery Operation UpdateNamedQueryResponse EndUpdateNamedQuery(IAsyncResult asyncResult); #endregion #region UpdateNotebook ///

/// Updates the contents of a Spark notebook. ///

/// Container for the necessary parameters to execute the UpdateNotebook service method. /// /// The response from the UpdateNotebook service method, as returned by Athena. /// /// Indicates a platform issue, which may be due to a transient condition or outage. /// /// /// Indicates that something is wrong with the input to the request. For example, a required /// parameter may be missing or out of range. /// /// /// Indicates that the request was throttled. /// /// REST API Reference for UpdateNotebook Operation UpdateNotebookResponse UpdateNotebook(UpdateNotebookRequest request); ///

/// Initiates the asynchronous execution of the UpdateNotebook operation. ///

/// /// Container for the necessary parameters to execute the UpdateNotebook operation on AmazonAthenaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateNotebook /// operation. /// REST API Reference for UpdateNotebook Operation IAsyncResult BeginUpdateNotebook(UpdateNotebookRequest request, AsyncCallback callback, object state); ///

/// Finishes the asynchronous execution of the UpdateNotebook operation. ///

/// /// The IAsyncResult returned by the call to BeginUpdateNotebook. /// /// Returns a UpdateNotebookResult from Athena. /// REST API Reference for UpdateNotebook Operation UpdateNotebookResponse EndUpdateNotebook(IAsyncResult asyncResult); #endregion #region UpdateNotebookMetadata ///

/// Updates the metadata for a notebook. ///

/// Container for the necessary parameters to execute the UpdateNotebookMetadata service method. /// /// The response from the UpdateNotebookMetadata service method, as returned by Athena. /// /// Indicates a platform issue, which may be due to a transient condition or outage. /// /// /// Indicates that something is wrong with the input to the request. For example, a required /// parameter may be missing or out of range. /// /// /// Indicates that the request was throttled. /// /// REST API Reference for UpdateNotebookMetadata Operation UpdateNotebookMetadataResponse UpdateNotebookMetadata(UpdateNotebookMetadataRequest request); ///

/// Initiates the asynchronous execution of the UpdateNotebookMetadata operation. ///

/// /// Container for the necessary parameters to execute the UpdateNotebookMetadata operation on AmazonAthenaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateNotebookMetadata /// operation. /// REST API Reference for UpdateNotebookMetadata Operation IAsyncResult BeginUpdateNotebookMetadata(UpdateNotebookMetadataRequest request, AsyncCallback callback, object state); ///

/// Finishes the asynchronous execution of the UpdateNotebookMetadata operation. ///

/// /// The IAsyncResult returned by the call to BeginUpdateNotebookMetadata. /// /// Returns a UpdateNotebookMetadataResult from Athena. /// REST API Reference for UpdateNotebookMetadata Operation UpdateNotebookMetadataResponse EndUpdateNotebookMetadata(IAsyncResult asyncResult); #endregion #region UpdatePreparedStatement ///

/// Updates a prepared statement. ///

/// Container for the necessary parameters to execute the UpdatePreparedStatement service method. /// /// The response from the UpdatePreparedStatement service method, as returned by Athena. /// /// Indicates a platform issue, which may be due to a transient condition or outage. /// /// /// Indicates that something is wrong with the input to the request. For example, a required /// parameter may be missing or out of range. /// /// /// A resource, such as a workgroup, was not found. /// /// REST API Reference for UpdatePreparedStatement Operation UpdatePreparedStatementResponse UpdatePreparedStatement(UpdatePreparedStatementRequest request); ///

/// Initiates the asynchronous execution of the UpdatePreparedStatement operation. ///

/// /// Container for the necessary parameters to execute the UpdatePreparedStatement operation on AmazonAthenaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdatePreparedStatement /// operation. /// REST API Reference for UpdatePreparedStatement Operation IAsyncResult BeginUpdatePreparedStatement(UpdatePreparedStatementRequest request, AsyncCallback callback, object state); ///

/// Finishes the asynchronous execution of the UpdatePreparedStatement operation. ///

/// /// The IAsyncResult returned by the call to BeginUpdatePreparedStatement. /// /// Returns a UpdatePreparedStatementResult from Athena. /// REST API Reference for UpdatePreparedStatement Operation UpdatePreparedStatementResponse EndUpdatePreparedStatement(IAsyncResult asyncResult); #endregion #region UpdateWorkGroup ///

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

/// Container for the necessary parameters to execute the UpdateWorkGroup service method. /// /// The response from the UpdateWorkGroup service method, as returned by Athena. /// /// Indicates a platform issue, which may be due to a transient condition or outage. /// /// /// Indicates that something is wrong with the input to the request. For example, a required /// parameter may be missing or out of range. /// /// REST API Reference for UpdateWorkGroup Operation UpdateWorkGroupResponse UpdateWorkGroup(UpdateWorkGroupRequest request); ///

/// Initiates the asynchronous execution of the UpdateWorkGroup operation. ///

/// /// Container for the necessary parameters to execute the UpdateWorkGroup operation on AmazonAthenaClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateWorkGroup /// operation. /// REST API Reference for UpdateWorkGroup Operation IAsyncResult BeginUpdateWorkGroup(UpdateWorkGroupRequest request, AsyncCallback callback, object state); ///

/// Finishes the asynchronous execution of the UpdateWorkGroup operation. ///

/// /// The IAsyncResult returned by the call to BeginUpdateWorkGroup. /// /// Returns a UpdateWorkGroupResult from Athena. /// REST API Reference for UpdateWorkGroup Operation UpdateWorkGroupResponse EndUpdateWorkGroup(IAsyncResult asyncResult); #endregion } }