/* * 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.Threading; using System.Threading.Tasks; 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 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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task BatchGetNamedQueryAsync(BatchGetNamedQueryRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task BatchGetPreparedStatementAsync(BatchGetPreparedStatementRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task BatchGetQueryExecutionAsync(BatchGetQueryExecutionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task CancelCapacityReservationAsync(CancelCapacityReservationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task CreateCapacityReservationAsync(CreateCapacityReservationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task CreateDataCatalogAsync(CreateDataCatalogRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task CreateNamedQueryAsync(CreateNamedQueryRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task CreateNotebookAsync(CreateNotebookRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task CreatePreparedStatementAsync(CreatePreparedStatementRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task CreatePresignedNotebookUrlAsync(CreatePresignedNotebookUrlRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task CreateWorkGroupAsync(CreateWorkGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task DeleteCapacityReservationAsync(DeleteCapacityReservationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteDataCatalog /// /// Deletes a data catalog. /// /// Container for the necessary parameters to execute the DeleteDataCatalog service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task DeleteDataCatalogAsync(DeleteDataCatalogRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task DeleteNamedQueryAsync(DeleteNamedQueryRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteNotebook /// /// Deletes the specified notebook. /// /// Container for the necessary parameters to execute the DeleteNotebook service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task DeleteNotebookAsync(DeleteNotebookRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task DeletePreparedStatementAsync(DeletePreparedStatementRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task DeleteWorkGroupAsync(DeleteWorkGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region ExportNotebook /// /// Exports the specified notebook and its metadata. /// /// Container for the necessary parameters to execute the ExportNotebook service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task ExportNotebookAsync(ExportNotebookRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region GetCalculationExecution /// /// Describes a previously submitted calculation execution. /// /// Container for the necessary parameters to execute the GetCalculationExecution service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task GetCalculationExecutionAsync(GetCalculationExecutionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region GetCalculationExecutionCode /// /// Retrieves the unencrypted code that was executed for the calculation. /// /// Container for the necessary parameters to execute the GetCalculationExecutionCode service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task GetCalculationExecutionCodeAsync(GetCalculationExecutionCodeRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region GetCalculationExecutionStatus /// /// Gets the status of a current calculation. /// /// Container for the necessary parameters to execute the GetCalculationExecutionStatus service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task GetCalculationExecutionStatusAsync(GetCalculationExecutionStatusRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task GetCapacityAssignmentConfigurationAsync(GetCapacityAssignmentConfigurationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region GetCapacityReservation /// /// Returns information about the capacity reservation with the specified name. /// /// Container for the necessary parameters to execute the GetCapacityReservation service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task GetCapacityReservationAsync(GetCapacityReservationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task GetDatabaseAsync(GetDatabaseRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region GetDataCatalog /// /// Returns the specified data catalog. /// /// Container for the necessary parameters to execute the GetDataCatalog service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task GetDataCatalogAsync(GetDataCatalogRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task GetNamedQueryAsync(GetNamedQueryRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region GetNotebookMetadata /// /// Retrieves notebook metadata for the specified notebook ID. /// /// Container for the necessary parameters to execute the GetNotebookMetadata service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task GetNotebookMetadataAsync(GetNotebookMetadataRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task GetPreparedStatementAsync(GetPreparedStatementRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task GetQueryExecutionAsync(GetQueryExecutionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task GetQueryResultsAsync(GetQueryResultsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task GetQueryRuntimeStatisticsAsync(GetQueryRuntimeStatisticsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task GetSessionAsync(GetSessionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region GetSessionStatus /// /// Gets the current status of a session. /// /// Container for the necessary parameters to execute the GetSessionStatus service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task GetSessionStatusAsync(GetSessionStatusRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region GetTableMetadata /// /// Returns table metadata for the specified catalog, database, and table. /// /// Container for the necessary parameters to execute the GetTableMetadata service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task GetTableMetadataAsync(GetTableMetadataRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region GetWorkGroup /// /// Returns information about the workgroup with the specified name. /// /// Container for the necessary parameters to execute the GetWorkGroup service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task GetWorkGroupAsync(GetWorkGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task ImportNotebookAsync(ImportNotebookRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task ListApplicationDPUSizesAsync(ListApplicationDPUSizesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task ListCalculationExecutionsAsync(ListCalculationExecutionsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region ListCapacityReservations /// /// Lists the capacity reservations for the current account. /// /// Container for the necessary parameters to execute the ListCapacityReservations service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task ListCapacityReservationsAsync(ListCapacityReservationsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region ListDatabases /// /// Lists the databases in the specified data catalog. /// /// Container for the necessary parameters to execute the ListDatabases service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task ListDatabasesAsync(ListDatabasesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task ListDataCatalogsAsync(ListDataCatalogsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task ListEngineVersionsAsync(ListEngineVersionsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task ListExecutorsAsync(ListExecutorsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task ListNamedQueriesAsync(ListNamedQueriesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task ListNotebookMetadataAsync(ListNotebookMetadataRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task ListNotebookSessionsAsync(ListNotebookSessionsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region ListPreparedStatements /// /// Lists the prepared statements in the specified workgroup. /// /// Container for the necessary parameters to execute the ListPreparedStatements service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task ListPreparedStatementsAsync(ListPreparedStatementsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task ListQueryExecutionsAsync(ListQueryExecutionsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task ListSessionsAsync(ListSessionsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task ListTableMetadataAsync(ListTableMetadataRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region ListTagsForResource /// /// Lists the tags associated with an Athena resource. /// /// Container for the necessary parameters to execute the ListTagsForResource service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task ListTagsForResourceAsync(ListTagsForResourceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region ListWorkGroups /// /// Lists available workgroups for the account. /// /// Container for the necessary parameters to execute the ListWorkGroups service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task ListWorkGroupsAsync(ListWorkGroupsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task PutCapacityAssignmentConfigurationAsync(PutCapacityAssignmentConfigurationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task StartCalculationExecutionAsync(StartCalculationExecutionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task StartQueryExecutionAsync(StartQueryExecutionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task StartSessionAsync(StartSessionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task StopCalculationExecutionAsync(StopCalculationExecutionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task StopQueryExecutionAsync(StopQueryExecutionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task TagResourceAsync(TagResourceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task TerminateSessionAsync(TerminateSessionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region UntagResource /// /// Removes one or more tags from an Athena resource. /// /// Container for the necessary parameters to execute the UntagResource service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task UntagResourceAsync(UntagResourceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task UpdateCapacityReservationAsync(UpdateCapacityReservationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region UpdateDataCatalog /// /// Updates the data catalog that has the specified name. /// /// Container for the necessary parameters to execute the UpdateDataCatalog service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task UpdateDataCatalogAsync(UpdateDataCatalogRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task UpdateNamedQueryAsync(UpdateNamedQueryRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region UpdateNotebook /// /// Updates the contents of a Spark notebook. /// /// Container for the necessary parameters to execute the UpdateNotebook service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task UpdateNotebookAsync(UpdateNotebookRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region UpdateNotebookMetadata /// /// Updates the metadata for a notebook. /// /// Container for the necessary parameters to execute the UpdateNotebookMetadata service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task UpdateNotebookMetadataAsync(UpdateNotebookMetadataRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region UpdatePreparedStatement /// /// Updates a prepared statement. /// /// Container for the necessary parameters to execute the UpdatePreparedStatement service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task UpdatePreparedStatementAsync(UpdatePreparedStatementRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task UpdateWorkGroupAsync(UpdateWorkGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion } }