use std::error::Error;
use std::fmt;
use async_trait::async_trait;
use rusoto_core::credential::ProvideAwsCredentials;
use rusoto_core::region;
use rusoto_core::request::{BufferedHttpResponse, DispatchSignedRequest};
use rusoto_core::{Client, RusotoError};
use rusoto_core::proto;
use rusoto_core::request::HttpResponse;
use rusoto_core::signature::SignedRequest;
#[allow(unused_imports)]
use serde::{Deserialize, Serialize};
impl AthenaClient {
fn new_signed_request(&self, http_method: &str, request_uri: &str) -> SignedRequest {
let mut request = SignedRequest::new(http_method, "athena", &self.region, request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request
}
async fn sign_and_dispatch<E>(
&self,
request: SignedRequest,
from_response: fn(BufferedHttpResponse) -> RusotoError<E>,
) -> Result<HttpResponse, RusotoError<E>> {
let mut response = self.client.sign_and_dispatch(request).await?;
if !response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
return Err(from_response(response));
}
Ok(response)
}
}
use serde_json;
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct BatchGetNamedQueryInput {
#[serde(rename = "NamedQueryIds")]
pub named_query_ids: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BatchGetNamedQueryOutput {
#[serde(rename = "NamedQueries")]
#[serde(skip_serializing_if = "Option::is_none")]
pub named_queries: Option<Vec<NamedQuery>>,
#[serde(rename = "UnprocessedNamedQueryIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub unprocessed_named_query_ids: Option<Vec<UnprocessedNamedQueryId>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct BatchGetQueryExecutionInput {
#[serde(rename = "QueryExecutionIds")]
pub query_execution_ids: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BatchGetQueryExecutionOutput {
#[serde(rename = "QueryExecutions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub query_executions: Option<Vec<QueryExecution>>,
#[serde(rename = "UnprocessedQueryExecutionIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub unprocessed_query_execution_ids: Option<Vec<UnprocessedQueryExecutionId>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Column {
#[serde(rename = "Comment")]
#[serde(skip_serializing_if = "Option::is_none")]
pub comment: Option<String>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ColumnInfo {
#[serde(rename = "CaseSensitive")]
#[serde(skip_serializing_if = "Option::is_none")]
pub case_sensitive: Option<bool>,
#[serde(rename = "CatalogName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub catalog_name: Option<String>,
#[serde(rename = "Label")]
#[serde(skip_serializing_if = "Option::is_none")]
pub label: Option<String>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Nullable")]
#[serde(skip_serializing_if = "Option::is_none")]
pub nullable: Option<String>,
#[serde(rename = "Precision")]
#[serde(skip_serializing_if = "Option::is_none")]
pub precision: Option<i64>,
#[serde(rename = "Scale")]
#[serde(skip_serializing_if = "Option::is_none")]
pub scale: Option<i64>,
#[serde(rename = "SchemaName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub schema_name: Option<String>,
#[serde(rename = "TableName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub table_name: Option<String>,
#[serde(rename = "Type")]
pub type_: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateDataCatalogInput {
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Parameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub parameters: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
#[serde(rename = "Type")]
pub type_: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateDataCatalogOutput {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateNamedQueryInput {
#[serde(rename = "ClientRequestToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_request_token: Option<String>,
#[serde(rename = "Database")]
pub database: String,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "QueryString")]
pub query_string: String,
#[serde(rename = "WorkGroup")]
#[serde(skip_serializing_if = "Option::is_none")]
pub work_group: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateNamedQueryOutput {
#[serde(rename = "NamedQueryId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub named_query_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateWorkGroupInput {
#[serde(rename = "Configuration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub configuration: Option<WorkGroupConfiguration>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateWorkGroupOutput {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DataCatalog {
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Parameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub parameters: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "Type")]
pub type_: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DataCatalogSummary {
#[serde(rename = "CatalogName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub catalog_name: Option<String>,
#[serde(rename = "Type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Database {
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Parameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub parameters: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Datum {
#[serde(rename = "VarCharValue")]
#[serde(skip_serializing_if = "Option::is_none")]
pub var_char_value: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteDataCatalogInput {
#[serde(rename = "Name")]
pub name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteDataCatalogOutput {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteNamedQueryInput {
#[serde(rename = "NamedQueryId")]
pub named_query_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteNamedQueryOutput {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteWorkGroupInput {
#[serde(rename = "RecursiveDeleteOption")]
#[serde(skip_serializing_if = "Option::is_none")]
pub recursive_delete_option: Option<bool>,
#[serde(rename = "WorkGroup")]
pub work_group: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteWorkGroupOutput {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct EncryptionConfiguration {
#[serde(rename = "EncryptionOption")]
pub encryption_option: String,
#[serde(rename = "KmsKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kms_key: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetDataCatalogInput {
#[serde(rename = "Name")]
pub name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetDataCatalogOutput {
#[serde(rename = "DataCatalog")]
#[serde(skip_serializing_if = "Option::is_none")]
pub data_catalog: Option<DataCatalog>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetDatabaseInput {
#[serde(rename = "CatalogName")]
pub catalog_name: String,
#[serde(rename = "DatabaseName")]
pub database_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetDatabaseOutput {
#[serde(rename = "Database")]
#[serde(skip_serializing_if = "Option::is_none")]
pub database: Option<Database>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetNamedQueryInput {
#[serde(rename = "NamedQueryId")]
pub named_query_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetNamedQueryOutput {
#[serde(rename = "NamedQuery")]
#[serde(skip_serializing_if = "Option::is_none")]
pub named_query: Option<NamedQuery>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetQueryExecutionInput {
#[serde(rename = "QueryExecutionId")]
pub query_execution_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetQueryExecutionOutput {
#[serde(rename = "QueryExecution")]
#[serde(skip_serializing_if = "Option::is_none")]
pub query_execution: Option<QueryExecution>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetQueryResultsInput {
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "QueryExecutionId")]
pub query_execution_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetQueryResultsOutput {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "ResultSet")]
#[serde(skip_serializing_if = "Option::is_none")]
pub result_set: Option<ResultSet>,
#[serde(rename = "UpdateCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub update_count: Option<i64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetTableMetadataInput {
#[serde(rename = "CatalogName")]
pub catalog_name: String,
#[serde(rename = "DatabaseName")]
pub database_name: String,
#[serde(rename = "TableName")]
pub table_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetTableMetadataOutput {
#[serde(rename = "TableMetadata")]
#[serde(skip_serializing_if = "Option::is_none")]
pub table_metadata: Option<TableMetadata>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetWorkGroupInput {
#[serde(rename = "WorkGroup")]
pub work_group: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetWorkGroupOutput {
#[serde(rename = "WorkGroup")]
#[serde(skip_serializing_if = "Option::is_none")]
pub work_group: Option<WorkGroup>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListDataCatalogsInput {
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListDataCatalogsOutput {
#[serde(rename = "DataCatalogsSummary")]
#[serde(skip_serializing_if = "Option::is_none")]
pub data_catalogs_summary: Option<Vec<DataCatalogSummary>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListDatabasesInput {
#[serde(rename = "CatalogName")]
pub catalog_name: String,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListDatabasesOutput {
#[serde(rename = "DatabaseList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub database_list: Option<Vec<Database>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListNamedQueriesInput {
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "WorkGroup")]
#[serde(skip_serializing_if = "Option::is_none")]
pub work_group: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListNamedQueriesOutput {
#[serde(rename = "NamedQueryIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub named_query_ids: Option<Vec<String>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListQueryExecutionsInput {
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "WorkGroup")]
#[serde(skip_serializing_if = "Option::is_none")]
pub work_group: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListQueryExecutionsOutput {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "QueryExecutionIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub query_execution_ids: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListTableMetadataInput {
#[serde(rename = "CatalogName")]
pub catalog_name: String,
#[serde(rename = "DatabaseName")]
pub database_name: String,
#[serde(rename = "Expression")]
#[serde(skip_serializing_if = "Option::is_none")]
pub expression: Option<String>,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListTableMetadataOutput {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "TableMetadataList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub table_metadata_list: Option<Vec<TableMetadata>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListTagsForResourceInput {
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "ResourceARN")]
pub resource_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListTagsForResourceOutput {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListWorkGroupsInput {
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListWorkGroupsOutput {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "WorkGroups")]
#[serde(skip_serializing_if = "Option::is_none")]
pub work_groups: Option<Vec<WorkGroupSummary>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct NamedQuery {
#[serde(rename = "Database")]
pub database: String,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "NamedQueryId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub named_query_id: Option<String>,
#[serde(rename = "QueryString")]
pub query_string: String,
#[serde(rename = "WorkGroup")]
#[serde(skip_serializing_if = "Option::is_none")]
pub work_group: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct QueryExecution {
#[serde(rename = "Query")]
#[serde(skip_serializing_if = "Option::is_none")]
pub query: Option<String>,
#[serde(rename = "QueryExecutionContext")]
#[serde(skip_serializing_if = "Option::is_none")]
pub query_execution_context: Option<QueryExecutionContext>,
#[serde(rename = "QueryExecutionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub query_execution_id: Option<String>,
#[serde(rename = "ResultConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub result_configuration: Option<ResultConfiguration>,
#[serde(rename = "StatementType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub statement_type: Option<String>,
#[serde(rename = "Statistics")]
#[serde(skip_serializing_if = "Option::is_none")]
pub statistics: Option<QueryExecutionStatistics>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<QueryExecutionStatus>,
#[serde(rename = "WorkGroup")]
#[serde(skip_serializing_if = "Option::is_none")]
pub work_group: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct QueryExecutionContext {
#[serde(rename = "Catalog")]
#[serde(skip_serializing_if = "Option::is_none")]
pub catalog: Option<String>,
#[serde(rename = "Database")]
#[serde(skip_serializing_if = "Option::is_none")]
pub database: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct QueryExecutionStatistics {
#[serde(rename = "DataManifestLocation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub data_manifest_location: Option<String>,
#[serde(rename = "DataScannedInBytes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub data_scanned_in_bytes: Option<i64>,
#[serde(rename = "EngineExecutionTimeInMillis")]
#[serde(skip_serializing_if = "Option::is_none")]
pub engine_execution_time_in_millis: Option<i64>,
#[serde(rename = "QueryPlanningTimeInMillis")]
#[serde(skip_serializing_if = "Option::is_none")]
pub query_planning_time_in_millis: Option<i64>,
#[serde(rename = "QueryQueueTimeInMillis")]
#[serde(skip_serializing_if = "Option::is_none")]
pub query_queue_time_in_millis: Option<i64>,
#[serde(rename = "ServiceProcessingTimeInMillis")]
#[serde(skip_serializing_if = "Option::is_none")]
pub service_processing_time_in_millis: Option<i64>,
#[serde(rename = "TotalExecutionTimeInMillis")]
#[serde(skip_serializing_if = "Option::is_none")]
pub total_execution_time_in_millis: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct QueryExecutionStatus {
#[serde(rename = "CompletionDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub completion_date_time: Option<f64>,
#[serde(rename = "State")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<String>,
#[serde(rename = "StateChangeReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state_change_reason: Option<String>,
#[serde(rename = "SubmissionDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub submission_date_time: Option<f64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ResultConfiguration {
#[serde(rename = "EncryptionConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub encryption_configuration: Option<EncryptionConfiguration>,
#[serde(rename = "OutputLocation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub output_location: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ResultConfigurationUpdates {
#[serde(rename = "EncryptionConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub encryption_configuration: Option<EncryptionConfiguration>,
#[serde(rename = "OutputLocation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub output_location: Option<String>,
#[serde(rename = "RemoveEncryptionConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub remove_encryption_configuration: Option<bool>,
#[serde(rename = "RemoveOutputLocation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub remove_output_location: Option<bool>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ResultSet {
#[serde(rename = "ResultSetMetadata")]
#[serde(skip_serializing_if = "Option::is_none")]
pub result_set_metadata: Option<ResultSetMetadata>,
#[serde(rename = "Rows")]
#[serde(skip_serializing_if = "Option::is_none")]
pub rows: Option<Vec<Row>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ResultSetMetadata {
#[serde(rename = "ColumnInfo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub column_info: Option<Vec<ColumnInfo>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Row {
#[serde(rename = "Data")]
#[serde(skip_serializing_if = "Option::is_none")]
pub data: Option<Vec<Datum>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StartQueryExecutionInput {
#[serde(rename = "ClientRequestToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_request_token: Option<String>,
#[serde(rename = "QueryExecutionContext")]
#[serde(skip_serializing_if = "Option::is_none")]
pub query_execution_context: Option<QueryExecutionContext>,
#[serde(rename = "QueryString")]
pub query_string: String,
#[serde(rename = "ResultConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub result_configuration: Option<ResultConfiguration>,
#[serde(rename = "WorkGroup")]
#[serde(skip_serializing_if = "Option::is_none")]
pub work_group: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct StartQueryExecutionOutput {
#[serde(rename = "QueryExecutionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub query_execution_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StopQueryExecutionInput {
#[serde(rename = "QueryExecutionId")]
pub query_execution_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct StopQueryExecutionOutput {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct TableMetadata {
#[serde(rename = "Columns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub columns: Option<Vec<Column>>,
#[serde(rename = "CreateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub create_time: Option<f64>,
#[serde(rename = "LastAccessTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_access_time: Option<f64>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Parameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub parameters: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "PartitionKeys")]
#[serde(skip_serializing_if = "Option::is_none")]
pub partition_keys: Option<Vec<Column>>,
#[serde(rename = "TableType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub table_type: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct Tag {
#[serde(rename = "Key")]
#[serde(skip_serializing_if = "Option::is_none")]
pub key: Option<String>,
#[serde(rename = "Value")]
#[serde(skip_serializing_if = "Option::is_none")]
pub value: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct TagResourceInput {
#[serde(rename = "ResourceARN")]
pub resource_arn: String,
#[serde(rename = "Tags")]
pub tags: Vec<Tag>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct TagResourceOutput {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UnprocessedNamedQueryId {
#[serde(rename = "ErrorCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_code: Option<String>,
#[serde(rename = "ErrorMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_message: Option<String>,
#[serde(rename = "NamedQueryId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub named_query_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UnprocessedQueryExecutionId {
#[serde(rename = "ErrorCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_code: Option<String>,
#[serde(rename = "ErrorMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_message: Option<String>,
#[serde(rename = "QueryExecutionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub query_execution_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UntagResourceInput {
#[serde(rename = "ResourceARN")]
pub resource_arn: String,
#[serde(rename = "TagKeys")]
pub tag_keys: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UntagResourceOutput {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateDataCatalogInput {
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Parameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub parameters: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "Type")]
pub type_: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateDataCatalogOutput {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateWorkGroupInput {
#[serde(rename = "ConfigurationUpdates")]
#[serde(skip_serializing_if = "Option::is_none")]
pub configuration_updates: Option<WorkGroupConfigurationUpdates>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "State")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<String>,
#[serde(rename = "WorkGroup")]
pub work_group: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateWorkGroupOutput {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct WorkGroup {
#[serde(rename = "Configuration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub configuration: Option<WorkGroupConfiguration>,
#[serde(rename = "CreationTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_time: Option<f64>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "State")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct WorkGroupConfiguration {
#[serde(rename = "BytesScannedCutoffPerQuery")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bytes_scanned_cutoff_per_query: Option<i64>,
#[serde(rename = "EnforceWorkGroupConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enforce_work_group_configuration: Option<bool>,
#[serde(rename = "PublishCloudWatchMetricsEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub publish_cloud_watch_metrics_enabled: Option<bool>,
#[serde(rename = "RequesterPaysEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub requester_pays_enabled: Option<bool>,
#[serde(rename = "ResultConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub result_configuration: Option<ResultConfiguration>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct WorkGroupConfigurationUpdates {
#[serde(rename = "BytesScannedCutoffPerQuery")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bytes_scanned_cutoff_per_query: Option<i64>,
#[serde(rename = "EnforceWorkGroupConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enforce_work_group_configuration: Option<bool>,
#[serde(rename = "PublishCloudWatchMetricsEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub publish_cloud_watch_metrics_enabled: Option<bool>,
#[serde(rename = "RemoveBytesScannedCutoffPerQuery")]
#[serde(skip_serializing_if = "Option::is_none")]
pub remove_bytes_scanned_cutoff_per_query: Option<bool>,
#[serde(rename = "RequesterPaysEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub requester_pays_enabled: Option<bool>,
#[serde(rename = "ResultConfigurationUpdates")]
#[serde(skip_serializing_if = "Option::is_none")]
pub result_configuration_updates: Option<ResultConfigurationUpdates>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct WorkGroupSummary {
#[serde(rename = "CreationTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_time: Option<f64>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "State")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<String>,
}
#[derive(Debug, PartialEq)]
pub enum BatchGetNamedQueryError {
InternalServer(String),
InvalidRequest(String),
}
impl BatchGetNamedQueryError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<BatchGetNamedQueryError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(BatchGetNamedQueryError::InternalServer(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(BatchGetNamedQueryError::InvalidRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for BatchGetNamedQueryError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
BatchGetNamedQueryError::InternalServer(ref cause) => write!(f, "{}", cause),
BatchGetNamedQueryError::InvalidRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for BatchGetNamedQueryError {}
#[derive(Debug, PartialEq)]
pub enum BatchGetQueryExecutionError {
InternalServer(String),
InvalidRequest(String),
}
impl BatchGetQueryExecutionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<BatchGetQueryExecutionError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(BatchGetQueryExecutionError::InternalServer(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(BatchGetQueryExecutionError::InvalidRequest(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for BatchGetQueryExecutionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
BatchGetQueryExecutionError::InternalServer(ref cause) => write!(f, "{}", cause),
BatchGetQueryExecutionError::InvalidRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for BatchGetQueryExecutionError {}
#[derive(Debug, PartialEq)]
pub enum CreateDataCatalogError {
InternalServer(String),
InvalidRequest(String),
}
impl CreateDataCatalogError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateDataCatalogError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(CreateDataCatalogError::InternalServer(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(CreateDataCatalogError::InvalidRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateDataCatalogError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateDataCatalogError::InternalServer(ref cause) => write!(f, "{}", cause),
CreateDataCatalogError::InvalidRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateDataCatalogError {}
#[derive(Debug, PartialEq)]
pub enum CreateNamedQueryError {
InternalServer(String),
InvalidRequest(String),
}
impl CreateNamedQueryError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateNamedQueryError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(CreateNamedQueryError::InternalServer(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(CreateNamedQueryError::InvalidRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateNamedQueryError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateNamedQueryError::InternalServer(ref cause) => write!(f, "{}", cause),
CreateNamedQueryError::InvalidRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateNamedQueryError {}
#[derive(Debug, PartialEq)]
pub enum CreateWorkGroupError {
InternalServer(String),
InvalidRequest(String),
}
impl CreateWorkGroupError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateWorkGroupError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(CreateWorkGroupError::InternalServer(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(CreateWorkGroupError::InvalidRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateWorkGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateWorkGroupError::InternalServer(ref cause) => write!(f, "{}", cause),
CreateWorkGroupError::InvalidRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateWorkGroupError {}
#[derive(Debug, PartialEq)]
pub enum DeleteDataCatalogError {
InternalServer(String),
InvalidRequest(String),
}
impl DeleteDataCatalogError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteDataCatalogError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(DeleteDataCatalogError::InternalServer(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(DeleteDataCatalogError::InvalidRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteDataCatalogError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteDataCatalogError::InternalServer(ref cause) => write!(f, "{}", cause),
DeleteDataCatalogError::InvalidRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteDataCatalogError {}
#[derive(Debug, PartialEq)]
pub enum DeleteNamedQueryError {
InternalServer(String),
InvalidRequest(String),
}
impl DeleteNamedQueryError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteNamedQueryError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(DeleteNamedQueryError::InternalServer(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(DeleteNamedQueryError::InvalidRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteNamedQueryError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteNamedQueryError::InternalServer(ref cause) => write!(f, "{}", cause),
DeleteNamedQueryError::InvalidRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteNamedQueryError {}
#[derive(Debug, PartialEq)]
pub enum DeleteWorkGroupError {
InternalServer(String),
InvalidRequest(String),
}
impl DeleteWorkGroupError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteWorkGroupError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(DeleteWorkGroupError::InternalServer(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(DeleteWorkGroupError::InvalidRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteWorkGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteWorkGroupError::InternalServer(ref cause) => write!(f, "{}", cause),
DeleteWorkGroupError::InvalidRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteWorkGroupError {}
#[derive(Debug, PartialEq)]
pub enum GetDataCatalogError {
InternalServer(String),
InvalidRequest(String),
}
impl GetDataCatalogError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetDataCatalogError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(GetDataCatalogError::InternalServer(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(GetDataCatalogError::InvalidRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetDataCatalogError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetDataCatalogError::InternalServer(ref cause) => write!(f, "{}", cause),
GetDataCatalogError::InvalidRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetDataCatalogError {}
#[derive(Debug, PartialEq)]
pub enum GetDatabaseError {
InternalServer(String),
InvalidRequest(String),
Metadata(String),
}
impl GetDatabaseError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetDatabaseError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(GetDatabaseError::InternalServer(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(GetDatabaseError::InvalidRequest(err.msg))
}
"MetadataException" => {
return RusotoError::Service(GetDatabaseError::Metadata(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetDatabaseError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetDatabaseError::InternalServer(ref cause) => write!(f, "{}", cause),
GetDatabaseError::InvalidRequest(ref cause) => write!(f, "{}", cause),
GetDatabaseError::Metadata(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetDatabaseError {}
#[derive(Debug, PartialEq)]
pub enum GetNamedQueryError {
InternalServer(String),
InvalidRequest(String),
}
impl GetNamedQueryError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetNamedQueryError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(GetNamedQueryError::InternalServer(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(GetNamedQueryError::InvalidRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetNamedQueryError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetNamedQueryError::InternalServer(ref cause) => write!(f, "{}", cause),
GetNamedQueryError::InvalidRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetNamedQueryError {}
#[derive(Debug, PartialEq)]
pub enum GetQueryExecutionError {
InternalServer(String),
InvalidRequest(String),
}
impl GetQueryExecutionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetQueryExecutionError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(GetQueryExecutionError::InternalServer(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(GetQueryExecutionError::InvalidRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetQueryExecutionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetQueryExecutionError::InternalServer(ref cause) => write!(f, "{}", cause),
GetQueryExecutionError::InvalidRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetQueryExecutionError {}
#[derive(Debug, PartialEq)]
pub enum GetQueryResultsError {
InternalServer(String),
InvalidRequest(String),
}
impl GetQueryResultsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetQueryResultsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(GetQueryResultsError::InternalServer(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(GetQueryResultsError::InvalidRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetQueryResultsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetQueryResultsError::InternalServer(ref cause) => write!(f, "{}", cause),
GetQueryResultsError::InvalidRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetQueryResultsError {}
#[derive(Debug, PartialEq)]
pub enum GetTableMetadataError {
InternalServer(String),
InvalidRequest(String),
Metadata(String),
}
impl GetTableMetadataError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetTableMetadataError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(GetTableMetadataError::InternalServer(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(GetTableMetadataError::InvalidRequest(err.msg))
}
"MetadataException" => {
return RusotoError::Service(GetTableMetadataError::Metadata(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetTableMetadataError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetTableMetadataError::InternalServer(ref cause) => write!(f, "{}", cause),
GetTableMetadataError::InvalidRequest(ref cause) => write!(f, "{}", cause),
GetTableMetadataError::Metadata(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetTableMetadataError {}
#[derive(Debug, PartialEq)]
pub enum GetWorkGroupError {
InternalServer(String),
InvalidRequest(String),
}
impl GetWorkGroupError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetWorkGroupError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(GetWorkGroupError::InternalServer(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(GetWorkGroupError::InvalidRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetWorkGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetWorkGroupError::InternalServer(ref cause) => write!(f, "{}", cause),
GetWorkGroupError::InvalidRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetWorkGroupError {}
#[derive(Debug, PartialEq)]
pub enum ListDataCatalogsError {
InternalServer(String),
InvalidRequest(String),
}
impl ListDataCatalogsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListDataCatalogsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(ListDataCatalogsError::InternalServer(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(ListDataCatalogsError::InvalidRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListDataCatalogsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListDataCatalogsError::InternalServer(ref cause) => write!(f, "{}", cause),
ListDataCatalogsError::InvalidRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListDataCatalogsError {}
#[derive(Debug, PartialEq)]
pub enum ListDatabasesError {
InternalServer(String),
InvalidRequest(String),
Metadata(String),
}
impl ListDatabasesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListDatabasesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(ListDatabasesError::InternalServer(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(ListDatabasesError::InvalidRequest(err.msg))
}
"MetadataException" => {
return RusotoError::Service(ListDatabasesError::Metadata(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListDatabasesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListDatabasesError::InternalServer(ref cause) => write!(f, "{}", cause),
ListDatabasesError::InvalidRequest(ref cause) => write!(f, "{}", cause),
ListDatabasesError::Metadata(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListDatabasesError {}
#[derive(Debug, PartialEq)]
pub enum ListNamedQueriesError {
InternalServer(String),
InvalidRequest(String),
}
impl ListNamedQueriesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListNamedQueriesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(ListNamedQueriesError::InternalServer(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(ListNamedQueriesError::InvalidRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListNamedQueriesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListNamedQueriesError::InternalServer(ref cause) => write!(f, "{}", cause),
ListNamedQueriesError::InvalidRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListNamedQueriesError {}
#[derive(Debug, PartialEq)]
pub enum ListQueryExecutionsError {
InternalServer(String),
InvalidRequest(String),
}
impl ListQueryExecutionsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListQueryExecutionsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(ListQueryExecutionsError::InternalServer(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(ListQueryExecutionsError::InvalidRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListQueryExecutionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListQueryExecutionsError::InternalServer(ref cause) => write!(f, "{}", cause),
ListQueryExecutionsError::InvalidRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListQueryExecutionsError {}
#[derive(Debug, PartialEq)]
pub enum ListTableMetadataError {
InternalServer(String),
InvalidRequest(String),
Metadata(String),
}
impl ListTableMetadataError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListTableMetadataError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(ListTableMetadataError::InternalServer(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(ListTableMetadataError::InvalidRequest(err.msg))
}
"MetadataException" => {
return RusotoError::Service(ListTableMetadataError::Metadata(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListTableMetadataError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListTableMetadataError::InternalServer(ref cause) => write!(f, "{}", cause),
ListTableMetadataError::InvalidRequest(ref cause) => write!(f, "{}", cause),
ListTableMetadataError::Metadata(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListTableMetadataError {}
#[derive(Debug, PartialEq)]
pub enum ListTagsForResourceError {
InternalServer(String),
InvalidRequest(String),
ResourceNotFound(String),
}
impl ListTagsForResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListTagsForResourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(ListTagsForResourceError::InternalServer(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(ListTagsForResourceError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListTagsForResourceError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListTagsForResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListTagsForResourceError::InternalServer(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::InvalidRequest(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListTagsForResourceError {}
#[derive(Debug, PartialEq)]
pub enum ListWorkGroupsError {
InternalServer(String),
InvalidRequest(String),
}
impl ListWorkGroupsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListWorkGroupsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(ListWorkGroupsError::InternalServer(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(ListWorkGroupsError::InvalidRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListWorkGroupsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListWorkGroupsError::InternalServer(ref cause) => write!(f, "{}", cause),
ListWorkGroupsError::InvalidRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListWorkGroupsError {}
#[derive(Debug, PartialEq)]
pub enum StartQueryExecutionError {
InternalServer(String),
InvalidRequest(String),
TooManyRequests(String),
}
impl StartQueryExecutionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StartQueryExecutionError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(StartQueryExecutionError::InternalServer(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(StartQueryExecutionError::InvalidRequest(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(StartQueryExecutionError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for StartQueryExecutionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
StartQueryExecutionError::InternalServer(ref cause) => write!(f, "{}", cause),
StartQueryExecutionError::InvalidRequest(ref cause) => write!(f, "{}", cause),
StartQueryExecutionError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for StartQueryExecutionError {}
#[derive(Debug, PartialEq)]
pub enum StopQueryExecutionError {
InternalServer(String),
InvalidRequest(String),
}
impl StopQueryExecutionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StopQueryExecutionError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(StopQueryExecutionError::InternalServer(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(StopQueryExecutionError::InvalidRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for StopQueryExecutionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
StopQueryExecutionError::InternalServer(ref cause) => write!(f, "{}", cause),
StopQueryExecutionError::InvalidRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for StopQueryExecutionError {}
#[derive(Debug, PartialEq)]
pub enum TagResourceError {
InternalServer(String),
InvalidRequest(String),
ResourceNotFound(String),
}
impl TagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<TagResourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(TagResourceError::InternalServer(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(TagResourceError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(TagResourceError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for TagResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
TagResourceError::InternalServer(ref cause) => write!(f, "{}", cause),
TagResourceError::InvalidRequest(ref cause) => write!(f, "{}", cause),
TagResourceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for TagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UntagResourceError {
InternalServer(String),
InvalidRequest(String),
ResourceNotFound(String),
}
impl UntagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UntagResourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(UntagResourceError::InternalServer(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(UntagResourceError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UntagResourceError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UntagResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UntagResourceError::InternalServer(ref cause) => write!(f, "{}", cause),
UntagResourceError::InvalidRequest(ref cause) => write!(f, "{}", cause),
UntagResourceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UntagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UpdateDataCatalogError {
InternalServer(String),
InvalidRequest(String),
}
impl UpdateDataCatalogError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateDataCatalogError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(UpdateDataCatalogError::InternalServer(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(UpdateDataCatalogError::InvalidRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateDataCatalogError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateDataCatalogError::InternalServer(ref cause) => write!(f, "{}", cause),
UpdateDataCatalogError::InvalidRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateDataCatalogError {}
#[derive(Debug, PartialEq)]
pub enum UpdateWorkGroupError {
InternalServer(String),
InvalidRequest(String),
}
impl UpdateWorkGroupError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateWorkGroupError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(UpdateWorkGroupError::InternalServer(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(UpdateWorkGroupError::InvalidRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateWorkGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateWorkGroupError::InternalServer(ref cause) => write!(f, "{}", cause),
UpdateWorkGroupError::InvalidRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateWorkGroupError {}
#[async_trait]
pub trait Athena {
async fn batch_get_named_query(
&self,
input: BatchGetNamedQueryInput,
) -> Result<BatchGetNamedQueryOutput, RusotoError<BatchGetNamedQueryError>>;
async fn batch_get_query_execution(
&self,
input: BatchGetQueryExecutionInput,
) -> Result<BatchGetQueryExecutionOutput, RusotoError<BatchGetQueryExecutionError>>;
async fn create_data_catalog(
&self,
input: CreateDataCatalogInput,
) -> Result<CreateDataCatalogOutput, RusotoError<CreateDataCatalogError>>;
async fn create_named_query(
&self,
input: CreateNamedQueryInput,
) -> Result<CreateNamedQueryOutput, RusotoError<CreateNamedQueryError>>;
async fn create_work_group(
&self,
input: CreateWorkGroupInput,
) -> Result<CreateWorkGroupOutput, RusotoError<CreateWorkGroupError>>;
async fn delete_data_catalog(
&self,
input: DeleteDataCatalogInput,
) -> Result<DeleteDataCatalogOutput, RusotoError<DeleteDataCatalogError>>;
async fn delete_named_query(
&self,
input: DeleteNamedQueryInput,
) -> Result<DeleteNamedQueryOutput, RusotoError<DeleteNamedQueryError>>;
async fn delete_work_group(
&self,
input: DeleteWorkGroupInput,
) -> Result<DeleteWorkGroupOutput, RusotoError<DeleteWorkGroupError>>;
async fn get_data_catalog(
&self,
input: GetDataCatalogInput,
) -> Result<GetDataCatalogOutput, RusotoError<GetDataCatalogError>>;
async fn get_database(
&self,
input: GetDatabaseInput,
) -> Result<GetDatabaseOutput, RusotoError<GetDatabaseError>>;
async fn get_named_query(
&self,
input: GetNamedQueryInput,
) -> Result<GetNamedQueryOutput, RusotoError<GetNamedQueryError>>;
async fn get_query_execution(
&self,
input: GetQueryExecutionInput,
) -> Result<GetQueryExecutionOutput, RusotoError<GetQueryExecutionError>>;
async fn get_query_results(
&self,
input: GetQueryResultsInput,
) -> Result<GetQueryResultsOutput, RusotoError<GetQueryResultsError>>;
async fn get_table_metadata(
&self,
input: GetTableMetadataInput,
) -> Result<GetTableMetadataOutput, RusotoError<GetTableMetadataError>>;
async fn get_work_group(
&self,
input: GetWorkGroupInput,
) -> Result<GetWorkGroupOutput, RusotoError<GetWorkGroupError>>;
async fn list_data_catalogs(
&self,
input: ListDataCatalogsInput,
) -> Result<ListDataCatalogsOutput, RusotoError<ListDataCatalogsError>>;
async fn list_databases(
&self,
input: ListDatabasesInput,
) -> Result<ListDatabasesOutput, RusotoError<ListDatabasesError>>;
async fn list_named_queries(
&self,
input: ListNamedQueriesInput,
) -> Result<ListNamedQueriesOutput, RusotoError<ListNamedQueriesError>>;
async fn list_query_executions(
&self,
input: ListQueryExecutionsInput,
) -> Result<ListQueryExecutionsOutput, RusotoError<ListQueryExecutionsError>>;
async fn list_table_metadata(
&self,
input: ListTableMetadataInput,
) -> Result<ListTableMetadataOutput, RusotoError<ListTableMetadataError>>;
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceInput,
) -> Result<ListTagsForResourceOutput, RusotoError<ListTagsForResourceError>>;
async fn list_work_groups(
&self,
input: ListWorkGroupsInput,
) -> Result<ListWorkGroupsOutput, RusotoError<ListWorkGroupsError>>;
async fn start_query_execution(
&self,
input: StartQueryExecutionInput,
) -> Result<StartQueryExecutionOutput, RusotoError<StartQueryExecutionError>>;
async fn stop_query_execution(
&self,
input: StopQueryExecutionInput,
) -> Result<StopQueryExecutionOutput, RusotoError<StopQueryExecutionError>>;
async fn tag_resource(
&self,
input: TagResourceInput,
) -> Result<TagResourceOutput, RusotoError<TagResourceError>>;
async fn untag_resource(
&self,
input: UntagResourceInput,
) -> Result<UntagResourceOutput, RusotoError<UntagResourceError>>;
async fn update_data_catalog(
&self,
input: UpdateDataCatalogInput,
) -> Result<UpdateDataCatalogOutput, RusotoError<UpdateDataCatalogError>>;
async fn update_work_group(
&self,
input: UpdateWorkGroupInput,
) -> Result<UpdateWorkGroupOutput, RusotoError<UpdateWorkGroupError>>;
}
#[derive(Clone)]
pub struct AthenaClient {
client: Client,
region: region::Region,
}
impl AthenaClient {
pub fn new(region: region::Region) -> AthenaClient {
AthenaClient {
client: Client::shared(),
region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> AthenaClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
D: DispatchSignedRequest + Send + Sync + 'static,
{
AthenaClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region,
}
}
pub fn new_with_client(client: Client, region: region::Region) -> AthenaClient {
AthenaClient { client, region }
}
}
#[async_trait]
impl Athena for AthenaClient {
async fn batch_get_named_query(
&self,
input: BatchGetNamedQueryInput,
) -> Result<BatchGetNamedQueryOutput, RusotoError<BatchGetNamedQueryError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AmazonAthena.BatchGetNamedQuery");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, BatchGetNamedQueryError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<BatchGetNamedQueryOutput, _>()
}
async fn batch_get_query_execution(
&self,
input: BatchGetQueryExecutionInput,
) -> Result<BatchGetQueryExecutionOutput, RusotoError<BatchGetQueryExecutionError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AmazonAthena.BatchGetQueryExecution");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, BatchGetQueryExecutionError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<BatchGetQueryExecutionOutput, _>()
}
async fn create_data_catalog(
&self,
input: CreateDataCatalogInput,
) -> Result<CreateDataCatalogOutput, RusotoError<CreateDataCatalogError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AmazonAthena.CreateDataCatalog");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateDataCatalogError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateDataCatalogOutput, _>()
}
async fn create_named_query(
&self,
input: CreateNamedQueryInput,
) -> Result<CreateNamedQueryOutput, RusotoError<CreateNamedQueryError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AmazonAthena.CreateNamedQuery");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateNamedQueryError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateNamedQueryOutput, _>()
}
async fn create_work_group(
&self,
input: CreateWorkGroupInput,
) -> Result<CreateWorkGroupOutput, RusotoError<CreateWorkGroupError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AmazonAthena.CreateWorkGroup");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateWorkGroupError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateWorkGroupOutput, _>()
}
async fn delete_data_catalog(
&self,
input: DeleteDataCatalogInput,
) -> Result<DeleteDataCatalogOutput, RusotoError<DeleteDataCatalogError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AmazonAthena.DeleteDataCatalog");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteDataCatalogError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DeleteDataCatalogOutput, _>()
}
async fn delete_named_query(
&self,
input: DeleteNamedQueryInput,
) -> Result<DeleteNamedQueryOutput, RusotoError<DeleteNamedQueryError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AmazonAthena.DeleteNamedQuery");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteNamedQueryError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DeleteNamedQueryOutput, _>()
}
async fn delete_work_group(
&self,
input: DeleteWorkGroupInput,
) -> Result<DeleteWorkGroupOutput, RusotoError<DeleteWorkGroupError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AmazonAthena.DeleteWorkGroup");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteWorkGroupError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DeleteWorkGroupOutput, _>()
}
async fn get_data_catalog(
&self,
input: GetDataCatalogInput,
) -> Result<GetDataCatalogOutput, RusotoError<GetDataCatalogError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AmazonAthena.GetDataCatalog");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetDataCatalogError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetDataCatalogOutput, _>()
}
async fn get_database(
&self,
input: GetDatabaseInput,
) -> Result<GetDatabaseOutput, RusotoError<GetDatabaseError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AmazonAthena.GetDatabase");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetDatabaseError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetDatabaseOutput, _>()
}
async fn get_named_query(
&self,
input: GetNamedQueryInput,
) -> Result<GetNamedQueryOutput, RusotoError<GetNamedQueryError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AmazonAthena.GetNamedQuery");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetNamedQueryError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetNamedQueryOutput, _>()
}
async fn get_query_execution(
&self,
input: GetQueryExecutionInput,
) -> Result<GetQueryExecutionOutput, RusotoError<GetQueryExecutionError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AmazonAthena.GetQueryExecution");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetQueryExecutionError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetQueryExecutionOutput, _>()
}
async fn get_query_results(
&self,
input: GetQueryResultsInput,
) -> Result<GetQueryResultsOutput, RusotoError<GetQueryResultsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AmazonAthena.GetQueryResults");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetQueryResultsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetQueryResultsOutput, _>()
}
async fn get_table_metadata(
&self,
input: GetTableMetadataInput,
) -> Result<GetTableMetadataOutput, RusotoError<GetTableMetadataError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AmazonAthena.GetTableMetadata");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetTableMetadataError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetTableMetadataOutput, _>()
}
async fn get_work_group(
&self,
input: GetWorkGroupInput,
) -> Result<GetWorkGroupOutput, RusotoError<GetWorkGroupError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AmazonAthena.GetWorkGroup");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetWorkGroupError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetWorkGroupOutput, _>()
}
async fn list_data_catalogs(
&self,
input: ListDataCatalogsInput,
) -> Result<ListDataCatalogsOutput, RusotoError<ListDataCatalogsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AmazonAthena.ListDataCatalogs");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListDataCatalogsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListDataCatalogsOutput, _>()
}
async fn list_databases(
&self,
input: ListDatabasesInput,
) -> Result<ListDatabasesOutput, RusotoError<ListDatabasesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AmazonAthena.ListDatabases");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListDatabasesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListDatabasesOutput, _>()
}
async fn list_named_queries(
&self,
input: ListNamedQueriesInput,
) -> Result<ListNamedQueriesOutput, RusotoError<ListNamedQueriesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AmazonAthena.ListNamedQueries");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListNamedQueriesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListNamedQueriesOutput, _>()
}
async fn list_query_executions(
&self,
input: ListQueryExecutionsInput,
) -> Result<ListQueryExecutionsOutput, RusotoError<ListQueryExecutionsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AmazonAthena.ListQueryExecutions");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListQueryExecutionsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListQueryExecutionsOutput, _>()
}
async fn list_table_metadata(
&self,
input: ListTableMetadataInput,
) -> Result<ListTableMetadataOutput, RusotoError<ListTableMetadataError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AmazonAthena.ListTableMetadata");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListTableMetadataError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListTableMetadataOutput, _>()
}
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceInput,
) -> Result<ListTagsForResourceOutput, RusotoError<ListTagsForResourceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AmazonAthena.ListTagsForResource");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListTagsForResourceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListTagsForResourceOutput, _>()
}
async fn list_work_groups(
&self,
input: ListWorkGroupsInput,
) -> Result<ListWorkGroupsOutput, RusotoError<ListWorkGroupsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AmazonAthena.ListWorkGroups");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListWorkGroupsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListWorkGroupsOutput, _>()
}
async fn start_query_execution(
&self,
input: StartQueryExecutionInput,
) -> Result<StartQueryExecutionOutput, RusotoError<StartQueryExecutionError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AmazonAthena.StartQueryExecution");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, StartQueryExecutionError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<StartQueryExecutionOutput, _>()
}
async fn stop_query_execution(
&self,
input: StopQueryExecutionInput,
) -> Result<StopQueryExecutionOutput, RusotoError<StopQueryExecutionError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AmazonAthena.StopQueryExecution");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, StopQueryExecutionError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<StopQueryExecutionOutput, _>()
}
async fn tag_resource(
&self,
input: TagResourceInput,
) -> Result<TagResourceOutput, RusotoError<TagResourceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AmazonAthena.TagResource");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, TagResourceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<TagResourceOutput, _>()
}
async fn untag_resource(
&self,
input: UntagResourceInput,
) -> Result<UntagResourceOutput, RusotoError<UntagResourceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AmazonAthena.UntagResource");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UntagResourceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<UntagResourceOutput, _>()
}
async fn update_data_catalog(
&self,
input: UpdateDataCatalogInput,
) -> Result<UpdateDataCatalogOutput, RusotoError<UpdateDataCatalogError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AmazonAthena.UpdateDataCatalog");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdateDataCatalogError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<UpdateDataCatalogOutput, _>()
}
async fn update_work_group(
&self,
input: UpdateWorkGroupInput,
) -> Result<UpdateWorkGroupOutput, RusotoError<UpdateWorkGroupError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AmazonAthena.UpdateWorkGroup");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdateWorkGroupError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<UpdateWorkGroupOutput, _>()
}
}