Documentation

Overview

    Package athena provides the API client, operations, and parameter types for Amazon 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 (http://docs.aws.amazon.com/athena/latest/ug/what-is.html) 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 (https://docs.aws.amazon.com/athena/latest/ug/connect-with-jdbc.html). For code samples using the AWS SDK for Java, see Examples and Code Samples (https://docs.aws.amazon.com/athena/latest/ug/code-samples.html) in the Amazon Athena User Guide.

    Index

    Constants

    View Source
    const ServiceAPIVersion = "2017-05-18"
    View Source
    const ServiceID = "Athena"

    Variables

    This section is empty.

    Functions

    func NewDefaultEndpointResolver

    func NewDefaultEndpointResolver() *internalendpoints.Resolver

      NewDefaultEndpointResolver constructs a new service endpoint resolver

      func WithAPIOptions

      func WithAPIOptions(optFns ...func(*middleware.Stack) error) func(*Options)

        WithAPIOptions returns a functional option for setting the Client's APIOptions option.

        func WithEndpointResolver

        func WithEndpointResolver(v EndpointResolver) func(*Options)

          WithEndpointResolver returns a functional option for setting the Client's EndpointResolver option.

          Types

          type BatchGetNamedQueryInput

          type BatchGetNamedQueryInput struct {
          
          	// An array of query IDs.
          	//
          	// This member is required.
          	NamedQueryIds []string
          }

          type BatchGetNamedQueryOutput

          type BatchGetNamedQueryOutput struct {
          
          	// Information about the named query IDs submitted.
          	NamedQueries []types.NamedQuery
          
          	// Information about provided query IDs.
          	UnprocessedNamedQueryIds []types.UnprocessedNamedQueryId
          
          	// Metadata pertaining to the operation's result.
          	ResultMetadata middleware.Metadata
          }

          type BatchGetQueryExecutionInput

          type BatchGetQueryExecutionInput struct {
          
          	// An array of query execution IDs.
          	//
          	// This member is required.
          	QueryExecutionIds []string
          }

          type BatchGetQueryExecutionOutput

          type BatchGetQueryExecutionOutput struct {
          
          	// Information about a query execution.
          	QueryExecutions []types.QueryExecution
          
          	// Information about the query executions that failed to run.
          	UnprocessedQueryExecutionIds []types.UnprocessedQueryExecutionId
          
          	// Metadata pertaining to the operation's result.
          	ResultMetadata middleware.Metadata
          }

          type Client

          type Client struct {
          	// contains filtered or unexported fields
          }

            Client provides the API client to make operations call for Amazon Athena.

            func New

            func New(options Options, optFns ...func(*Options)) *Client

              New returns an initialized Client based on the functional options. Provide additional functional options to further configure the behavior of the client, such as changing the client's endpoint or adding custom middleware behavior.

              func NewFromConfig

              func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client

                NewFromConfig returns a new client from the provided config.

                func (*Client) BatchGetNamedQuery

                func (c *Client) BatchGetNamedQuery(ctx context.Context, params *BatchGetNamedQueryInput, optFns ...func(*Options)) (*BatchGetNamedQueryOutput, error)

                  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.

                  func (*Client) BatchGetQueryExecution

                  func (c *Client) BatchGetQueryExecution(ctx context.Context, params *BatchGetQueryExecutionInput, optFns ...func(*Options)) (*BatchGetQueryExecutionOutput, error)

                    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.

                    func (*Client) CreateDataCatalog

                    func (c *Client) CreateDataCatalog(ctx context.Context, params *CreateDataCatalogInput, optFns ...func(*Options)) (*CreateDataCatalogOutput, error)

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

                      func (*Client) CreateNamedQuery

                      func (c *Client) CreateNamedQuery(ctx context.Context, params *CreateNamedQueryInput, optFns ...func(*Options)) (*CreateNamedQueryOutput, error)

                        Creates a named query in the specified workgroup. Requires that you have access to the workgroup. For code samples using the AWS SDK for Java, see Examples and Code Samples (http://docs.aws.amazon.com/athena/latest/ug/code-samples.html) in the Amazon Athena User Guide.

                        func (*Client) CreateWorkGroup

                        func (c *Client) CreateWorkGroup(ctx context.Context, params *CreateWorkGroupInput, optFns ...func(*Options)) (*CreateWorkGroupOutput, error)

                          Creates a workgroup with the specified name.

                          func (*Client) DeleteDataCatalog

                          func (c *Client) DeleteDataCatalog(ctx context.Context, params *DeleteDataCatalogInput, optFns ...func(*Options)) (*DeleteDataCatalogOutput, error)

                            Deletes a data catalog.

                            func (*Client) DeleteNamedQuery

                            func (c *Client) DeleteNamedQuery(ctx context.Context, params *DeleteNamedQueryInput, optFns ...func(*Options)) (*DeleteNamedQueryOutput, error)

                              Deletes the named query if you have access to the workgroup in which the query was saved. For code samples using the AWS SDK for Java, see Examples and Code Samples (http://docs.aws.amazon.com/athena/latest/ug/code-samples.html) in the Amazon Athena User Guide.

                              func (*Client) DeleteWorkGroup

                              func (c *Client) DeleteWorkGroup(ctx context.Context, params *DeleteWorkGroupInput, optFns ...func(*Options)) (*DeleteWorkGroupOutput, error)

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

                                func (*Client) GetDataCatalog

                                func (c *Client) GetDataCatalog(ctx context.Context, params *GetDataCatalogInput, optFns ...func(*Options)) (*GetDataCatalogOutput, error)

                                  Returns the specified data catalog.

                                  func (*Client) GetDatabase

                                  func (c *Client) GetDatabase(ctx context.Context, params *GetDatabaseInput, optFns ...func(*Options)) (*GetDatabaseOutput, error)

                                    Returns a database object for the specfied database and data catalog.

                                    func (*Client) GetNamedQuery

                                    func (c *Client) GetNamedQuery(ctx context.Context, params *GetNamedQueryInput, optFns ...func(*Options)) (*GetNamedQueryOutput, error)

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

                                      func (*Client) GetQueryExecution

                                      func (c *Client) GetQueryExecution(ctx context.Context, params *GetQueryExecutionInput, optFns ...func(*Options)) (*GetQueryExecutionOutput, error)

                                        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.

                                        func (*Client) GetQueryResults

                                        func (c *Client) GetQueryResults(ctx context.Context, params *GetQueryResultsInput, optFns ...func(*Options)) (*GetQueryResultsOutput, error)

                                          Streams the results of a single query execution specified by QueryExecutionId from the Athena query results location in Amazon S3. For more information, see Query Results (https://docs.aws.amazon.com/athena/latest/ug/querying.html) 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.

                                          func (*Client) GetTableMetadata

                                          func (c *Client) GetTableMetadata(ctx context.Context, params *GetTableMetadataInput, optFns ...func(*Options)) (*GetTableMetadataOutput, error)

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

                                            func (*Client) GetWorkGroup

                                            func (c *Client) GetWorkGroup(ctx context.Context, params *GetWorkGroupInput, optFns ...func(*Options)) (*GetWorkGroupOutput, error)

                                              Returns information about the workgroup with the specified name.

                                              func (*Client) ListDataCatalogs

                                              func (c *Client) ListDataCatalogs(ctx context.Context, params *ListDataCatalogsInput, optFns ...func(*Options)) (*ListDataCatalogsOutput, error)

                                                Lists the data catalogs in the current AWS account.

                                                func (*Client) ListDatabases

                                                func (c *Client) ListDatabases(ctx context.Context, params *ListDatabasesInput, optFns ...func(*Options)) (*ListDatabasesOutput, error)

                                                  Lists the databases in the specified data catalog.

                                                  func (*Client) ListNamedQueries

                                                  func (c *Client) ListNamedQueries(ctx context.Context, params *ListNamedQueriesInput, optFns ...func(*Options)) (*ListNamedQueriesOutput, error)

                                                    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 AWS SDK for Java, see Examples and Code Samples (http://docs.aws.amazon.com/athena/latest/ug/code-samples.html) in the Amazon Athena User Guide.

                                                    func (*Client) ListQueryExecutions

                                                    func (c *Client) ListQueryExecutions(ctx context.Context, params *ListQueryExecutionsInput, optFns ...func(*Options)) (*ListQueryExecutionsOutput, error)

                                                      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 AWS SDK for Java, see Examples and Code Samples (http://docs.aws.amazon.com/athena/latest/ug/code-samples.html) in the Amazon Athena User Guide.

                                                      func (*Client) ListTableMetadata

                                                      func (c *Client) ListTableMetadata(ctx context.Context, params *ListTableMetadataInput, optFns ...func(*Options)) (*ListTableMetadataOutput, error)

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

                                                        func (*Client) ListTagsForResource

                                                        func (c *Client) ListTagsForResource(ctx context.Context, params *ListTagsForResourceInput, optFns ...func(*Options)) (*ListTagsForResourceOutput, error)

                                                          Lists the tags associated with an Athena workgroup or data catalog resource.

                                                          func (*Client) ListWorkGroups

                                                          func (c *Client) ListWorkGroups(ctx context.Context, params *ListWorkGroupsInput, optFns ...func(*Options)) (*ListWorkGroupsOutput, error)

                                                            Lists available workgroups for the account.

                                                            func (*Client) StartQueryExecution

                                                            func (c *Client) StartQueryExecution(ctx context.Context, params *StartQueryExecutionInput, optFns ...func(*Options)) (*StartQueryExecutionOutput, error)

                                                              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 AWS SDK for Java, see Examples and Code Samples (http://docs.aws.amazon.com/athena/latest/ug/code-samples.html) in the Amazon Athena User Guide.

                                                              func (*Client) StopQueryExecution

                                                              func (c *Client) StopQueryExecution(ctx context.Context, params *StopQueryExecutionInput, optFns ...func(*Options)) (*StopQueryExecutionOutput, error)

                                                                Stops a query execution. Requires you to have access to the workgroup in which the query ran. For code samples using the AWS SDK for Java, see Examples and Code Samples (http://docs.aws.amazon.com/athena/latest/ug/code-samples.html) in the Amazon Athena User Guide.

                                                                func (*Client) TagResource

                                                                func (c *Client) TagResource(ctx context.Context, params *TagResourceInput, optFns ...func(*Options)) (*TagResourceOutput, error)

                                                                  Adds one or more tags to an Athena resource. A tag is a label that you assign to a resource. In Athena, a resource can be a workgroup or data catalog. 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 or data catalogs by purpose, owner, or environment. Use a consistent set of tag keys to make it easier to search and filter workgroups or data catalogs in your account. For best practices, see Tagging Best Practices (https://aws.amazon.com/answers/account-management/aws-tagging-strategies/). 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.

                                                                  func (*Client) UntagResource

                                                                  func (c *Client) UntagResource(ctx context.Context, params *UntagResourceInput, optFns ...func(*Options)) (*UntagResourceOutput, error)

                                                                    Removes one or more tags from a data catalog or workgroup resource.

                                                                    func (*Client) UpdateDataCatalog

                                                                    func (c *Client) UpdateDataCatalog(ctx context.Context, params *UpdateDataCatalogInput, optFns ...func(*Options)) (*UpdateDataCatalogOutput, error)

                                                                      Updates the data catalog that has the specified name.

                                                                      func (*Client) UpdateWorkGroup

                                                                      func (c *Client) UpdateWorkGroup(ctx context.Context, params *UpdateWorkGroupInput, optFns ...func(*Options)) (*UpdateWorkGroupOutput, error)

                                                                        Updates the workgroup with the specified name. The workgroup's name cannot be changed.

                                                                        type CreateDataCatalogInput

                                                                        type CreateDataCatalogInput struct {
                                                                        
                                                                        	// The name of the data catalog to create. The catalog name must be unique for the
                                                                        	// AWS account and can use a maximum of 128 alphanumeric, underscore, at sign, or
                                                                        	// hyphen characters.
                                                                        	//
                                                                        	// This member is required.
                                                                        	Name *string
                                                                        
                                                                        	// The type of data catalog to create: LAMBDA for a federated catalog, GLUE for AWS
                                                                        	// Glue Catalog, or HIVE for an external hive metastore.
                                                                        	//
                                                                        	// This member is required.
                                                                        	Type types.DataCatalogType
                                                                        
                                                                        	// A description of the data catalog to be created.
                                                                        	Description *string
                                                                        
                                                                        	// Specifies the Lambda function or functions to use for creating the data catalog.
                                                                        	// This is a mapping whose values depend on the catalog type.
                                                                        	//
                                                                        	// * For the HIVE data
                                                                        	// catalog type, use the following syntax. The metadata-function parameter is
                                                                        	// required. The sdk-version parameter is optional and defaults to the currently
                                                                        	// supported version. metadata-function=lambda_arn, sdk-version=version_number
                                                                        	//
                                                                        	// *
                                                                        	// For the LAMBDA data catalog type, use one of the following sets of required
                                                                        	// parameters, but not both.
                                                                        	//
                                                                        	// * If you have one Lambda function that processes
                                                                        	// metadata and another for reading the actual data, use the following syntax. Both
                                                                        	// parameters are required. metadata-function=lambda_arn,
                                                                        	// record-function=lambda_arn
                                                                        	//
                                                                        	// * If you have a composite Lambda function that
                                                                        	// processes both metadata and data, use the following syntax to specify your
                                                                        	// Lambda function. function=lambda_arn
                                                                        	//
                                                                        	// * The GLUE type has no parameters.
                                                                        	Parameters map[string]string
                                                                        
                                                                        	// A list of comma separated tags to add to the data catalog that is created.
                                                                        	Tags []types.Tag
                                                                        }

                                                                        type CreateDataCatalogOutput

                                                                        type CreateDataCatalogOutput struct {
                                                                        	// Metadata pertaining to the operation's result.
                                                                        	ResultMetadata middleware.Metadata
                                                                        }

                                                                        type CreateNamedQueryInput

                                                                        type CreateNamedQueryInput struct {
                                                                        
                                                                        	// The database to which the query belongs.
                                                                        	//
                                                                        	// This member is required.
                                                                        	Database *string
                                                                        
                                                                        	// The query name.
                                                                        	//
                                                                        	// This member is required.
                                                                        	Name *string
                                                                        
                                                                        	// The contents of the query with all query statements.
                                                                        	//
                                                                        	// This member is required.
                                                                        	QueryString *string
                                                                        
                                                                        	// A unique case-sensitive string used to ensure the request to create the query is
                                                                        	// idempotent (executes only once). If another CreateNamedQuery request is
                                                                        	// received, the same response is returned and another query is not created. If a
                                                                        	// parameter has changed, for example, the QueryString, an error is returned. This
                                                                        	// token is listed as not required because AWS SDKs (for example the AWS SDK for
                                                                        	// Java) auto-generate the token for users. If you are not using the AWS SDK or the
                                                                        	// AWS CLI, you must provide this token or the action will fail.
                                                                        	ClientRequestToken *string
                                                                        
                                                                        	// The query description.
                                                                        	Description *string
                                                                        
                                                                        	// The name of the workgroup in which the named query is being created.
                                                                        	WorkGroup *string
                                                                        }

                                                                        type CreateNamedQueryOutput

                                                                        type CreateNamedQueryOutput struct {
                                                                        
                                                                        	// The unique ID of the query.
                                                                        	NamedQueryId *string
                                                                        
                                                                        	// Metadata pertaining to the operation's result.
                                                                        	ResultMetadata middleware.Metadata
                                                                        }

                                                                        type CreateWorkGroupInput

                                                                        type CreateWorkGroupInput struct {
                                                                        
                                                                        	// The workgroup name.
                                                                        	//
                                                                        	// This member is required.
                                                                        	Name *string
                                                                        
                                                                        	// The configuration for the workgroup, which includes the location in Amazon S3
                                                                        	// where query results are stored, the encryption configuration, if any, used for
                                                                        	// encrypting query results, whether the Amazon CloudWatch Metrics are enabled for
                                                                        	// the workgroup, the limit for the amount of bytes scanned (cutoff) per query, if
                                                                        	// it is specified, and whether workgroup's settings (specified with
                                                                        	// EnforceWorkGroupConfiguration) in the WorkGroupConfiguration override
                                                                        	// client-side settings. See WorkGroupConfiguration$EnforceWorkGroupConfiguration.
                                                                        	Configuration *types.WorkGroupConfiguration
                                                                        
                                                                        	// The workgroup description.
                                                                        	Description *string
                                                                        
                                                                        	// A list of comma separated tags to add to the workgroup that is created.
                                                                        	Tags []types.Tag
                                                                        }

                                                                        type CreateWorkGroupOutput

                                                                        type CreateWorkGroupOutput struct {
                                                                        	// Metadata pertaining to the operation's result.
                                                                        	ResultMetadata middleware.Metadata
                                                                        }

                                                                        type DeleteDataCatalogInput

                                                                        type DeleteDataCatalogInput struct {
                                                                        
                                                                        	// The name of the data catalog to delete.
                                                                        	//
                                                                        	// This member is required.
                                                                        	Name *string
                                                                        }

                                                                        type DeleteDataCatalogOutput

                                                                        type DeleteDataCatalogOutput struct {
                                                                        	// Metadata pertaining to the operation's result.
                                                                        	ResultMetadata middleware.Metadata
                                                                        }

                                                                        type DeleteNamedQueryInput

                                                                        type DeleteNamedQueryInput struct {
                                                                        
                                                                        	// The unique ID of the query to delete.
                                                                        	//
                                                                        	// This member is required.
                                                                        	NamedQueryId *string
                                                                        }

                                                                        type DeleteNamedQueryOutput

                                                                        type DeleteNamedQueryOutput struct {
                                                                        	// Metadata pertaining to the operation's result.
                                                                        	ResultMetadata middleware.Metadata
                                                                        }

                                                                        type DeleteWorkGroupInput

                                                                        type DeleteWorkGroupInput struct {
                                                                        
                                                                        	// The unique name of the workgroup to delete.
                                                                        	//
                                                                        	// This member is required.
                                                                        	WorkGroup *string
                                                                        
                                                                        	// The option to delete the workgroup and its contents even if the workgroup
                                                                        	// contains any named queries.
                                                                        	RecursiveDeleteOption *bool
                                                                        }

                                                                        type DeleteWorkGroupOutput

                                                                        type DeleteWorkGroupOutput struct {
                                                                        	// Metadata pertaining to the operation's result.
                                                                        	ResultMetadata middleware.Metadata
                                                                        }

                                                                        type EndpointResolver

                                                                        type EndpointResolver interface {
                                                                        	ResolveEndpoint(region string, options EndpointResolverOptions) (aws.Endpoint, error)
                                                                        }

                                                                          EndpointResolver interface for resolving service endpoints.

                                                                          func EndpointResolverFromURL

                                                                          func EndpointResolverFromURL(url string, optFns ...func(*aws.Endpoint)) EndpointResolver

                                                                            EndpointResolverFromURL returns an EndpointResolver configured using the provided endpoint url. By default, the resolved endpoint resolver uses the client region as signing region, and the endpoint source is set to EndpointSourceCustom.You can provide functional options to configure endpoint values for the resolved endpoint.

                                                                            type EndpointResolverFunc

                                                                            type EndpointResolverFunc func(region string, options EndpointResolverOptions) (aws.Endpoint, error)

                                                                              EndpointResolverFunc is a helper utility that wraps a function so it satisfies the EndpointResolver interface. This is useful when you want to add additional endpoint resolving logic, or stub out specific endpoints with custom values.

                                                                              func (EndpointResolverFunc) ResolveEndpoint

                                                                              func (fn EndpointResolverFunc) ResolveEndpoint(region string, options EndpointResolverOptions) (endpoint aws.Endpoint, err error)

                                                                              type EndpointResolverOptions

                                                                              type EndpointResolverOptions = internalendpoints.Options

                                                                                EndpointResolverOptions is the service endpoint resolver options

                                                                                type GetDataCatalogInput

                                                                                type GetDataCatalogInput struct {
                                                                                
                                                                                	// The name of the data catalog to return.
                                                                                	//
                                                                                	// This member is required.
                                                                                	Name *string
                                                                                }

                                                                                type GetDataCatalogOutput

                                                                                type GetDataCatalogOutput struct {
                                                                                
                                                                                	// The data catalog returned.
                                                                                	DataCatalog *types.DataCatalog
                                                                                
                                                                                	// Metadata pertaining to the operation's result.
                                                                                	ResultMetadata middleware.Metadata
                                                                                }

                                                                                type GetDatabaseInput

                                                                                type GetDatabaseInput struct {
                                                                                
                                                                                	// The name of the data catalog that contains the database to return.
                                                                                	//
                                                                                	// This member is required.
                                                                                	CatalogName *string
                                                                                
                                                                                	// The name of the database to return.
                                                                                	//
                                                                                	// This member is required.
                                                                                	DatabaseName *string
                                                                                }

                                                                                type GetDatabaseOutput

                                                                                type GetDatabaseOutput struct {
                                                                                
                                                                                	// The database returned.
                                                                                	Database *types.Database
                                                                                
                                                                                	// Metadata pertaining to the operation's result.
                                                                                	ResultMetadata middleware.Metadata
                                                                                }

                                                                                type GetNamedQueryInput

                                                                                type GetNamedQueryInput struct {
                                                                                
                                                                                	// The unique ID of the query. Use ListNamedQueries to get query IDs.
                                                                                	//
                                                                                	// This member is required.
                                                                                	NamedQueryId *string
                                                                                }

                                                                                type GetNamedQueryOutput

                                                                                type GetNamedQueryOutput struct {
                                                                                
                                                                                	// Information about the query.
                                                                                	NamedQuery *types.NamedQuery
                                                                                
                                                                                	// Metadata pertaining to the operation's result.
                                                                                	ResultMetadata middleware.Metadata
                                                                                }

                                                                                type GetQueryExecutionInput

                                                                                type GetQueryExecutionInput struct {
                                                                                
                                                                                	// The unique ID of the query execution.
                                                                                	//
                                                                                	// This member is required.
                                                                                	QueryExecutionId *string
                                                                                }

                                                                                type GetQueryExecutionOutput

                                                                                type GetQueryExecutionOutput struct {
                                                                                
                                                                                	// Information about the query execution.
                                                                                	QueryExecution *types.QueryExecution
                                                                                
                                                                                	// Metadata pertaining to the operation's result.
                                                                                	ResultMetadata middleware.Metadata
                                                                                }

                                                                                type GetQueryResultsAPIClient

                                                                                type GetQueryResultsAPIClient interface {
                                                                                	GetQueryResults(context.Context, *GetQueryResultsInput, ...func(*Options)) (*GetQueryResultsOutput, error)
                                                                                }

                                                                                  GetQueryResultsAPIClient is a client that implements the GetQueryResults operation.

                                                                                  type GetQueryResultsInput

                                                                                  type GetQueryResultsInput struct {
                                                                                  
                                                                                  	// The unique ID of the query execution.
                                                                                  	//
                                                                                  	// This member is required.
                                                                                  	QueryExecutionId *string
                                                                                  
                                                                                  	// The maximum number of results (rows) to return in this request.
                                                                                  	MaxResults *int32
                                                                                  
                                                                                  	// A token generated by the Athena service that specifies where to continue
                                                                                  	// pagination if a previous request was truncated. To obtain the next set of pages,
                                                                                  	// pass in the NextToken from the response object of the previous page call.
                                                                                  	NextToken *string
                                                                                  }

                                                                                  type GetQueryResultsOutput

                                                                                  type GetQueryResultsOutput struct {
                                                                                  
                                                                                  	// A token generated by the Athena service that specifies where to continue
                                                                                  	// pagination if a previous request was truncated. To obtain the next set of pages,
                                                                                  	// pass in the NextToken from the response object of the previous page call.
                                                                                  	NextToken *string
                                                                                  
                                                                                  	// The results of the query execution.
                                                                                  	ResultSet *types.ResultSet
                                                                                  
                                                                                  	// The number of rows inserted with a CREATE TABLE AS SELECT statement.
                                                                                  	UpdateCount *int64
                                                                                  
                                                                                  	// Metadata pertaining to the operation's result.
                                                                                  	ResultMetadata middleware.Metadata
                                                                                  }

                                                                                  type GetQueryResultsPaginator

                                                                                  type GetQueryResultsPaginator struct {
                                                                                  	// contains filtered or unexported fields
                                                                                  }

                                                                                    GetQueryResultsPaginator is a paginator for GetQueryResults

                                                                                    func NewGetQueryResultsPaginator

                                                                                    func NewGetQueryResultsPaginator(client GetQueryResultsAPIClient, params *GetQueryResultsInput, optFns ...func(*GetQueryResultsPaginatorOptions)) *GetQueryResultsPaginator

                                                                                      NewGetQueryResultsPaginator returns a new GetQueryResultsPaginator

                                                                                      func (*GetQueryResultsPaginator) HasMorePages

                                                                                      func (p *GetQueryResultsPaginator) HasMorePages() bool

                                                                                        HasMorePages returns a boolean indicating whether more pages are available

                                                                                        func (*GetQueryResultsPaginator) NextPage

                                                                                        func (p *GetQueryResultsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*GetQueryResultsOutput, error)

                                                                                          NextPage retrieves the next GetQueryResults page.

                                                                                          type GetQueryResultsPaginatorOptions

                                                                                          type GetQueryResultsPaginatorOptions struct {
                                                                                          	// The maximum number of results (rows) to return in this request.
                                                                                          	Limit int32
                                                                                          
                                                                                          	// Set to true if pagination should stop if the service returns a pagination token
                                                                                          	// that matches the most recent token provided to the service.
                                                                                          	StopOnDuplicateToken bool
                                                                                          }

                                                                                            GetQueryResultsPaginatorOptions is the paginator options for GetQueryResults

                                                                                            type GetTableMetadataInput

                                                                                            type GetTableMetadataInput struct {
                                                                                            
                                                                                            	// The name of the data catalog that contains the database and table metadata to
                                                                                            	// return.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	CatalogName *string
                                                                                            
                                                                                            	// The name of the database that contains the table metadata to return.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	DatabaseName *string
                                                                                            
                                                                                            	// The name of the table for which metadata is returned.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	TableName *string
                                                                                            }

                                                                                            type GetTableMetadataOutput

                                                                                            type GetTableMetadataOutput struct {
                                                                                            
                                                                                            	// An object that contains table metadata.
                                                                                            	TableMetadata *types.TableMetadata
                                                                                            
                                                                                            	// Metadata pertaining to the operation's result.
                                                                                            	ResultMetadata middleware.Metadata
                                                                                            }

                                                                                            type GetWorkGroupInput

                                                                                            type GetWorkGroupInput struct {
                                                                                            
                                                                                            	// The name of the workgroup.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	WorkGroup *string
                                                                                            }

                                                                                            type GetWorkGroupOutput

                                                                                            type GetWorkGroupOutput struct {
                                                                                            
                                                                                            	// Information about the workgroup.
                                                                                            	WorkGroup *types.WorkGroup
                                                                                            
                                                                                            	// Metadata pertaining to the operation's result.
                                                                                            	ResultMetadata middleware.Metadata
                                                                                            }

                                                                                            type HTTPClient

                                                                                            type HTTPClient interface {
                                                                                            	Do(*http.Request) (*http.Response, error)
                                                                                            }

                                                                                            type HTTPSignerV4

                                                                                            type HTTPSignerV4 interface {
                                                                                            	SignHTTP(ctx context.Context, credentials aws.Credentials, r *http.Request, payloadHash string, service string, region string, signingTime time.Time, optFns ...func(*v4.SignerOptions)) error
                                                                                            }

                                                                                            type IdempotencyTokenProvider

                                                                                            type IdempotencyTokenProvider interface {
                                                                                            	GetIdempotencyToken() (string, error)
                                                                                            }

                                                                                              IdempotencyTokenProvider interface for providing idempotency token

                                                                                              type ListDataCatalogsAPIClient

                                                                                              type ListDataCatalogsAPIClient interface {
                                                                                              	ListDataCatalogs(context.Context, *ListDataCatalogsInput, ...func(*Options)) (*ListDataCatalogsOutput, error)
                                                                                              }

                                                                                                ListDataCatalogsAPIClient is a client that implements the ListDataCatalogs operation.

                                                                                                type ListDataCatalogsInput

                                                                                                type ListDataCatalogsInput struct {
                                                                                                
                                                                                                	// Specifies the maximum number of data catalogs to return.
                                                                                                	MaxResults *int32
                                                                                                
                                                                                                	// A token generated by the Athena service that specifies where to continue
                                                                                                	// pagination if a previous request was truncated. To obtain the next set of pages,
                                                                                                	// pass in the NextToken from the response object of the previous page call.
                                                                                                	NextToken *string
                                                                                                }

                                                                                                type ListDataCatalogsOutput

                                                                                                type ListDataCatalogsOutput struct {
                                                                                                
                                                                                                	// A summary list of data catalogs.
                                                                                                	DataCatalogsSummary []types.DataCatalogSummary
                                                                                                
                                                                                                	// A token generated by the Athena service that specifies where to continue
                                                                                                	// pagination if a previous request was truncated. To obtain the next set of pages,
                                                                                                	// pass in the NextToken from the response object of the previous page call.
                                                                                                	NextToken *string
                                                                                                
                                                                                                	// Metadata pertaining to the operation's result.
                                                                                                	ResultMetadata middleware.Metadata
                                                                                                }

                                                                                                type ListDataCatalogsPaginator

                                                                                                type ListDataCatalogsPaginator struct {
                                                                                                	// contains filtered or unexported fields
                                                                                                }

                                                                                                  ListDataCatalogsPaginator is a paginator for ListDataCatalogs

                                                                                                  func NewListDataCatalogsPaginator

                                                                                                  func NewListDataCatalogsPaginator(client ListDataCatalogsAPIClient, params *ListDataCatalogsInput, optFns ...func(*ListDataCatalogsPaginatorOptions)) *ListDataCatalogsPaginator

                                                                                                    NewListDataCatalogsPaginator returns a new ListDataCatalogsPaginator

                                                                                                    func (*ListDataCatalogsPaginator) HasMorePages

                                                                                                    func (p *ListDataCatalogsPaginator) HasMorePages() bool

                                                                                                      HasMorePages returns a boolean indicating whether more pages are available

                                                                                                      func (*ListDataCatalogsPaginator) NextPage

                                                                                                      func (p *ListDataCatalogsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListDataCatalogsOutput, error)

                                                                                                        NextPage retrieves the next ListDataCatalogs page.

                                                                                                        type ListDataCatalogsPaginatorOptions

                                                                                                        type ListDataCatalogsPaginatorOptions struct {
                                                                                                        	// Specifies the maximum number of data catalogs to return.
                                                                                                        	Limit int32
                                                                                                        
                                                                                                        	// Set to true if pagination should stop if the service returns a pagination token
                                                                                                        	// that matches the most recent token provided to the service.
                                                                                                        	StopOnDuplicateToken bool
                                                                                                        }

                                                                                                          ListDataCatalogsPaginatorOptions is the paginator options for ListDataCatalogs

                                                                                                          type ListDatabasesAPIClient

                                                                                                          type ListDatabasesAPIClient interface {
                                                                                                          	ListDatabases(context.Context, *ListDatabasesInput, ...func(*Options)) (*ListDatabasesOutput, error)
                                                                                                          }

                                                                                                            ListDatabasesAPIClient is a client that implements the ListDatabases operation.

                                                                                                            type ListDatabasesInput

                                                                                                            type ListDatabasesInput struct {
                                                                                                            
                                                                                                            	// The name of the data catalog that contains the databases to return.
                                                                                                            	//
                                                                                                            	// This member is required.
                                                                                                            	CatalogName *string
                                                                                                            
                                                                                                            	// Specifies the maximum number of results to return.
                                                                                                            	MaxResults *int32
                                                                                                            
                                                                                                            	// A token generated by the Athena service that specifies where to continue
                                                                                                            	// pagination if a previous request was truncated. To obtain the next set of pages,
                                                                                                            	// pass in the NextToken from the response object of the previous page call.
                                                                                                            	NextToken *string
                                                                                                            }

                                                                                                            type ListDatabasesOutput

                                                                                                            type ListDatabasesOutput struct {
                                                                                                            
                                                                                                            	// A list of databases from a data catalog.
                                                                                                            	DatabaseList []types.Database
                                                                                                            
                                                                                                            	// A token generated by the Athena service that specifies where to continue
                                                                                                            	// pagination if a previous request was truncated. To obtain the next set of pages,
                                                                                                            	// pass in the NextToken from the response object of the previous page call.
                                                                                                            	NextToken *string
                                                                                                            
                                                                                                            	// Metadata pertaining to the operation's result.
                                                                                                            	ResultMetadata middleware.Metadata
                                                                                                            }

                                                                                                            type ListDatabasesPaginator

                                                                                                            type ListDatabasesPaginator struct {
                                                                                                            	// contains filtered or unexported fields
                                                                                                            }

                                                                                                              ListDatabasesPaginator is a paginator for ListDatabases

                                                                                                              func NewListDatabasesPaginator

                                                                                                              func NewListDatabasesPaginator(client ListDatabasesAPIClient, params *ListDatabasesInput, optFns ...func(*ListDatabasesPaginatorOptions)) *ListDatabasesPaginator

                                                                                                                NewListDatabasesPaginator returns a new ListDatabasesPaginator

                                                                                                                func (*ListDatabasesPaginator) HasMorePages

                                                                                                                func (p *ListDatabasesPaginator) HasMorePages() bool

                                                                                                                  HasMorePages returns a boolean indicating whether more pages are available

                                                                                                                  func (*ListDatabasesPaginator) NextPage

                                                                                                                  func (p *ListDatabasesPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListDatabasesOutput, error)

                                                                                                                    NextPage retrieves the next ListDatabases page.

                                                                                                                    type ListDatabasesPaginatorOptions

                                                                                                                    type ListDatabasesPaginatorOptions struct {
                                                                                                                    	// Specifies the maximum number of results to return.
                                                                                                                    	Limit int32
                                                                                                                    
                                                                                                                    	// Set to true if pagination should stop if the service returns a pagination token
                                                                                                                    	// that matches the most recent token provided to the service.
                                                                                                                    	StopOnDuplicateToken bool
                                                                                                                    }

                                                                                                                      ListDatabasesPaginatorOptions is the paginator options for ListDatabases

                                                                                                                      type ListNamedQueriesAPIClient

                                                                                                                      type ListNamedQueriesAPIClient interface {
                                                                                                                      	ListNamedQueries(context.Context, *ListNamedQueriesInput, ...func(*Options)) (*ListNamedQueriesOutput, error)
                                                                                                                      }

                                                                                                                        ListNamedQueriesAPIClient is a client that implements the ListNamedQueries operation.

                                                                                                                        type ListNamedQueriesInput

                                                                                                                        type ListNamedQueriesInput struct {
                                                                                                                        
                                                                                                                        	// The maximum number of queries to return in this request.
                                                                                                                        	MaxResults *int32
                                                                                                                        
                                                                                                                        	// A token generated by the Athena service that specifies where to continue
                                                                                                                        	// pagination if a previous request was truncated. To obtain the next set of pages,
                                                                                                                        	// pass in the NextToken from the response object of the previous page call.
                                                                                                                        	NextToken *string
                                                                                                                        
                                                                                                                        	// The name of the workgroup from which the named queries are being returned. If a
                                                                                                                        	// workgroup is not specified, the saved queries for the primary workgroup are
                                                                                                                        	// returned.
                                                                                                                        	WorkGroup *string
                                                                                                                        }

                                                                                                                        type ListNamedQueriesOutput

                                                                                                                        type ListNamedQueriesOutput struct {
                                                                                                                        
                                                                                                                        	// The list of unique query IDs.
                                                                                                                        	NamedQueryIds []string
                                                                                                                        
                                                                                                                        	// A token generated by the Athena service that specifies where to continue
                                                                                                                        	// pagination if a previous request was truncated. To obtain the next set of pages,
                                                                                                                        	// pass in the NextToken from the response object of the previous page call.
                                                                                                                        	NextToken *string
                                                                                                                        
                                                                                                                        	// Metadata pertaining to the operation's result.
                                                                                                                        	ResultMetadata middleware.Metadata
                                                                                                                        }

                                                                                                                        type ListNamedQueriesPaginator

                                                                                                                        type ListNamedQueriesPaginator struct {
                                                                                                                        	// contains filtered or unexported fields
                                                                                                                        }

                                                                                                                          ListNamedQueriesPaginator is a paginator for ListNamedQueries

                                                                                                                          func NewListNamedQueriesPaginator

                                                                                                                          func NewListNamedQueriesPaginator(client ListNamedQueriesAPIClient, params *ListNamedQueriesInput, optFns ...func(*ListNamedQueriesPaginatorOptions)) *ListNamedQueriesPaginator

                                                                                                                            NewListNamedQueriesPaginator returns a new ListNamedQueriesPaginator

                                                                                                                            func (*ListNamedQueriesPaginator) HasMorePages

                                                                                                                            func (p *ListNamedQueriesPaginator) HasMorePages() bool

                                                                                                                              HasMorePages returns a boolean indicating whether more pages are available

                                                                                                                              func (*ListNamedQueriesPaginator) NextPage

                                                                                                                              func (p *ListNamedQueriesPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListNamedQueriesOutput, error)

                                                                                                                                NextPage retrieves the next ListNamedQueries page.

                                                                                                                                type ListNamedQueriesPaginatorOptions

                                                                                                                                type ListNamedQueriesPaginatorOptions struct {
                                                                                                                                	// The maximum number of queries to return in this request.
                                                                                                                                	Limit int32
                                                                                                                                
                                                                                                                                	// Set to true if pagination should stop if the service returns a pagination token
                                                                                                                                	// that matches the most recent token provided to the service.
                                                                                                                                	StopOnDuplicateToken bool
                                                                                                                                }

                                                                                                                                  ListNamedQueriesPaginatorOptions is the paginator options for ListNamedQueries

                                                                                                                                  type ListQueryExecutionsAPIClient

                                                                                                                                  type ListQueryExecutionsAPIClient interface {
                                                                                                                                  	ListQueryExecutions(context.Context, *ListQueryExecutionsInput, ...func(*Options)) (*ListQueryExecutionsOutput, error)
                                                                                                                                  }

                                                                                                                                    ListQueryExecutionsAPIClient is a client that implements the ListQueryExecutions operation.

                                                                                                                                    type ListQueryExecutionsInput

                                                                                                                                    type ListQueryExecutionsInput struct {
                                                                                                                                    
                                                                                                                                    	// The maximum number of query executions to return in this request.
                                                                                                                                    	MaxResults *int32
                                                                                                                                    
                                                                                                                                    	// A token generated by the Athena service that specifies where to continue
                                                                                                                                    	// pagination if a previous request was truncated. To obtain the next set of pages,
                                                                                                                                    	// pass in the NextToken from the response object of the previous page call.
                                                                                                                                    	NextToken *string
                                                                                                                                    
                                                                                                                                    	// The name of the workgroup from which queries are being returned. If a workgroup
                                                                                                                                    	// is not specified, a list of available query execution IDs for the queries in the
                                                                                                                                    	// primary workgroup is returned.
                                                                                                                                    	WorkGroup *string
                                                                                                                                    }

                                                                                                                                    type ListQueryExecutionsOutput

                                                                                                                                    type ListQueryExecutionsOutput struct {
                                                                                                                                    
                                                                                                                                    	// A token to be used by the next request if this request is truncated.
                                                                                                                                    	NextToken *string
                                                                                                                                    
                                                                                                                                    	// The unique IDs of each query execution as an array of strings.
                                                                                                                                    	QueryExecutionIds []string
                                                                                                                                    
                                                                                                                                    	// Metadata pertaining to the operation's result.
                                                                                                                                    	ResultMetadata middleware.Metadata
                                                                                                                                    }

                                                                                                                                    type ListQueryExecutionsPaginator

                                                                                                                                    type ListQueryExecutionsPaginator struct {
                                                                                                                                    	// contains filtered or unexported fields
                                                                                                                                    }

                                                                                                                                      ListQueryExecutionsPaginator is a paginator for ListQueryExecutions

                                                                                                                                      func NewListQueryExecutionsPaginator

                                                                                                                                      func NewListQueryExecutionsPaginator(client ListQueryExecutionsAPIClient, params *ListQueryExecutionsInput, optFns ...func(*ListQueryExecutionsPaginatorOptions)) *ListQueryExecutionsPaginator

                                                                                                                                        NewListQueryExecutionsPaginator returns a new ListQueryExecutionsPaginator

                                                                                                                                        func (*ListQueryExecutionsPaginator) HasMorePages

                                                                                                                                        func (p *ListQueryExecutionsPaginator) HasMorePages() bool

                                                                                                                                          HasMorePages returns a boolean indicating whether more pages are available

                                                                                                                                          func (*ListQueryExecutionsPaginator) NextPage

                                                                                                                                          func (p *ListQueryExecutionsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListQueryExecutionsOutput, error)

                                                                                                                                            NextPage retrieves the next ListQueryExecutions page.

                                                                                                                                            type ListQueryExecutionsPaginatorOptions

                                                                                                                                            type ListQueryExecutionsPaginatorOptions struct {
                                                                                                                                            	// The maximum number of query executions to return in this request.
                                                                                                                                            	Limit int32
                                                                                                                                            
                                                                                                                                            	// Set to true if pagination should stop if the service returns a pagination token
                                                                                                                                            	// that matches the most recent token provided to the service.
                                                                                                                                            	StopOnDuplicateToken bool
                                                                                                                                            }

                                                                                                                                              ListQueryExecutionsPaginatorOptions is the paginator options for ListQueryExecutions

                                                                                                                                              type ListTableMetadataAPIClient

                                                                                                                                              type ListTableMetadataAPIClient interface {
                                                                                                                                              	ListTableMetadata(context.Context, *ListTableMetadataInput, ...func(*Options)) (*ListTableMetadataOutput, error)
                                                                                                                                              }

                                                                                                                                                ListTableMetadataAPIClient is a client that implements the ListTableMetadata operation.

                                                                                                                                                type ListTableMetadataInput

                                                                                                                                                type ListTableMetadataInput struct {
                                                                                                                                                
                                                                                                                                                	// The name of the data catalog for which table metadata should be returned.
                                                                                                                                                	//
                                                                                                                                                	// This member is required.
                                                                                                                                                	CatalogName *string
                                                                                                                                                
                                                                                                                                                	// The name of the database for which table metadata should be returned.
                                                                                                                                                	//
                                                                                                                                                	// This member is required.
                                                                                                                                                	DatabaseName *string
                                                                                                                                                
                                                                                                                                                	// A regex filter that pattern-matches table names. If no expression is supplied,
                                                                                                                                                	// metadata for all tables are listed.
                                                                                                                                                	Expression *string
                                                                                                                                                
                                                                                                                                                	// Specifies the maximum number of results to return.
                                                                                                                                                	MaxResults *int32
                                                                                                                                                
                                                                                                                                                	// A token generated by the Athena service that specifies where to continue
                                                                                                                                                	// pagination if a previous request was truncated. To obtain the next set of pages,
                                                                                                                                                	// pass in the NextToken from the response object of the previous page call.
                                                                                                                                                	NextToken *string
                                                                                                                                                }

                                                                                                                                                type ListTableMetadataOutput

                                                                                                                                                type ListTableMetadataOutput struct {
                                                                                                                                                
                                                                                                                                                	// A token generated by the Athena service that specifies where to continue
                                                                                                                                                	// pagination if a previous request was truncated. To obtain the next set of pages,
                                                                                                                                                	// pass in the NextToken from the response object of the previous page call.
                                                                                                                                                	NextToken *string
                                                                                                                                                
                                                                                                                                                	// A list of table metadata.
                                                                                                                                                	TableMetadataList []types.TableMetadata
                                                                                                                                                
                                                                                                                                                	// Metadata pertaining to the operation's result.
                                                                                                                                                	ResultMetadata middleware.Metadata
                                                                                                                                                }

                                                                                                                                                type ListTableMetadataPaginator

                                                                                                                                                type ListTableMetadataPaginator struct {
                                                                                                                                                	// contains filtered or unexported fields
                                                                                                                                                }

                                                                                                                                                  ListTableMetadataPaginator is a paginator for ListTableMetadata

                                                                                                                                                  func NewListTableMetadataPaginator

                                                                                                                                                  func NewListTableMetadataPaginator(client ListTableMetadataAPIClient, params *ListTableMetadataInput, optFns ...func(*ListTableMetadataPaginatorOptions)) *ListTableMetadataPaginator

                                                                                                                                                    NewListTableMetadataPaginator returns a new ListTableMetadataPaginator

                                                                                                                                                    func (*ListTableMetadataPaginator) HasMorePages

                                                                                                                                                    func (p *ListTableMetadataPaginator) HasMorePages() bool

                                                                                                                                                      HasMorePages returns a boolean indicating whether more pages are available

                                                                                                                                                      func (*ListTableMetadataPaginator) NextPage

                                                                                                                                                      func (p *ListTableMetadataPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListTableMetadataOutput, error)

                                                                                                                                                        NextPage retrieves the next ListTableMetadata page.

                                                                                                                                                        type ListTableMetadataPaginatorOptions

                                                                                                                                                        type ListTableMetadataPaginatorOptions struct {
                                                                                                                                                        	// Specifies the maximum number of results to return.
                                                                                                                                                        	Limit int32
                                                                                                                                                        
                                                                                                                                                        	// Set to true if pagination should stop if the service returns a pagination token
                                                                                                                                                        	// that matches the most recent token provided to the service.
                                                                                                                                                        	StopOnDuplicateToken bool
                                                                                                                                                        }

                                                                                                                                                          ListTableMetadataPaginatorOptions is the paginator options for ListTableMetadata

                                                                                                                                                          type ListTagsForResourceAPIClient

                                                                                                                                                          type ListTagsForResourceAPIClient interface {
                                                                                                                                                          	ListTagsForResource(context.Context, *ListTagsForResourceInput, ...func(*Options)) (*ListTagsForResourceOutput, error)
                                                                                                                                                          }

                                                                                                                                                            ListTagsForResourceAPIClient is a client that implements the ListTagsForResource operation.

                                                                                                                                                            type ListTagsForResourceInput

                                                                                                                                                            type ListTagsForResourceInput struct {
                                                                                                                                                            
                                                                                                                                                            	// Lists the tags for the resource with the specified ARN.
                                                                                                                                                            	//
                                                                                                                                                            	// This member is required.
                                                                                                                                                            	ResourceARN *string
                                                                                                                                                            
                                                                                                                                                            	// The maximum number of results to be returned per request that lists the tags for
                                                                                                                                                            	// the resource.
                                                                                                                                                            	MaxResults *int32
                                                                                                                                                            
                                                                                                                                                            	// The token for the next set of results, or null if there are no additional
                                                                                                                                                            	// results for this request, where the request lists the tags for the resource with
                                                                                                                                                            	// the specified ARN.
                                                                                                                                                            	NextToken *string
                                                                                                                                                            }

                                                                                                                                                            type ListTagsForResourceOutput

                                                                                                                                                            type ListTagsForResourceOutput struct {
                                                                                                                                                            
                                                                                                                                                            	// A token to be used by the next request if this request is truncated.
                                                                                                                                                            	NextToken *string
                                                                                                                                                            
                                                                                                                                                            	// The list of tags associated with the specified resource.
                                                                                                                                                            	Tags []types.Tag
                                                                                                                                                            
                                                                                                                                                            	// Metadata pertaining to the operation's result.
                                                                                                                                                            	ResultMetadata middleware.Metadata
                                                                                                                                                            }

                                                                                                                                                            type ListTagsForResourcePaginator

                                                                                                                                                            type ListTagsForResourcePaginator struct {
                                                                                                                                                            	// contains filtered or unexported fields
                                                                                                                                                            }

                                                                                                                                                              ListTagsForResourcePaginator is a paginator for ListTagsForResource

                                                                                                                                                              func NewListTagsForResourcePaginator

                                                                                                                                                              func NewListTagsForResourcePaginator(client ListTagsForResourceAPIClient, params *ListTagsForResourceInput, optFns ...func(*ListTagsForResourcePaginatorOptions)) *ListTagsForResourcePaginator

                                                                                                                                                                NewListTagsForResourcePaginator returns a new ListTagsForResourcePaginator

                                                                                                                                                                func (*ListTagsForResourcePaginator) HasMorePages

                                                                                                                                                                func (p *ListTagsForResourcePaginator) HasMorePages() bool

                                                                                                                                                                  HasMorePages returns a boolean indicating whether more pages are available

                                                                                                                                                                  func (*ListTagsForResourcePaginator) NextPage

                                                                                                                                                                  func (p *ListTagsForResourcePaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListTagsForResourceOutput, error)

                                                                                                                                                                    NextPage retrieves the next ListTagsForResource page.

                                                                                                                                                                    type ListTagsForResourcePaginatorOptions

                                                                                                                                                                    type ListTagsForResourcePaginatorOptions struct {
                                                                                                                                                                    	// The maximum number of results to be returned per request that lists the tags for
                                                                                                                                                                    	// the resource.
                                                                                                                                                                    	Limit int32
                                                                                                                                                                    
                                                                                                                                                                    	// Set to true if pagination should stop if the service returns a pagination token
                                                                                                                                                                    	// that matches the most recent token provided to the service.
                                                                                                                                                                    	StopOnDuplicateToken bool
                                                                                                                                                                    }

                                                                                                                                                                      ListTagsForResourcePaginatorOptions is the paginator options for ListTagsForResource

                                                                                                                                                                      type ListWorkGroupsAPIClient

                                                                                                                                                                      type ListWorkGroupsAPIClient interface {
                                                                                                                                                                      	ListWorkGroups(context.Context, *ListWorkGroupsInput, ...func(*Options)) (*ListWorkGroupsOutput, error)
                                                                                                                                                                      }

                                                                                                                                                                        ListWorkGroupsAPIClient is a client that implements the ListWorkGroups operation.

                                                                                                                                                                        type ListWorkGroupsInput

                                                                                                                                                                        type ListWorkGroupsInput struct {
                                                                                                                                                                        
                                                                                                                                                                        	// The maximum number of workgroups to return in this request.
                                                                                                                                                                        	MaxResults *int32
                                                                                                                                                                        
                                                                                                                                                                        	// A token generated by the Athena service that specifies where to continue
                                                                                                                                                                        	// pagination if a previous request was truncated. To obtain the next set of pages,
                                                                                                                                                                        	// pass in the NextToken from the response object of the previous page call.
                                                                                                                                                                        	NextToken *string
                                                                                                                                                                        }

                                                                                                                                                                        type ListWorkGroupsOutput

                                                                                                                                                                        type ListWorkGroupsOutput struct {
                                                                                                                                                                        
                                                                                                                                                                        	// A token generated by the Athena service that specifies where to continue
                                                                                                                                                                        	// pagination if a previous request was truncated. To obtain the next set of pages,
                                                                                                                                                                        	// pass in the NextToken from the response object of the previous page call.
                                                                                                                                                                        	NextToken *string
                                                                                                                                                                        
                                                                                                                                                                        	// The list of workgroups, including their names, descriptions, creation times, and
                                                                                                                                                                        	// states.
                                                                                                                                                                        	WorkGroups []types.WorkGroupSummary
                                                                                                                                                                        
                                                                                                                                                                        	// Metadata pertaining to the operation's result.
                                                                                                                                                                        	ResultMetadata middleware.Metadata
                                                                                                                                                                        }

                                                                                                                                                                        type ListWorkGroupsPaginator

                                                                                                                                                                        type ListWorkGroupsPaginator struct {
                                                                                                                                                                        	// contains filtered or unexported fields
                                                                                                                                                                        }

                                                                                                                                                                          ListWorkGroupsPaginator is a paginator for ListWorkGroups

                                                                                                                                                                          func NewListWorkGroupsPaginator

                                                                                                                                                                          func NewListWorkGroupsPaginator(client ListWorkGroupsAPIClient, params *ListWorkGroupsInput, optFns ...func(*ListWorkGroupsPaginatorOptions)) *ListWorkGroupsPaginator

                                                                                                                                                                            NewListWorkGroupsPaginator returns a new ListWorkGroupsPaginator

                                                                                                                                                                            func (*ListWorkGroupsPaginator) HasMorePages

                                                                                                                                                                            func (p *ListWorkGroupsPaginator) HasMorePages() bool

                                                                                                                                                                              HasMorePages returns a boolean indicating whether more pages are available

                                                                                                                                                                              func (*ListWorkGroupsPaginator) NextPage

                                                                                                                                                                              func (p *ListWorkGroupsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListWorkGroupsOutput, error)

                                                                                                                                                                                NextPage retrieves the next ListWorkGroups page.

                                                                                                                                                                                type ListWorkGroupsPaginatorOptions

                                                                                                                                                                                type ListWorkGroupsPaginatorOptions struct {
                                                                                                                                                                                	// The maximum number of workgroups to return in this request.
                                                                                                                                                                                	Limit int32
                                                                                                                                                                                
                                                                                                                                                                                	// Set to true if pagination should stop if the service returns a pagination token
                                                                                                                                                                                	// that matches the most recent token provided to the service.
                                                                                                                                                                                	StopOnDuplicateToken bool
                                                                                                                                                                                }

                                                                                                                                                                                  ListWorkGroupsPaginatorOptions is the paginator options for ListWorkGroups

                                                                                                                                                                                  type Options

                                                                                                                                                                                  type Options struct {
                                                                                                                                                                                  	// Set of options to modify how an operation is invoked. These apply to all
                                                                                                                                                                                  	// operations invoked for this client. Use functional options on operation call to
                                                                                                                                                                                  	// modify this list for per operation behavior.
                                                                                                                                                                                  	APIOptions []func(*middleware.Stack) error
                                                                                                                                                                                  
                                                                                                                                                                                  	// Configures the events that will be sent to the configured logger.
                                                                                                                                                                                  	ClientLogMode aws.ClientLogMode
                                                                                                                                                                                  
                                                                                                                                                                                  	// The credentials object to use when signing requests.
                                                                                                                                                                                  	Credentials aws.CredentialsProvider
                                                                                                                                                                                  
                                                                                                                                                                                  	// The endpoint options to be used when attempting to resolve an endpoint.
                                                                                                                                                                                  	EndpointOptions EndpointResolverOptions
                                                                                                                                                                                  
                                                                                                                                                                                  	// The service endpoint resolver.
                                                                                                                                                                                  	EndpointResolver EndpointResolver
                                                                                                                                                                                  
                                                                                                                                                                                  	// Signature Version 4 (SigV4) Signer
                                                                                                                                                                                  	HTTPSignerV4 HTTPSignerV4
                                                                                                                                                                                  
                                                                                                                                                                                  	// Provides idempotency tokens values that will be automatically populated into
                                                                                                                                                                                  	// idempotent API operations.
                                                                                                                                                                                  	IdempotencyTokenProvider IdempotencyTokenProvider
                                                                                                                                                                                  
                                                                                                                                                                                  	// The logger writer interface to write logging messages to.
                                                                                                                                                                                  	Logger logging.Logger
                                                                                                                                                                                  
                                                                                                                                                                                  	// The region to send requests to. (Required)
                                                                                                                                                                                  	Region string
                                                                                                                                                                                  
                                                                                                                                                                                  	// Retryer guides how HTTP requests should be retried in case of recoverable
                                                                                                                                                                                  	// failures. When nil the API client will use a default retryer.
                                                                                                                                                                                  	Retryer aws.Retryer
                                                                                                                                                                                  
                                                                                                                                                                                  	// The HTTP client to invoke API calls with. Defaults to client's default HTTP
                                                                                                                                                                                  	// implementation if nil.
                                                                                                                                                                                  	HTTPClient HTTPClient
                                                                                                                                                                                  }

                                                                                                                                                                                  func (Options) Copy

                                                                                                                                                                                  func (o Options) Copy() Options

                                                                                                                                                                                    Copy creates a clone where the APIOptions list is deep copied.

                                                                                                                                                                                    type ResolveEndpoint

                                                                                                                                                                                    type ResolveEndpoint struct {
                                                                                                                                                                                    	Resolver EndpointResolver
                                                                                                                                                                                    	Options  EndpointResolverOptions
                                                                                                                                                                                    }

                                                                                                                                                                                    func (*ResolveEndpoint) HandleSerialize

                                                                                                                                                                                    func (*ResolveEndpoint) ID

                                                                                                                                                                                    func (*ResolveEndpoint) ID() string

                                                                                                                                                                                    type StartQueryExecutionInput

                                                                                                                                                                                    type StartQueryExecutionInput struct {
                                                                                                                                                                                    
                                                                                                                                                                                    	// The SQL query statements to be executed.
                                                                                                                                                                                    	//
                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                    	QueryString *string
                                                                                                                                                                                    
                                                                                                                                                                                    	// A unique case-sensitive string used to ensure the request to create the query is
                                                                                                                                                                                    	// idempotent (executes only once). If another StartQueryExecution request is
                                                                                                                                                                                    	// received, the same response is returned and another query is not created. If a
                                                                                                                                                                                    	// parameter has changed, for example, the QueryString, an error is returned. This
                                                                                                                                                                                    	// token is listed as not required because AWS SDKs (for example the AWS SDK for
                                                                                                                                                                                    	// Java) auto-generate the token for users. If you are not using the AWS SDK or the
                                                                                                                                                                                    	// AWS CLI, you must provide this token or the action will fail.
                                                                                                                                                                                    	ClientRequestToken *string
                                                                                                                                                                                    
                                                                                                                                                                                    	// The database within which the query executes.
                                                                                                                                                                                    	QueryExecutionContext *types.QueryExecutionContext
                                                                                                                                                                                    
                                                                                                                                                                                    	// Specifies information about where and how to save the results of the query
                                                                                                                                                                                    	// execution. If the query runs in a workgroup, then workgroup's settings may
                                                                                                                                                                                    	// override query settings. This affects the query results location. The workgroup
                                                                                                                                                                                    	// settings override is specified in EnforceWorkGroupConfiguration (true/false) in
                                                                                                                                                                                    	// the WorkGroupConfiguration. See
                                                                                                                                                                                    	// WorkGroupConfiguration$EnforceWorkGroupConfiguration.
                                                                                                                                                                                    	ResultConfiguration *types.ResultConfiguration
                                                                                                                                                                                    
                                                                                                                                                                                    	// The name of the workgroup in which the query is being started.
                                                                                                                                                                                    	WorkGroup *string
                                                                                                                                                                                    }

                                                                                                                                                                                    type StartQueryExecutionOutput

                                                                                                                                                                                    type StartQueryExecutionOutput struct {
                                                                                                                                                                                    
                                                                                                                                                                                    	// The unique ID of the query that ran as a result of this request.
                                                                                                                                                                                    	QueryExecutionId *string
                                                                                                                                                                                    
                                                                                                                                                                                    	// Metadata pertaining to the operation's result.
                                                                                                                                                                                    	ResultMetadata middleware.Metadata
                                                                                                                                                                                    }

                                                                                                                                                                                    type StopQueryExecutionInput

                                                                                                                                                                                    type StopQueryExecutionInput struct {
                                                                                                                                                                                    
                                                                                                                                                                                    	// The unique ID of the query execution to stop.
                                                                                                                                                                                    	//
                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                    	QueryExecutionId *string
                                                                                                                                                                                    }

                                                                                                                                                                                    type StopQueryExecutionOutput

                                                                                                                                                                                    type StopQueryExecutionOutput struct {
                                                                                                                                                                                    	// Metadata pertaining to the operation's result.
                                                                                                                                                                                    	ResultMetadata middleware.Metadata
                                                                                                                                                                                    }

                                                                                                                                                                                    type TagResourceInput

                                                                                                                                                                                    type TagResourceInput struct {
                                                                                                                                                                                    
                                                                                                                                                                                    	// Specifies the ARN of the Athena resource (workgroup or data catalog) to which
                                                                                                                                                                                    	// tags are to be added.
                                                                                                                                                                                    	//
                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                    	ResourceARN *string
                                                                                                                                                                                    
                                                                                                                                                                                    	// A collection of one or more tags, separated by commas, to be added to an Athena
                                                                                                                                                                                    	// workgroup or data catalog resource.
                                                                                                                                                                                    	//
                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                    	Tags []types.Tag
                                                                                                                                                                                    }

                                                                                                                                                                                    type TagResourceOutput

                                                                                                                                                                                    type TagResourceOutput struct {
                                                                                                                                                                                    	// Metadata pertaining to the operation's result.
                                                                                                                                                                                    	ResultMetadata middleware.Metadata
                                                                                                                                                                                    }

                                                                                                                                                                                    type UntagResourceInput

                                                                                                                                                                                    type UntagResourceInput struct {
                                                                                                                                                                                    
                                                                                                                                                                                    	// Specifies the ARN of the resource from which tags are to be removed.
                                                                                                                                                                                    	//
                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                    	ResourceARN *string
                                                                                                                                                                                    
                                                                                                                                                                                    	// A comma-separated list of one or more tag keys whose tags are to be removed from
                                                                                                                                                                                    	// the specified resource.
                                                                                                                                                                                    	//
                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                    	TagKeys []string
                                                                                                                                                                                    }

                                                                                                                                                                                    type UntagResourceOutput

                                                                                                                                                                                    type UntagResourceOutput struct {
                                                                                                                                                                                    	// Metadata pertaining to the operation's result.
                                                                                                                                                                                    	ResultMetadata middleware.Metadata
                                                                                                                                                                                    }

                                                                                                                                                                                    type UpdateDataCatalogInput

                                                                                                                                                                                    type UpdateDataCatalogInput struct {
                                                                                                                                                                                    
                                                                                                                                                                                    	// The name of the data catalog to update. The catalog name must be unique for the
                                                                                                                                                                                    	// AWS account and can use a maximum of 128 alphanumeric, underscore, at sign, or
                                                                                                                                                                                    	// hyphen characters.
                                                                                                                                                                                    	//
                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                    	Name *string
                                                                                                                                                                                    
                                                                                                                                                                                    	// Specifies the type of data catalog to update. Specify LAMBDA for a federated
                                                                                                                                                                                    	// catalog, GLUE for AWS Glue Catalog, or HIVE for an external hive metastore.
                                                                                                                                                                                    	//
                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                    	Type types.DataCatalogType
                                                                                                                                                                                    
                                                                                                                                                                                    	// New or modified text that describes the data catalog.
                                                                                                                                                                                    	Description *string
                                                                                                                                                                                    
                                                                                                                                                                                    	// Specifies the Lambda function or functions to use for updating the data catalog.
                                                                                                                                                                                    	// This is a mapping whose values depend on the catalog type.
                                                                                                                                                                                    	//
                                                                                                                                                                                    	// * For the HIVE data
                                                                                                                                                                                    	// catalog type, use the following syntax. The metadata-function parameter is
                                                                                                                                                                                    	// required. The sdk-version parameter is optional and defaults to the currently
                                                                                                                                                                                    	// supported version. metadata-function=lambda_arn, sdk-version=version_number
                                                                                                                                                                                    	//
                                                                                                                                                                                    	// *
                                                                                                                                                                                    	// For the LAMBDA data catalog type, use one of the following sets of required
                                                                                                                                                                                    	// parameters, but not both.
                                                                                                                                                                                    	//
                                                                                                                                                                                    	// * If you have one Lambda function that processes
                                                                                                                                                                                    	// metadata and another for reading the actual data, use the following syntax. Both
                                                                                                                                                                                    	// parameters are required. metadata-function=lambda_arn,
                                                                                                                                                                                    	// record-function=lambda_arn
                                                                                                                                                                                    	//
                                                                                                                                                                                    	// * If you have a composite Lambda function that
                                                                                                                                                                                    	// processes both metadata and data, use the following syntax to specify your
                                                                                                                                                                                    	// Lambda function. function=lambda_arn
                                                                                                                                                                                    	//
                                                                                                                                                                                    	// * The GLUE type has no parameters.
                                                                                                                                                                                    	Parameters map[string]string
                                                                                                                                                                                    }

                                                                                                                                                                                    type UpdateDataCatalogOutput

                                                                                                                                                                                    type UpdateDataCatalogOutput struct {
                                                                                                                                                                                    	// Metadata pertaining to the operation's result.
                                                                                                                                                                                    	ResultMetadata middleware.Metadata
                                                                                                                                                                                    }

                                                                                                                                                                                    type UpdateWorkGroupInput

                                                                                                                                                                                    type UpdateWorkGroupInput struct {
                                                                                                                                                                                    
                                                                                                                                                                                    	// The specified workgroup that will be updated.
                                                                                                                                                                                    	//
                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                    	WorkGroup *string
                                                                                                                                                                                    
                                                                                                                                                                                    	// The workgroup configuration that will be updated for the given workgroup.
                                                                                                                                                                                    	ConfigurationUpdates *types.WorkGroupConfigurationUpdates
                                                                                                                                                                                    
                                                                                                                                                                                    	// The workgroup description.
                                                                                                                                                                                    	Description *string
                                                                                                                                                                                    
                                                                                                                                                                                    	// The workgroup state that will be updated for the given workgroup.
                                                                                                                                                                                    	State types.WorkGroupState
                                                                                                                                                                                    }

                                                                                                                                                                                    type UpdateWorkGroupOutput

                                                                                                                                                                                    type UpdateWorkGroupOutput struct {
                                                                                                                                                                                    	// Metadata pertaining to the operation's result.
                                                                                                                                                                                    	ResultMetadata middleware.Metadata
                                                                                                                                                                                    }

                                                                                                                                                                                    Directories

                                                                                                                                                                                    Path Synopsis
                                                                                                                                                                                    internal