// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
use std::fmt::Write;
/// See [`BatchCreatePartitionInput`](crate::input::BatchCreatePartitionInput).
pub mod batch_create_partition_input {
/// A builder for [`BatchCreatePartitionInput`](crate::input::BatchCreatePartitionInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) catalog_id: std::option::Option<std::string::String>,
pub(crate) database_name: std::option::Option<std::string::String>,
pub(crate) table_name: std::option::Option<std::string::String>,
pub(crate) partition_input_list:
std::option::Option<std::vec::Vec<crate::model::PartitionInput>>,
}
impl Builder {
/// <p>The ID of the catalog in which the partition is to be created. Currently, this should be the Amazon Web Services account ID.</p>
pub fn catalog_id(mut self, input: impl Into<std::string::String>) -> Self {
self.catalog_id = Some(input.into());
self
}
/// <p>The ID of the catalog in which the partition is to be created. Currently, this should be the Amazon Web Services account ID.</p>
pub fn set_catalog_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.catalog_id = input;
self
}
/// <p>The name of the metadata database in which the partition is to be created.</p>
pub fn database_name(mut self, input: impl Into<std::string::String>) -> Self {
self.database_name = Some(input.into());
self
}
/// <p>The name of the metadata database in which the partition is to be created.</p>
pub fn set_database_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.database_name = input;
self
}
/// <p>The name of the metadata table in which the partition is to be created.</p>
pub fn table_name(mut self, input: impl Into<std::string::String>) -> Self {
self.table_name = Some(input.into());
self
}
/// <p>The name of the metadata table in which the partition is to be created.</p>
pub fn set_table_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.table_name = input;
self
}
/// Appends an item to `partition_input_list`.
///
/// To override the contents of this collection use [`set_partition_input_list`](Self::set_partition_input_list).
///
/// <p>A list of <code>PartitionInput</code> structures that define the partitions to be created.</p>
pub fn partition_input_list(mut self, input: crate::model::PartitionInput) -> Self {
let mut v = self.partition_input_list.unwrap_or_default();
v.push(input);
self.partition_input_list = Some(v);
self
}
/// <p>A list of <code>PartitionInput</code> structures that define the partitions to be created.</p>
pub fn set_partition_input_list(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::PartitionInput>>,
) -> Self {
self.partition_input_list = input;
self
}
/// Consumes the builder and constructs a [`BatchCreatePartitionInput`](crate::input::BatchCreatePartitionInput).
pub fn build(
self,
) -> Result<
crate::input::BatchCreatePartitionInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::BatchCreatePartitionInput {
catalog_id: self.catalog_id,
database_name: self.database_name,
table_name: self.table_name,
partition_input_list: self.partition_input_list,
})
}
}
}
impl BatchCreatePartitionInput {
/// Consumes the builder and constructs an Operation<[`BatchCreatePartition`](crate::operation::BatchCreatePartition)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::BatchCreatePartition,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::BatchCreatePartitionInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::BatchCreatePartitionInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.BatchCreatePartition",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_batch_create_partition(
&self,
)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::BatchCreatePartition::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"BatchCreatePartition",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`BatchCreatePartitionInput`](crate::input::BatchCreatePartitionInput).
pub fn builder() -> crate::input::batch_create_partition_input::Builder {
crate::input::batch_create_partition_input::Builder::default()
}
}
/// See [`BatchDeleteConnectionInput`](crate::input::BatchDeleteConnectionInput).
pub mod batch_delete_connection_input {
/// A builder for [`BatchDeleteConnectionInput`](crate::input::BatchDeleteConnectionInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) catalog_id: std::option::Option<std::string::String>,
pub(crate) connection_name_list: std::option::Option<std::vec::Vec<std::string::String>>,
}
impl Builder {
/// <p>The ID of the Data Catalog in which the connections reside. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(mut self, input: impl Into<std::string::String>) -> Self {
self.catalog_id = Some(input.into());
self
}
/// <p>The ID of the Data Catalog in which the connections reside. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn set_catalog_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.catalog_id = input;
self
}
/// Appends an item to `connection_name_list`.
///
/// To override the contents of this collection use [`set_connection_name_list`](Self::set_connection_name_list).
///
/// <p>A list of names of the connections to delete.</p>
pub fn connection_name_list(mut self, input: impl Into<std::string::String>) -> Self {
let mut v = self.connection_name_list.unwrap_or_default();
v.push(input.into());
self.connection_name_list = Some(v);
self
}
/// <p>A list of names of the connections to delete.</p>
pub fn set_connection_name_list(
mut self,
input: std::option::Option<std::vec::Vec<std::string::String>>,
) -> Self {
self.connection_name_list = input;
self
}
/// Consumes the builder and constructs a [`BatchDeleteConnectionInput`](crate::input::BatchDeleteConnectionInput).
pub fn build(
self,
) -> Result<
crate::input::BatchDeleteConnectionInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::BatchDeleteConnectionInput {
catalog_id: self.catalog_id,
connection_name_list: self.connection_name_list,
})
}
}
}
impl BatchDeleteConnectionInput {
/// Consumes the builder and constructs an Operation<[`BatchDeleteConnection`](crate::operation::BatchDeleteConnection)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::BatchDeleteConnection,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::BatchDeleteConnectionInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::BatchDeleteConnectionInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.BatchDeleteConnection",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_batch_delete_connection(
&self,
)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::BatchDeleteConnection::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"BatchDeleteConnection",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`BatchDeleteConnectionInput`](crate::input::BatchDeleteConnectionInput).
pub fn builder() -> crate::input::batch_delete_connection_input::Builder {
crate::input::batch_delete_connection_input::Builder::default()
}
}
/// See [`BatchDeletePartitionInput`](crate::input::BatchDeletePartitionInput).
pub mod batch_delete_partition_input {
/// A builder for [`BatchDeletePartitionInput`](crate::input::BatchDeletePartitionInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) catalog_id: std::option::Option<std::string::String>,
pub(crate) database_name: std::option::Option<std::string::String>,
pub(crate) table_name: std::option::Option<std::string::String>,
pub(crate) partitions_to_delete:
std::option::Option<std::vec::Vec<crate::model::PartitionValueList>>,
}
impl Builder {
/// <p>The ID of the Data Catalog where the partition to be deleted resides. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(mut self, input: impl Into<std::string::String>) -> Self {
self.catalog_id = Some(input.into());
self
}
/// <p>The ID of the Data Catalog where the partition to be deleted resides. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn set_catalog_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.catalog_id = input;
self
}
/// <p>The name of the catalog database in which the table in question resides.</p>
pub fn database_name(mut self, input: impl Into<std::string::String>) -> Self {
self.database_name = Some(input.into());
self
}
/// <p>The name of the catalog database in which the table in question resides.</p>
pub fn set_database_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.database_name = input;
self
}
/// <p>The name of the table that contains the partitions to be deleted.</p>
pub fn table_name(mut self, input: impl Into<std::string::String>) -> Self {
self.table_name = Some(input.into());
self
}
/// <p>The name of the table that contains the partitions to be deleted.</p>
pub fn set_table_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.table_name = input;
self
}
/// Appends an item to `partitions_to_delete`.
///
/// To override the contents of this collection use [`set_partitions_to_delete`](Self::set_partitions_to_delete).
///
/// <p>A list of <code>PartitionInput</code> structures that define the partitions to be deleted.</p>
pub fn partitions_to_delete(mut self, input: crate::model::PartitionValueList) -> Self {
let mut v = self.partitions_to_delete.unwrap_or_default();
v.push(input);
self.partitions_to_delete = Some(v);
self
}
/// <p>A list of <code>PartitionInput</code> structures that define the partitions to be deleted.</p>
pub fn set_partitions_to_delete(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::PartitionValueList>>,
) -> Self {
self.partitions_to_delete = input;
self
}
/// Consumes the builder and constructs a [`BatchDeletePartitionInput`](crate::input::BatchDeletePartitionInput).
pub fn build(
self,
) -> Result<
crate::input::BatchDeletePartitionInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::BatchDeletePartitionInput {
catalog_id: self.catalog_id,
database_name: self.database_name,
table_name: self.table_name,
partitions_to_delete: self.partitions_to_delete,
})
}
}
}
impl BatchDeletePartitionInput {
/// Consumes the builder and constructs an Operation<[`BatchDeletePartition`](crate::operation::BatchDeletePartition)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::BatchDeletePartition,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::BatchDeletePartitionInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::BatchDeletePartitionInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.BatchDeletePartition",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_batch_delete_partition(
&self,
)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::BatchDeletePartition::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"BatchDeletePartition",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`BatchDeletePartitionInput`](crate::input::BatchDeletePartitionInput).
pub fn builder() -> crate::input::batch_delete_partition_input::Builder {
crate::input::batch_delete_partition_input::Builder::default()
}
}
/// See [`BatchDeleteTableInput`](crate::input::BatchDeleteTableInput).
pub mod batch_delete_table_input {
/// A builder for [`BatchDeleteTableInput`](crate::input::BatchDeleteTableInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) catalog_id: std::option::Option<std::string::String>,
pub(crate) database_name: std::option::Option<std::string::String>,
pub(crate) tables_to_delete: std::option::Option<std::vec::Vec<std::string::String>>,
pub(crate) transaction_id: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The ID of the Data Catalog where the table resides. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(mut self, input: impl Into<std::string::String>) -> Self {
self.catalog_id = Some(input.into());
self
}
/// <p>The ID of the Data Catalog where the table resides. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn set_catalog_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.catalog_id = input;
self
}
/// <p>The name of the catalog database in which the tables to delete reside. For Hive compatibility, this name is entirely lowercase.</p>
pub fn database_name(mut self, input: impl Into<std::string::String>) -> Self {
self.database_name = Some(input.into());
self
}
/// <p>The name of the catalog database in which the tables to delete reside. For Hive compatibility, this name is entirely lowercase.</p>
pub fn set_database_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.database_name = input;
self
}
/// Appends an item to `tables_to_delete`.
///
/// To override the contents of this collection use [`set_tables_to_delete`](Self::set_tables_to_delete).
///
/// <p>A list of the table to delete.</p>
pub fn tables_to_delete(mut self, input: impl Into<std::string::String>) -> Self {
let mut v = self.tables_to_delete.unwrap_or_default();
v.push(input.into());
self.tables_to_delete = Some(v);
self
}
/// <p>A list of the table to delete.</p>
pub fn set_tables_to_delete(
mut self,
input: std::option::Option<std::vec::Vec<std::string::String>>,
) -> Self {
self.tables_to_delete = input;
self
}
/// <p>The transaction ID at which to delete the table contents.</p>
pub fn transaction_id(mut self, input: impl Into<std::string::String>) -> Self {
self.transaction_id = Some(input.into());
self
}
/// <p>The transaction ID at which to delete the table contents.</p>
pub fn set_transaction_id(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.transaction_id = input;
self
}
/// Consumes the builder and constructs a [`BatchDeleteTableInput`](crate::input::BatchDeleteTableInput).
pub fn build(
self,
) -> Result<
crate::input::BatchDeleteTableInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::BatchDeleteTableInput {
catalog_id: self.catalog_id,
database_name: self.database_name,
tables_to_delete: self.tables_to_delete,
transaction_id: self.transaction_id,
})
}
}
}
impl BatchDeleteTableInput {
/// Consumes the builder and constructs an Operation<[`BatchDeleteTable`](crate::operation::BatchDeleteTable)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::BatchDeleteTable,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::BatchDeleteTableInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::BatchDeleteTableInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.BatchDeleteTable",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_batch_delete_table(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::BatchDeleteTable::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"BatchDeleteTable",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`BatchDeleteTableInput`](crate::input::BatchDeleteTableInput).
pub fn builder() -> crate::input::batch_delete_table_input::Builder {
crate::input::batch_delete_table_input::Builder::default()
}
}
/// See [`BatchDeleteTableVersionInput`](crate::input::BatchDeleteTableVersionInput).
pub mod batch_delete_table_version_input {
/// A builder for [`BatchDeleteTableVersionInput`](crate::input::BatchDeleteTableVersionInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) catalog_id: std::option::Option<std::string::String>,
pub(crate) database_name: std::option::Option<std::string::String>,
pub(crate) table_name: std::option::Option<std::string::String>,
pub(crate) version_ids: std::option::Option<std::vec::Vec<std::string::String>>,
}
impl Builder {
/// <p>The ID of the Data Catalog where the tables reside. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(mut self, input: impl Into<std::string::String>) -> Self {
self.catalog_id = Some(input.into());
self
}
/// <p>The ID of the Data Catalog where the tables reside. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn set_catalog_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.catalog_id = input;
self
}
/// <p>The database in the catalog in which the table resides. For Hive compatibility, this name is entirely lowercase.</p>
pub fn database_name(mut self, input: impl Into<std::string::String>) -> Self {
self.database_name = Some(input.into());
self
}
/// <p>The database in the catalog in which the table resides. For Hive compatibility, this name is entirely lowercase.</p>
pub fn set_database_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.database_name = input;
self
}
/// <p>The name of the table. For Hive compatibility, this name is entirely lowercase.</p>
pub fn table_name(mut self, input: impl Into<std::string::String>) -> Self {
self.table_name = Some(input.into());
self
}
/// <p>The name of the table. For Hive compatibility, this name is entirely lowercase.</p>
pub fn set_table_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.table_name = input;
self
}
/// Appends an item to `version_ids`.
///
/// To override the contents of this collection use [`set_version_ids`](Self::set_version_ids).
///
/// <p>A list of the IDs of versions to be deleted. A <code>VersionId</code> is a string representation of an integer. Each version is incremented by 1.</p>
pub fn version_ids(mut self, input: impl Into<std::string::String>) -> Self {
let mut v = self.version_ids.unwrap_or_default();
v.push(input.into());
self.version_ids = Some(v);
self
}
/// <p>A list of the IDs of versions to be deleted. A <code>VersionId</code> is a string representation of an integer. Each version is incremented by 1.</p>
pub fn set_version_ids(
mut self,
input: std::option::Option<std::vec::Vec<std::string::String>>,
) -> Self {
self.version_ids = input;
self
}
/// Consumes the builder and constructs a [`BatchDeleteTableVersionInput`](crate::input::BatchDeleteTableVersionInput).
pub fn build(
self,
) -> Result<
crate::input::BatchDeleteTableVersionInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::BatchDeleteTableVersionInput {
catalog_id: self.catalog_id,
database_name: self.database_name,
table_name: self.table_name,
version_ids: self.version_ids,
})
}
}
}
impl BatchDeleteTableVersionInput {
/// Consumes the builder and constructs an Operation<[`BatchDeleteTableVersion`](crate::operation::BatchDeleteTableVersion)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::BatchDeleteTableVersion,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::BatchDeleteTableVersionInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::BatchDeleteTableVersionInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.BatchDeleteTableVersion",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_batch_delete_table_version(
&self,
)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::BatchDeleteTableVersion::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"BatchDeleteTableVersion",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`BatchDeleteTableVersionInput`](crate::input::BatchDeleteTableVersionInput).
pub fn builder() -> crate::input::batch_delete_table_version_input::Builder {
crate::input::batch_delete_table_version_input::Builder::default()
}
}
/// See [`BatchGetBlueprintsInput`](crate::input::BatchGetBlueprintsInput).
pub mod batch_get_blueprints_input {
/// A builder for [`BatchGetBlueprintsInput`](crate::input::BatchGetBlueprintsInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) names: std::option::Option<std::vec::Vec<std::string::String>>,
pub(crate) include_blueprint: std::option::Option<bool>,
pub(crate) include_parameter_spec: std::option::Option<bool>,
}
impl Builder {
/// Appends an item to `names`.
///
/// To override the contents of this collection use [`set_names`](Self::set_names).
///
/// <p>A list of blueprint names.</p>
pub fn names(mut self, input: impl Into<std::string::String>) -> Self {
let mut v = self.names.unwrap_or_default();
v.push(input.into());
self.names = Some(v);
self
}
/// <p>A list of blueprint names.</p>
pub fn set_names(
mut self,
input: std::option::Option<std::vec::Vec<std::string::String>>,
) -> Self {
self.names = input;
self
}
/// <p>Specifies whether or not to include the blueprint in the response.</p>
pub fn include_blueprint(mut self, input: bool) -> Self {
self.include_blueprint = Some(input);
self
}
/// <p>Specifies whether or not to include the blueprint in the response.</p>
pub fn set_include_blueprint(mut self, input: std::option::Option<bool>) -> Self {
self.include_blueprint = input;
self
}
/// <p>Specifies whether or not to include the parameters, as a JSON string, for the blueprint in the response.</p>
pub fn include_parameter_spec(mut self, input: bool) -> Self {
self.include_parameter_spec = Some(input);
self
}
/// <p>Specifies whether or not to include the parameters, as a JSON string, for the blueprint in the response.</p>
pub fn set_include_parameter_spec(mut self, input: std::option::Option<bool>) -> Self {
self.include_parameter_spec = input;
self
}
/// Consumes the builder and constructs a [`BatchGetBlueprintsInput`](crate::input::BatchGetBlueprintsInput).
pub fn build(
self,
) -> Result<
crate::input::BatchGetBlueprintsInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::BatchGetBlueprintsInput {
names: self.names,
include_blueprint: self.include_blueprint,
include_parameter_spec: self.include_parameter_spec,
})
}
}
}
impl BatchGetBlueprintsInput {
/// Consumes the builder and constructs an Operation<[`BatchGetBlueprints`](crate::operation::BatchGetBlueprints)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::BatchGetBlueprints,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::BatchGetBlueprintsInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::BatchGetBlueprintsInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.BatchGetBlueprints",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_batch_get_blueprints(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::BatchGetBlueprints::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"BatchGetBlueprints",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`BatchGetBlueprintsInput`](crate::input::BatchGetBlueprintsInput).
pub fn builder() -> crate::input::batch_get_blueprints_input::Builder {
crate::input::batch_get_blueprints_input::Builder::default()
}
}
/// See [`BatchGetCrawlersInput`](crate::input::BatchGetCrawlersInput).
pub mod batch_get_crawlers_input {
/// A builder for [`BatchGetCrawlersInput`](crate::input::BatchGetCrawlersInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) crawler_names: std::option::Option<std::vec::Vec<std::string::String>>,
}
impl Builder {
/// Appends an item to `crawler_names`.
///
/// To override the contents of this collection use [`set_crawler_names`](Self::set_crawler_names).
///
/// <p>A list of crawler names, which might be the names returned from the <code>ListCrawlers</code> operation.</p>
pub fn crawler_names(mut self, input: impl Into<std::string::String>) -> Self {
let mut v = self.crawler_names.unwrap_or_default();
v.push(input.into());
self.crawler_names = Some(v);
self
}
/// <p>A list of crawler names, which might be the names returned from the <code>ListCrawlers</code> operation.</p>
pub fn set_crawler_names(
mut self,
input: std::option::Option<std::vec::Vec<std::string::String>>,
) -> Self {
self.crawler_names = input;
self
}
/// Consumes the builder and constructs a [`BatchGetCrawlersInput`](crate::input::BatchGetCrawlersInput).
pub fn build(
self,
) -> Result<
crate::input::BatchGetCrawlersInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::BatchGetCrawlersInput {
crawler_names: self.crawler_names,
})
}
}
}
impl BatchGetCrawlersInput {
/// Consumes the builder and constructs an Operation<[`BatchGetCrawlers`](crate::operation::BatchGetCrawlers)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::BatchGetCrawlers,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::BatchGetCrawlersInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::BatchGetCrawlersInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.BatchGetCrawlers",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_batch_get_crawlers(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::BatchGetCrawlers::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"BatchGetCrawlers",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`BatchGetCrawlersInput`](crate::input::BatchGetCrawlersInput).
pub fn builder() -> crate::input::batch_get_crawlers_input::Builder {
crate::input::batch_get_crawlers_input::Builder::default()
}
}
/// See [`BatchGetCustomEntityTypesInput`](crate::input::BatchGetCustomEntityTypesInput).
pub mod batch_get_custom_entity_types_input {
/// A builder for [`BatchGetCustomEntityTypesInput`](crate::input::BatchGetCustomEntityTypesInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) names: std::option::Option<std::vec::Vec<std::string::String>>,
}
impl Builder {
/// Appends an item to `names`.
///
/// To override the contents of this collection use [`set_names`](Self::set_names).
///
/// <p>A list of names of the custom patterns that you want to retrieve.</p>
pub fn names(mut self, input: impl Into<std::string::String>) -> Self {
let mut v = self.names.unwrap_or_default();
v.push(input.into());
self.names = Some(v);
self
}
/// <p>A list of names of the custom patterns that you want to retrieve.</p>
pub fn set_names(
mut self,
input: std::option::Option<std::vec::Vec<std::string::String>>,
) -> Self {
self.names = input;
self
}
/// Consumes the builder and constructs a [`BatchGetCustomEntityTypesInput`](crate::input::BatchGetCustomEntityTypesInput).
pub fn build(
self,
) -> Result<
crate::input::BatchGetCustomEntityTypesInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::BatchGetCustomEntityTypesInput { names: self.names })
}
}
}
impl BatchGetCustomEntityTypesInput {
/// Consumes the builder and constructs an Operation<[`BatchGetCustomEntityTypes`](crate::operation::BatchGetCustomEntityTypes)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::BatchGetCustomEntityTypes,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::BatchGetCustomEntityTypesInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::BatchGetCustomEntityTypesInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.BatchGetCustomEntityTypes",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_batch_get_custom_entity_types(&self)?
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::BatchGetCustomEntityTypes::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"BatchGetCustomEntityTypes",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`BatchGetCustomEntityTypesInput`](crate::input::BatchGetCustomEntityTypesInput).
pub fn builder() -> crate::input::batch_get_custom_entity_types_input::Builder {
crate::input::batch_get_custom_entity_types_input::Builder::default()
}
}
/// See [`BatchGetDataQualityResultInput`](crate::input::BatchGetDataQualityResultInput).
pub mod batch_get_data_quality_result_input {
/// A builder for [`BatchGetDataQualityResultInput`](crate::input::BatchGetDataQualityResultInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) result_ids: std::option::Option<std::vec::Vec<std::string::String>>,
}
impl Builder {
/// Appends an item to `result_ids`.
///
/// To override the contents of this collection use [`set_result_ids`](Self::set_result_ids).
///
/// <p>A list of unique result IDs for the data quality results.</p>
pub fn result_ids(mut self, input: impl Into<std::string::String>) -> Self {
let mut v = self.result_ids.unwrap_or_default();
v.push(input.into());
self.result_ids = Some(v);
self
}
/// <p>A list of unique result IDs for the data quality results.</p>
pub fn set_result_ids(
mut self,
input: std::option::Option<std::vec::Vec<std::string::String>>,
) -> Self {
self.result_ids = input;
self
}
/// Consumes the builder and constructs a [`BatchGetDataQualityResultInput`](crate::input::BatchGetDataQualityResultInput).
pub fn build(
self,
) -> Result<
crate::input::BatchGetDataQualityResultInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::BatchGetDataQualityResultInput {
result_ids: self.result_ids,
})
}
}
}
impl BatchGetDataQualityResultInput {
/// Consumes the builder and constructs an Operation<[`BatchGetDataQualityResult`](crate::operation::BatchGetDataQualityResult)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::BatchGetDataQualityResult,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::BatchGetDataQualityResultInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::BatchGetDataQualityResultInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.BatchGetDataQualityResult",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_batch_get_data_quality_result(&self)?
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::BatchGetDataQualityResult::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"BatchGetDataQualityResult",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`BatchGetDataQualityResultInput`](crate::input::BatchGetDataQualityResultInput).
pub fn builder() -> crate::input::batch_get_data_quality_result_input::Builder {
crate::input::batch_get_data_quality_result_input::Builder::default()
}
}
/// See [`BatchGetDevEndpointsInput`](crate::input::BatchGetDevEndpointsInput).
pub mod batch_get_dev_endpoints_input {
/// A builder for [`BatchGetDevEndpointsInput`](crate::input::BatchGetDevEndpointsInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) dev_endpoint_names: std::option::Option<std::vec::Vec<std::string::String>>,
}
impl Builder {
/// Appends an item to `dev_endpoint_names`.
///
/// To override the contents of this collection use [`set_dev_endpoint_names`](Self::set_dev_endpoint_names).
///
/// <p>The list of <code>DevEndpoint</code> names, which might be the names returned from the <code>ListDevEndpoint</code> operation.</p>
pub fn dev_endpoint_names(mut self, input: impl Into<std::string::String>) -> Self {
let mut v = self.dev_endpoint_names.unwrap_or_default();
v.push(input.into());
self.dev_endpoint_names = Some(v);
self
}
/// <p>The list of <code>DevEndpoint</code> names, which might be the names returned from the <code>ListDevEndpoint</code> operation.</p>
pub fn set_dev_endpoint_names(
mut self,
input: std::option::Option<std::vec::Vec<std::string::String>>,
) -> Self {
self.dev_endpoint_names = input;
self
}
/// Consumes the builder and constructs a [`BatchGetDevEndpointsInput`](crate::input::BatchGetDevEndpointsInput).
pub fn build(
self,
) -> Result<
crate::input::BatchGetDevEndpointsInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::BatchGetDevEndpointsInput {
dev_endpoint_names: self.dev_endpoint_names,
})
}
}
}
impl BatchGetDevEndpointsInput {
/// Consumes the builder and constructs an Operation<[`BatchGetDevEndpoints`](crate::operation::BatchGetDevEndpoints)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::BatchGetDevEndpoints,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::BatchGetDevEndpointsInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::BatchGetDevEndpointsInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.BatchGetDevEndpoints",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_batch_get_dev_endpoints(
&self,
)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::BatchGetDevEndpoints::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"BatchGetDevEndpoints",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`BatchGetDevEndpointsInput`](crate::input::BatchGetDevEndpointsInput).
pub fn builder() -> crate::input::batch_get_dev_endpoints_input::Builder {
crate::input::batch_get_dev_endpoints_input::Builder::default()
}
}
/// See [`BatchGetJobsInput`](crate::input::BatchGetJobsInput).
pub mod batch_get_jobs_input {
/// A builder for [`BatchGetJobsInput`](crate::input::BatchGetJobsInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) job_names: std::option::Option<std::vec::Vec<std::string::String>>,
}
impl Builder {
/// Appends an item to `job_names`.
///
/// To override the contents of this collection use [`set_job_names`](Self::set_job_names).
///
/// <p>A list of job names, which might be the names returned from the <code>ListJobs</code> operation.</p>
pub fn job_names(mut self, input: impl Into<std::string::String>) -> Self {
let mut v = self.job_names.unwrap_or_default();
v.push(input.into());
self.job_names = Some(v);
self
}
/// <p>A list of job names, which might be the names returned from the <code>ListJobs</code> operation.</p>
pub fn set_job_names(
mut self,
input: std::option::Option<std::vec::Vec<std::string::String>>,
) -> Self {
self.job_names = input;
self
}
/// Consumes the builder and constructs a [`BatchGetJobsInput`](crate::input::BatchGetJobsInput).
pub fn build(
self,
) -> Result<crate::input::BatchGetJobsInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::BatchGetJobsInput {
job_names: self.job_names,
})
}
}
}
impl BatchGetJobsInput {
/// Consumes the builder and constructs an Operation<[`BatchGetJobs`](crate::operation::BatchGetJobs)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::BatchGetJobs,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::BatchGetJobsInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::BatchGetJobsInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.BatchGetJobs",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_batch_get_jobs(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::BatchGetJobs::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"BatchGetJobs",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`BatchGetJobsInput`](crate::input::BatchGetJobsInput).
pub fn builder() -> crate::input::batch_get_jobs_input::Builder {
crate::input::batch_get_jobs_input::Builder::default()
}
}
/// See [`BatchGetPartitionInput`](crate::input::BatchGetPartitionInput).
pub mod batch_get_partition_input {
/// A builder for [`BatchGetPartitionInput`](crate::input::BatchGetPartitionInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) catalog_id: std::option::Option<std::string::String>,
pub(crate) database_name: std::option::Option<std::string::String>,
pub(crate) table_name: std::option::Option<std::string::String>,
pub(crate) partitions_to_get:
std::option::Option<std::vec::Vec<crate::model::PartitionValueList>>,
}
impl Builder {
/// <p>The ID of the Data Catalog where the partitions in question reside. If none is supplied, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(mut self, input: impl Into<std::string::String>) -> Self {
self.catalog_id = Some(input.into());
self
}
/// <p>The ID of the Data Catalog where the partitions in question reside. If none is supplied, the Amazon Web Services account ID is used by default.</p>
pub fn set_catalog_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.catalog_id = input;
self
}
/// <p>The name of the catalog database where the partitions reside.</p>
pub fn database_name(mut self, input: impl Into<std::string::String>) -> Self {
self.database_name = Some(input.into());
self
}
/// <p>The name of the catalog database where the partitions reside.</p>
pub fn set_database_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.database_name = input;
self
}
/// <p>The name of the partitions' table.</p>
pub fn table_name(mut self, input: impl Into<std::string::String>) -> Self {
self.table_name = Some(input.into());
self
}
/// <p>The name of the partitions' table.</p>
pub fn set_table_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.table_name = input;
self
}
/// Appends an item to `partitions_to_get`.
///
/// To override the contents of this collection use [`set_partitions_to_get`](Self::set_partitions_to_get).
///
/// <p>A list of partition values identifying the partitions to retrieve.</p>
pub fn partitions_to_get(mut self, input: crate::model::PartitionValueList) -> Self {
let mut v = self.partitions_to_get.unwrap_or_default();
v.push(input);
self.partitions_to_get = Some(v);
self
}
/// <p>A list of partition values identifying the partitions to retrieve.</p>
pub fn set_partitions_to_get(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::PartitionValueList>>,
) -> Self {
self.partitions_to_get = input;
self
}
/// Consumes the builder and constructs a [`BatchGetPartitionInput`](crate::input::BatchGetPartitionInput).
pub fn build(
self,
) -> Result<
crate::input::BatchGetPartitionInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::BatchGetPartitionInput {
catalog_id: self.catalog_id,
database_name: self.database_name,
table_name: self.table_name,
partitions_to_get: self.partitions_to_get,
})
}
}
}
impl BatchGetPartitionInput {
/// Consumes the builder and constructs an Operation<[`BatchGetPartition`](crate::operation::BatchGetPartition)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::BatchGetPartition,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::BatchGetPartitionInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::BatchGetPartitionInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.BatchGetPartition",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_batch_get_partition(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::BatchGetPartition::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"BatchGetPartition",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`BatchGetPartitionInput`](crate::input::BatchGetPartitionInput).
pub fn builder() -> crate::input::batch_get_partition_input::Builder {
crate::input::batch_get_partition_input::Builder::default()
}
}
/// See [`BatchGetTriggersInput`](crate::input::BatchGetTriggersInput).
pub mod batch_get_triggers_input {
/// A builder for [`BatchGetTriggersInput`](crate::input::BatchGetTriggersInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) trigger_names: std::option::Option<std::vec::Vec<std::string::String>>,
}
impl Builder {
/// Appends an item to `trigger_names`.
///
/// To override the contents of this collection use [`set_trigger_names`](Self::set_trigger_names).
///
/// <p>A list of trigger names, which may be the names returned from the <code>ListTriggers</code> operation.</p>
pub fn trigger_names(mut self, input: impl Into<std::string::String>) -> Self {
let mut v = self.trigger_names.unwrap_or_default();
v.push(input.into());
self.trigger_names = Some(v);
self
}
/// <p>A list of trigger names, which may be the names returned from the <code>ListTriggers</code> operation.</p>
pub fn set_trigger_names(
mut self,
input: std::option::Option<std::vec::Vec<std::string::String>>,
) -> Self {
self.trigger_names = input;
self
}
/// Consumes the builder and constructs a [`BatchGetTriggersInput`](crate::input::BatchGetTriggersInput).
pub fn build(
self,
) -> Result<
crate::input::BatchGetTriggersInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::BatchGetTriggersInput {
trigger_names: self.trigger_names,
})
}
}
}
impl BatchGetTriggersInput {
/// Consumes the builder and constructs an Operation<[`BatchGetTriggers`](crate::operation::BatchGetTriggers)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::BatchGetTriggers,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::BatchGetTriggersInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::BatchGetTriggersInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.BatchGetTriggers",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_batch_get_triggers(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::BatchGetTriggers::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"BatchGetTriggers",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`BatchGetTriggersInput`](crate::input::BatchGetTriggersInput).
pub fn builder() -> crate::input::batch_get_triggers_input::Builder {
crate::input::batch_get_triggers_input::Builder::default()
}
}
/// See [`BatchGetWorkflowsInput`](crate::input::BatchGetWorkflowsInput).
pub mod batch_get_workflows_input {
/// A builder for [`BatchGetWorkflowsInput`](crate::input::BatchGetWorkflowsInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) names: std::option::Option<std::vec::Vec<std::string::String>>,
pub(crate) include_graph: std::option::Option<bool>,
}
impl Builder {
/// Appends an item to `names`.
///
/// To override the contents of this collection use [`set_names`](Self::set_names).
///
/// <p>A list of workflow names, which may be the names returned from the <code>ListWorkflows</code> operation.</p>
pub fn names(mut self, input: impl Into<std::string::String>) -> Self {
let mut v = self.names.unwrap_or_default();
v.push(input.into());
self.names = Some(v);
self
}
/// <p>A list of workflow names, which may be the names returned from the <code>ListWorkflows</code> operation.</p>
pub fn set_names(
mut self,
input: std::option::Option<std::vec::Vec<std::string::String>>,
) -> Self {
self.names = input;
self
}
/// <p>Specifies whether to include a graph when returning the workflow resource metadata.</p>
pub fn include_graph(mut self, input: bool) -> Self {
self.include_graph = Some(input);
self
}
/// <p>Specifies whether to include a graph when returning the workflow resource metadata.</p>
pub fn set_include_graph(mut self, input: std::option::Option<bool>) -> Self {
self.include_graph = input;
self
}
/// Consumes the builder and constructs a [`BatchGetWorkflowsInput`](crate::input::BatchGetWorkflowsInput).
pub fn build(
self,
) -> Result<
crate::input::BatchGetWorkflowsInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::BatchGetWorkflowsInput {
names: self.names,
include_graph: self.include_graph,
})
}
}
}
impl BatchGetWorkflowsInput {
/// Consumes the builder and constructs an Operation<[`BatchGetWorkflows`](crate::operation::BatchGetWorkflows)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::BatchGetWorkflows,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::BatchGetWorkflowsInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::BatchGetWorkflowsInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.BatchGetWorkflows",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_batch_get_workflows(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::BatchGetWorkflows::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"BatchGetWorkflows",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`BatchGetWorkflowsInput`](crate::input::BatchGetWorkflowsInput).
pub fn builder() -> crate::input::batch_get_workflows_input::Builder {
crate::input::batch_get_workflows_input::Builder::default()
}
}
/// See [`BatchStopJobRunInput`](crate::input::BatchStopJobRunInput).
pub mod batch_stop_job_run_input {
/// A builder for [`BatchStopJobRunInput`](crate::input::BatchStopJobRunInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) job_name: std::option::Option<std::string::String>,
pub(crate) job_run_ids: std::option::Option<std::vec::Vec<std::string::String>>,
}
impl Builder {
/// <p>The name of the job definition for which to stop job runs.</p>
pub fn job_name(mut self, input: impl Into<std::string::String>) -> Self {
self.job_name = Some(input.into());
self
}
/// <p>The name of the job definition for which to stop job runs.</p>
pub fn set_job_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.job_name = input;
self
}
/// Appends an item to `job_run_ids`.
///
/// To override the contents of this collection use [`set_job_run_ids`](Self::set_job_run_ids).
///
/// <p>A list of the <code>JobRunIds</code> that should be stopped for that job definition.</p>
pub fn job_run_ids(mut self, input: impl Into<std::string::String>) -> Self {
let mut v = self.job_run_ids.unwrap_or_default();
v.push(input.into());
self.job_run_ids = Some(v);
self
}
/// <p>A list of the <code>JobRunIds</code> that should be stopped for that job definition.</p>
pub fn set_job_run_ids(
mut self,
input: std::option::Option<std::vec::Vec<std::string::String>>,
) -> Self {
self.job_run_ids = input;
self
}
/// Consumes the builder and constructs a [`BatchStopJobRunInput`](crate::input::BatchStopJobRunInput).
pub fn build(
self,
) -> Result<crate::input::BatchStopJobRunInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::BatchStopJobRunInput {
job_name: self.job_name,
job_run_ids: self.job_run_ids,
})
}
}
}
impl BatchStopJobRunInput {
/// Consumes the builder and constructs an Operation<[`BatchStopJobRun`](crate::operation::BatchStopJobRun)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::BatchStopJobRun,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::BatchStopJobRunInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::BatchStopJobRunInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.BatchStopJobRun",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_batch_stop_job_run(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::BatchStopJobRun::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"BatchStopJobRun",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`BatchStopJobRunInput`](crate::input::BatchStopJobRunInput).
pub fn builder() -> crate::input::batch_stop_job_run_input::Builder {
crate::input::batch_stop_job_run_input::Builder::default()
}
}
/// See [`BatchUpdatePartitionInput`](crate::input::BatchUpdatePartitionInput).
pub mod batch_update_partition_input {
/// A builder for [`BatchUpdatePartitionInput`](crate::input::BatchUpdatePartitionInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) catalog_id: std::option::Option<std::string::String>,
pub(crate) database_name: std::option::Option<std::string::String>,
pub(crate) table_name: std::option::Option<std::string::String>,
pub(crate) entries:
std::option::Option<std::vec::Vec<crate::model::BatchUpdatePartitionRequestEntry>>,
}
impl Builder {
/// <p>The ID of the catalog in which the partition is to be updated. Currently, this should be the Amazon Web Services account ID.</p>
pub fn catalog_id(mut self, input: impl Into<std::string::String>) -> Self {
self.catalog_id = Some(input.into());
self
}
/// <p>The ID of the catalog in which the partition is to be updated. Currently, this should be the Amazon Web Services account ID.</p>
pub fn set_catalog_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.catalog_id = input;
self
}
/// <p>The name of the metadata database in which the partition is to be updated.</p>
pub fn database_name(mut self, input: impl Into<std::string::String>) -> Self {
self.database_name = Some(input.into());
self
}
/// <p>The name of the metadata database in which the partition is to be updated.</p>
pub fn set_database_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.database_name = input;
self
}
/// <p>The name of the metadata table in which the partition is to be updated.</p>
pub fn table_name(mut self, input: impl Into<std::string::String>) -> Self {
self.table_name = Some(input.into());
self
}
/// <p>The name of the metadata table in which the partition is to be updated.</p>
pub fn set_table_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.table_name = input;
self
}
/// Appends an item to `entries`.
///
/// To override the contents of this collection use [`set_entries`](Self::set_entries).
///
/// <p>A list of up to 100 <code>BatchUpdatePartitionRequestEntry</code> objects to update.</p>
pub fn entries(mut self, input: crate::model::BatchUpdatePartitionRequestEntry) -> Self {
let mut v = self.entries.unwrap_or_default();
v.push(input);
self.entries = Some(v);
self
}
/// <p>A list of up to 100 <code>BatchUpdatePartitionRequestEntry</code> objects to update.</p>
pub fn set_entries(
mut self,
input: std::option::Option<
std::vec::Vec<crate::model::BatchUpdatePartitionRequestEntry>,
>,
) -> Self {
self.entries = input;
self
}
/// Consumes the builder and constructs a [`BatchUpdatePartitionInput`](crate::input::BatchUpdatePartitionInput).
pub fn build(
self,
) -> Result<
crate::input::BatchUpdatePartitionInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::BatchUpdatePartitionInput {
catalog_id: self.catalog_id,
database_name: self.database_name,
table_name: self.table_name,
entries: self.entries,
})
}
}
}
impl BatchUpdatePartitionInput {
/// Consumes the builder and constructs an Operation<[`BatchUpdatePartition`](crate::operation::BatchUpdatePartition)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::BatchUpdatePartition,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::BatchUpdatePartitionInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::BatchUpdatePartitionInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.BatchUpdatePartition",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_batch_update_partition(
&self,
)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::BatchUpdatePartition::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"BatchUpdatePartition",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`BatchUpdatePartitionInput`](crate::input::BatchUpdatePartitionInput).
pub fn builder() -> crate::input::batch_update_partition_input::Builder {
crate::input::batch_update_partition_input::Builder::default()
}
}
/// See [`CancelDataQualityRuleRecommendationRunInput`](crate::input::CancelDataQualityRuleRecommendationRunInput).
pub mod cancel_data_quality_rule_recommendation_run_input {
/// A builder for [`CancelDataQualityRuleRecommendationRunInput`](crate::input::CancelDataQualityRuleRecommendationRunInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) run_id: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The unique run identifier associated with this run.</p>
pub fn run_id(mut self, input: impl Into<std::string::String>) -> Self {
self.run_id = Some(input.into());
self
}
/// <p>The unique run identifier associated with this run.</p>
pub fn set_run_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.run_id = input;
self
}
/// Consumes the builder and constructs a [`CancelDataQualityRuleRecommendationRunInput`](crate::input::CancelDataQualityRuleRecommendationRunInput).
pub fn build(
self,
) -> Result<
crate::input::CancelDataQualityRuleRecommendationRunInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::CancelDataQualityRuleRecommendationRunInput {
run_id: self.run_id,
})
}
}
}
impl CancelDataQualityRuleRecommendationRunInput {
/// Consumes the builder and constructs an Operation<[`CancelDataQualityRuleRecommendationRun`](crate::operation::CancelDataQualityRuleRecommendationRun)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::CancelDataQualityRuleRecommendationRun,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::CancelDataQualityRuleRecommendationRunInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::CancelDataQualityRuleRecommendationRunInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.CancelDataQualityRuleRecommendationRun",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_cancel_data_quality_rule_recommendation_run(&self)?
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::CancelDataQualityRuleRecommendationRun::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"CancelDataQualityRuleRecommendationRun",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`CancelDataQualityRuleRecommendationRunInput`](crate::input::CancelDataQualityRuleRecommendationRunInput).
pub fn builder() -> crate::input::cancel_data_quality_rule_recommendation_run_input::Builder {
crate::input::cancel_data_quality_rule_recommendation_run_input::Builder::default()
}
}
/// See [`CancelDataQualityRulesetEvaluationRunInput`](crate::input::CancelDataQualityRulesetEvaluationRunInput).
pub mod cancel_data_quality_ruleset_evaluation_run_input {
/// A builder for [`CancelDataQualityRulesetEvaluationRunInput`](crate::input::CancelDataQualityRulesetEvaluationRunInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) run_id: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The unique run identifier associated with this run.</p>
pub fn run_id(mut self, input: impl Into<std::string::String>) -> Self {
self.run_id = Some(input.into());
self
}
/// <p>The unique run identifier associated with this run.</p>
pub fn set_run_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.run_id = input;
self
}
/// Consumes the builder and constructs a [`CancelDataQualityRulesetEvaluationRunInput`](crate::input::CancelDataQualityRulesetEvaluationRunInput).
pub fn build(
self,
) -> Result<
crate::input::CancelDataQualityRulesetEvaluationRunInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::CancelDataQualityRulesetEvaluationRunInput {
run_id: self.run_id,
})
}
}
}
impl CancelDataQualityRulesetEvaluationRunInput {
/// Consumes the builder and constructs an Operation<[`CancelDataQualityRulesetEvaluationRun`](crate::operation::CancelDataQualityRulesetEvaluationRun)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::CancelDataQualityRulesetEvaluationRun,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::CancelDataQualityRulesetEvaluationRunInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::CancelDataQualityRulesetEvaluationRunInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.CancelDataQualityRulesetEvaluationRun",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_cancel_data_quality_ruleset_evaluation_run(&self)?
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::CancelDataQualityRulesetEvaluationRun::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"CancelDataQualityRulesetEvaluationRun",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`CancelDataQualityRulesetEvaluationRunInput`](crate::input::CancelDataQualityRulesetEvaluationRunInput).
pub fn builder() -> crate::input::cancel_data_quality_ruleset_evaluation_run_input::Builder {
crate::input::cancel_data_quality_ruleset_evaluation_run_input::Builder::default()
}
}
/// See [`CancelMlTaskRunInput`](crate::input::CancelMlTaskRunInput).
pub mod cancel_ml_task_run_input {
/// A builder for [`CancelMlTaskRunInput`](crate::input::CancelMlTaskRunInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) transform_id: std::option::Option<std::string::String>,
pub(crate) task_run_id: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The unique identifier of the machine learning transform.</p>
pub fn transform_id(mut self, input: impl Into<std::string::String>) -> Self {
self.transform_id = Some(input.into());
self
}
/// <p>The unique identifier of the machine learning transform.</p>
pub fn set_transform_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.transform_id = input;
self
}
/// <p>A unique identifier for the task run.</p>
pub fn task_run_id(mut self, input: impl Into<std::string::String>) -> Self {
self.task_run_id = Some(input.into());
self
}
/// <p>A unique identifier for the task run.</p>
pub fn set_task_run_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.task_run_id = input;
self
}
/// Consumes the builder and constructs a [`CancelMlTaskRunInput`](crate::input::CancelMlTaskRunInput).
pub fn build(
self,
) -> Result<crate::input::CancelMlTaskRunInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::CancelMlTaskRunInput {
transform_id: self.transform_id,
task_run_id: self.task_run_id,
})
}
}
}
impl CancelMlTaskRunInput {
/// Consumes the builder and constructs an Operation<[`CancelMLTaskRun`](crate::operation::CancelMLTaskRun)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::CancelMLTaskRun,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::CancelMlTaskRunInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::CancelMlTaskRunInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.CancelMLTaskRun",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_cancel_ml_task_run(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::CancelMLTaskRun::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"CancelMLTaskRun",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`CancelMlTaskRunInput`](crate::input::CancelMlTaskRunInput).
pub fn builder() -> crate::input::cancel_ml_task_run_input::Builder {
crate::input::cancel_ml_task_run_input::Builder::default()
}
}
/// See [`CancelStatementInput`](crate::input::CancelStatementInput).
pub mod cancel_statement_input {
/// A builder for [`CancelStatementInput`](crate::input::CancelStatementInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) session_id: std::option::Option<std::string::String>,
pub(crate) id: std::option::Option<i32>,
pub(crate) request_origin: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The Session ID of the statement to be cancelled.</p>
pub fn session_id(mut self, input: impl Into<std::string::String>) -> Self {
self.session_id = Some(input.into());
self
}
/// <p>The Session ID of the statement to be cancelled.</p>
pub fn set_session_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.session_id = input;
self
}
/// <p>The ID of the statement to be cancelled.</p>
pub fn id(mut self, input: i32) -> Self {
self.id = Some(input);
self
}
/// <p>The ID of the statement to be cancelled.</p>
pub fn set_id(mut self, input: std::option::Option<i32>) -> Self {
self.id = input;
self
}
/// <p>The origin of the request to cancel the statement.</p>
pub fn request_origin(mut self, input: impl Into<std::string::String>) -> Self {
self.request_origin = Some(input.into());
self
}
/// <p>The origin of the request to cancel the statement.</p>
pub fn set_request_origin(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.request_origin = input;
self
}
/// Consumes the builder and constructs a [`CancelStatementInput`](crate::input::CancelStatementInput).
pub fn build(
self,
) -> Result<crate::input::CancelStatementInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::CancelStatementInput {
session_id: self.session_id,
id: self.id.unwrap_or_default(),
request_origin: self.request_origin,
})
}
}
}
impl CancelStatementInput {
/// Consumes the builder and constructs an Operation<[`CancelStatement`](crate::operation::CancelStatement)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::CancelStatement,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::CancelStatementInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::CancelStatementInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.CancelStatement",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_cancel_statement(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::CancelStatement::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"CancelStatement",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`CancelStatementInput`](crate::input::CancelStatementInput).
pub fn builder() -> crate::input::cancel_statement_input::Builder {
crate::input::cancel_statement_input::Builder::default()
}
}
/// See [`CheckSchemaVersionValidityInput`](crate::input::CheckSchemaVersionValidityInput).
pub mod check_schema_version_validity_input {
/// A builder for [`CheckSchemaVersionValidityInput`](crate::input::CheckSchemaVersionValidityInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) data_format: std::option::Option<crate::model::DataFormat>,
pub(crate) schema_definition: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The data format of the schema definition. Currently <code>AVRO</code>, <code>JSON</code> and <code>PROTOBUF</code> are supported.</p>
pub fn data_format(mut self, input: crate::model::DataFormat) -> Self {
self.data_format = Some(input);
self
}
/// <p>The data format of the schema definition. Currently <code>AVRO</code>, <code>JSON</code> and <code>PROTOBUF</code> are supported.</p>
pub fn set_data_format(
mut self,
input: std::option::Option<crate::model::DataFormat>,
) -> Self {
self.data_format = input;
self
}
/// <p>The definition of the schema that has to be validated.</p>
pub fn schema_definition(mut self, input: impl Into<std::string::String>) -> Self {
self.schema_definition = Some(input.into());
self
}
/// <p>The definition of the schema that has to be validated.</p>
pub fn set_schema_definition(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.schema_definition = input;
self
}
/// Consumes the builder and constructs a [`CheckSchemaVersionValidityInput`](crate::input::CheckSchemaVersionValidityInput).
pub fn build(
self,
) -> Result<
crate::input::CheckSchemaVersionValidityInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::CheckSchemaVersionValidityInput {
data_format: self.data_format,
schema_definition: self.schema_definition,
})
}
}
}
impl CheckSchemaVersionValidityInput {
/// Consumes the builder and constructs an Operation<[`CheckSchemaVersionValidity`](crate::operation::CheckSchemaVersionValidity)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::CheckSchemaVersionValidity,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::CheckSchemaVersionValidityInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::CheckSchemaVersionValidityInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.CheckSchemaVersionValidity",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_check_schema_version_validity(&self)?
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::CheckSchemaVersionValidity::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"CheckSchemaVersionValidity",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`CheckSchemaVersionValidityInput`](crate::input::CheckSchemaVersionValidityInput).
pub fn builder() -> crate::input::check_schema_version_validity_input::Builder {
crate::input::check_schema_version_validity_input::Builder::default()
}
}
/// See [`CreateBlueprintInput`](crate::input::CreateBlueprintInput).
pub mod create_blueprint_input {
/// A builder for [`CreateBlueprintInput`](crate::input::CreateBlueprintInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) name: std::option::Option<std::string::String>,
pub(crate) description: std::option::Option<std::string::String>,
pub(crate) blueprint_location: std::option::Option<std::string::String>,
pub(crate) tags: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
}
impl Builder {
/// <p>The name of the blueprint.</p>
pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
self.name = Some(input.into());
self
}
/// <p>The name of the blueprint.</p>
pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.name = input;
self
}
/// <p>A description of the blueprint.</p>
pub fn description(mut self, input: impl Into<std::string::String>) -> Self {
self.description = Some(input.into());
self
}
/// <p>A description of the blueprint.</p>
pub fn set_description(mut self, input: std::option::Option<std::string::String>) -> Self {
self.description = input;
self
}
/// <p>Specifies a path in Amazon S3 where the blueprint is published.</p>
pub fn blueprint_location(mut self, input: impl Into<std::string::String>) -> Self {
self.blueprint_location = Some(input.into());
self
}
/// <p>Specifies a path in Amazon S3 where the blueprint is published.</p>
pub fn set_blueprint_location(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.blueprint_location = input;
self
}
/// Adds a key-value pair to `tags`.
///
/// To override the contents of this collection use [`set_tags`](Self::set_tags).
///
/// <p>The tags to be applied to this blueprint.</p>
pub fn tags(
mut self,
k: impl Into<std::string::String>,
v: impl Into<std::string::String>,
) -> Self {
let mut hash_map = self.tags.unwrap_or_default();
hash_map.insert(k.into(), v.into());
self.tags = Some(hash_map);
self
}
/// <p>The tags to be applied to this blueprint.</p>
pub fn set_tags(
mut self,
input: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
) -> Self {
self.tags = input;
self
}
/// Consumes the builder and constructs a [`CreateBlueprintInput`](crate::input::CreateBlueprintInput).
pub fn build(
self,
) -> Result<crate::input::CreateBlueprintInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::CreateBlueprintInput {
name: self.name,
description: self.description,
blueprint_location: self.blueprint_location,
tags: self.tags,
})
}
}
}
impl CreateBlueprintInput {
/// Consumes the builder and constructs an Operation<[`CreateBlueprint`](crate::operation::CreateBlueprint)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::CreateBlueprint,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::CreateBlueprintInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::CreateBlueprintInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.CreateBlueprint",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_create_blueprint(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::CreateBlueprint::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"CreateBlueprint",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`CreateBlueprintInput`](crate::input::CreateBlueprintInput).
pub fn builder() -> crate::input::create_blueprint_input::Builder {
crate::input::create_blueprint_input::Builder::default()
}
}
/// See [`CreateClassifierInput`](crate::input::CreateClassifierInput).
pub mod create_classifier_input {
/// A builder for [`CreateClassifierInput`](crate::input::CreateClassifierInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) grok_classifier: std::option::Option<crate::model::CreateGrokClassifierRequest>,
pub(crate) xml_classifier: std::option::Option<crate::model::CreateXmlClassifierRequest>,
pub(crate) json_classifier: std::option::Option<crate::model::CreateJsonClassifierRequest>,
pub(crate) csv_classifier: std::option::Option<crate::model::CreateCsvClassifierRequest>,
}
impl Builder {
/// <p>A <code>GrokClassifier</code> object specifying the classifier to create.</p>
pub fn grok_classifier(mut self, input: crate::model::CreateGrokClassifierRequest) -> Self {
self.grok_classifier = Some(input);
self
}
/// <p>A <code>GrokClassifier</code> object specifying the classifier to create.</p>
pub fn set_grok_classifier(
mut self,
input: std::option::Option<crate::model::CreateGrokClassifierRequest>,
) -> Self {
self.grok_classifier = input;
self
}
/// <p>An <code>XMLClassifier</code> object specifying the classifier to create.</p>
pub fn xml_classifier(mut self, input: crate::model::CreateXmlClassifierRequest) -> Self {
self.xml_classifier = Some(input);
self
}
/// <p>An <code>XMLClassifier</code> object specifying the classifier to create.</p>
pub fn set_xml_classifier(
mut self,
input: std::option::Option<crate::model::CreateXmlClassifierRequest>,
) -> Self {
self.xml_classifier = input;
self
}
/// <p>A <code>JsonClassifier</code> object specifying the classifier to create.</p>
pub fn json_classifier(mut self, input: crate::model::CreateJsonClassifierRequest) -> Self {
self.json_classifier = Some(input);
self
}
/// <p>A <code>JsonClassifier</code> object specifying the classifier to create.</p>
pub fn set_json_classifier(
mut self,
input: std::option::Option<crate::model::CreateJsonClassifierRequest>,
) -> Self {
self.json_classifier = input;
self
}
/// <p>A <code>CsvClassifier</code> object specifying the classifier to create.</p>
pub fn csv_classifier(mut self, input: crate::model::CreateCsvClassifierRequest) -> Self {
self.csv_classifier = Some(input);
self
}
/// <p>A <code>CsvClassifier</code> object specifying the classifier to create.</p>
pub fn set_csv_classifier(
mut self,
input: std::option::Option<crate::model::CreateCsvClassifierRequest>,
) -> Self {
self.csv_classifier = input;
self
}
/// Consumes the builder and constructs a [`CreateClassifierInput`](crate::input::CreateClassifierInput).
pub fn build(
self,
) -> Result<
crate::input::CreateClassifierInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::CreateClassifierInput {
grok_classifier: self.grok_classifier,
xml_classifier: self.xml_classifier,
json_classifier: self.json_classifier,
csv_classifier: self.csv_classifier,
})
}
}
}
impl CreateClassifierInput {
/// Consumes the builder and constructs an Operation<[`CreateClassifier`](crate::operation::CreateClassifier)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::CreateClassifier,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::CreateClassifierInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::CreateClassifierInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.CreateClassifier",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_create_classifier(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::CreateClassifier::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"CreateClassifier",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`CreateClassifierInput`](crate::input::CreateClassifierInput).
pub fn builder() -> crate::input::create_classifier_input::Builder {
crate::input::create_classifier_input::Builder::default()
}
}
/// See [`CreateConnectionInput`](crate::input::CreateConnectionInput).
pub mod create_connection_input {
/// A builder for [`CreateConnectionInput`](crate::input::CreateConnectionInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) catalog_id: std::option::Option<std::string::String>,
pub(crate) connection_input: std::option::Option<crate::model::ConnectionInput>,
pub(crate) tags: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
}
impl Builder {
/// <p>The ID of the Data Catalog in which to create the connection. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(mut self, input: impl Into<std::string::String>) -> Self {
self.catalog_id = Some(input.into());
self
}
/// <p>The ID of the Data Catalog in which to create the connection. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn set_catalog_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.catalog_id = input;
self
}
/// <p>A <code>ConnectionInput</code> object defining the connection to create.</p>
pub fn connection_input(mut self, input: crate::model::ConnectionInput) -> Self {
self.connection_input = Some(input);
self
}
/// <p>A <code>ConnectionInput</code> object defining the connection to create.</p>
pub fn set_connection_input(
mut self,
input: std::option::Option<crate::model::ConnectionInput>,
) -> Self {
self.connection_input = input;
self
}
/// Adds a key-value pair to `tags`.
///
/// To override the contents of this collection use [`set_tags`](Self::set_tags).
///
/// <p>The tags you assign to the connection.</p>
pub fn tags(
mut self,
k: impl Into<std::string::String>,
v: impl Into<std::string::String>,
) -> Self {
let mut hash_map = self.tags.unwrap_or_default();
hash_map.insert(k.into(), v.into());
self.tags = Some(hash_map);
self
}
/// <p>The tags you assign to the connection.</p>
pub fn set_tags(
mut self,
input: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
) -> Self {
self.tags = input;
self
}
/// Consumes the builder and constructs a [`CreateConnectionInput`](crate::input::CreateConnectionInput).
pub fn build(
self,
) -> Result<
crate::input::CreateConnectionInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::CreateConnectionInput {
catalog_id: self.catalog_id,
connection_input: self.connection_input,
tags: self.tags,
})
}
}
}
impl CreateConnectionInput {
/// Consumes the builder and constructs an Operation<[`CreateConnection`](crate::operation::CreateConnection)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::CreateConnection,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::CreateConnectionInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::CreateConnectionInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.CreateConnection",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_create_connection(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::CreateConnection::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"CreateConnection",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`CreateConnectionInput`](crate::input::CreateConnectionInput).
pub fn builder() -> crate::input::create_connection_input::Builder {
crate::input::create_connection_input::Builder::default()
}
}
/// See [`CreateCrawlerInput`](crate::input::CreateCrawlerInput).
pub mod create_crawler_input {
/// A builder for [`CreateCrawlerInput`](crate::input::CreateCrawlerInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) name: std::option::Option<std::string::String>,
pub(crate) role: std::option::Option<std::string::String>,
pub(crate) database_name: std::option::Option<std::string::String>,
pub(crate) description: std::option::Option<std::string::String>,
pub(crate) targets: std::option::Option<crate::model::CrawlerTargets>,
pub(crate) schedule: std::option::Option<std::string::String>,
pub(crate) classifiers: std::option::Option<std::vec::Vec<std::string::String>>,
pub(crate) table_prefix: std::option::Option<std::string::String>,
pub(crate) schema_change_policy: std::option::Option<crate::model::SchemaChangePolicy>,
pub(crate) recrawl_policy: std::option::Option<crate::model::RecrawlPolicy>,
pub(crate) lineage_configuration: std::option::Option<crate::model::LineageConfiguration>,
pub(crate) lake_formation_configuration:
std::option::Option<crate::model::LakeFormationConfiguration>,
pub(crate) configuration: std::option::Option<std::string::String>,
pub(crate) crawler_security_configuration: std::option::Option<std::string::String>,
pub(crate) tags: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
}
impl Builder {
/// <p>Name of the new crawler.</p>
pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
self.name = Some(input.into());
self
}
/// <p>Name of the new crawler.</p>
pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.name = input;
self
}
/// <p>The IAM role or Amazon Resource Name (ARN) of an IAM role used by the new crawler to access customer resources.</p>
pub fn role(mut self, input: impl Into<std::string::String>) -> Self {
self.role = Some(input.into());
self
}
/// <p>The IAM role or Amazon Resource Name (ARN) of an IAM role used by the new crawler to access customer resources.</p>
pub fn set_role(mut self, input: std::option::Option<std::string::String>) -> Self {
self.role = input;
self
}
/// <p>The Glue database where results are written, such as: <code>arn:aws:daylight:us-east-1::database/sometable/*</code>.</p>
pub fn database_name(mut self, input: impl Into<std::string::String>) -> Self {
self.database_name = Some(input.into());
self
}
/// <p>The Glue database where results are written, such as: <code>arn:aws:daylight:us-east-1::database/sometable/*</code>.</p>
pub fn set_database_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.database_name = input;
self
}
/// <p>A description of the new crawler.</p>
pub fn description(mut self, input: impl Into<std::string::String>) -> Self {
self.description = Some(input.into());
self
}
/// <p>A description of the new crawler.</p>
pub fn set_description(mut self, input: std::option::Option<std::string::String>) -> Self {
self.description = input;
self
}
/// <p>A list of collection of targets to crawl.</p>
pub fn targets(mut self, input: crate::model::CrawlerTargets) -> Self {
self.targets = Some(input);
self
}
/// <p>A list of collection of targets to crawl.</p>
pub fn set_targets(
mut self,
input: std::option::Option<crate::model::CrawlerTargets>,
) -> Self {
self.targets = input;
self
}
/// <p>A <code>cron</code> expression used to specify the schedule (see <a href="https://docs.aws.amazon.com/glue/latest/dg/monitor-data-warehouse-schedule.html">Time-Based Schedules for Jobs and Crawlers</a>. For example, to run something every day at 12:15 UTC, you would specify: <code>cron(15 12 * * ? *)</code>.</p>
pub fn schedule(mut self, input: impl Into<std::string::String>) -> Self {
self.schedule = Some(input.into());
self
}
/// <p>A <code>cron</code> expression used to specify the schedule (see <a href="https://docs.aws.amazon.com/glue/latest/dg/monitor-data-warehouse-schedule.html">Time-Based Schedules for Jobs and Crawlers</a>. For example, to run something every day at 12:15 UTC, you would specify: <code>cron(15 12 * * ? *)</code>.</p>
pub fn set_schedule(mut self, input: std::option::Option<std::string::String>) -> Self {
self.schedule = input;
self
}
/// Appends an item to `classifiers`.
///
/// To override the contents of this collection use [`set_classifiers`](Self::set_classifiers).
///
/// <p>A list of custom classifiers that the user has registered. By default, all built-in classifiers are included in a crawl, but these custom classifiers always override the default classifiers for a given classification.</p>
pub fn classifiers(mut self, input: impl Into<std::string::String>) -> Self {
let mut v = self.classifiers.unwrap_or_default();
v.push(input.into());
self.classifiers = Some(v);
self
}
/// <p>A list of custom classifiers that the user has registered. By default, all built-in classifiers are included in a crawl, but these custom classifiers always override the default classifiers for a given classification.</p>
pub fn set_classifiers(
mut self,
input: std::option::Option<std::vec::Vec<std::string::String>>,
) -> Self {
self.classifiers = input;
self
}
/// <p>The table prefix used for catalog tables that are created.</p>
pub fn table_prefix(mut self, input: impl Into<std::string::String>) -> Self {
self.table_prefix = Some(input.into());
self
}
/// <p>The table prefix used for catalog tables that are created.</p>
pub fn set_table_prefix(mut self, input: std::option::Option<std::string::String>) -> Self {
self.table_prefix = input;
self
}
/// <p>The policy for the crawler's update and deletion behavior.</p>
pub fn schema_change_policy(mut self, input: crate::model::SchemaChangePolicy) -> Self {
self.schema_change_policy = Some(input);
self
}
/// <p>The policy for the crawler's update and deletion behavior.</p>
pub fn set_schema_change_policy(
mut self,
input: std::option::Option<crate::model::SchemaChangePolicy>,
) -> Self {
self.schema_change_policy = input;
self
}
/// <p>A policy that specifies whether to crawl the entire dataset again, or to crawl only folders that were added since the last crawler run.</p>
pub fn recrawl_policy(mut self, input: crate::model::RecrawlPolicy) -> Self {
self.recrawl_policy = Some(input);
self
}
/// <p>A policy that specifies whether to crawl the entire dataset again, or to crawl only folders that were added since the last crawler run.</p>
pub fn set_recrawl_policy(
mut self,
input: std::option::Option<crate::model::RecrawlPolicy>,
) -> Self {
self.recrawl_policy = input;
self
}
/// <p>Specifies data lineage configuration settings for the crawler.</p>
pub fn lineage_configuration(mut self, input: crate::model::LineageConfiguration) -> Self {
self.lineage_configuration = Some(input);
self
}
/// <p>Specifies data lineage configuration settings for the crawler.</p>
pub fn set_lineage_configuration(
mut self,
input: std::option::Option<crate::model::LineageConfiguration>,
) -> Self {
self.lineage_configuration = input;
self
}
/// <p>Specifies Lake Formation configuration settings for the crawler.</p>
pub fn lake_formation_configuration(
mut self,
input: crate::model::LakeFormationConfiguration,
) -> Self {
self.lake_formation_configuration = Some(input);
self
}
/// <p>Specifies Lake Formation configuration settings for the crawler.</p>
pub fn set_lake_formation_configuration(
mut self,
input: std::option::Option<crate::model::LakeFormationConfiguration>,
) -> Self {
self.lake_formation_configuration = input;
self
}
/// <p>Crawler configuration information. This versioned JSON string allows users to specify aspects of a crawler's behavior. For more information, see <a href="https://docs.aws.amazon.com/glue/latest/dg/crawler-configuration.html">Setting crawler configuration options</a>.</p>
pub fn configuration(mut self, input: impl Into<std::string::String>) -> Self {
self.configuration = Some(input.into());
self
}
/// <p>Crawler configuration information. This versioned JSON string allows users to specify aspects of a crawler's behavior. For more information, see <a href="https://docs.aws.amazon.com/glue/latest/dg/crawler-configuration.html">Setting crawler configuration options</a>.</p>
pub fn set_configuration(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.configuration = input;
self
}
/// <p>The name of the <code>SecurityConfiguration</code> structure to be used by this crawler.</p>
pub fn crawler_security_configuration(
mut self,
input: impl Into<std::string::String>,
) -> Self {
self.crawler_security_configuration = Some(input.into());
self
}
/// <p>The name of the <code>SecurityConfiguration</code> structure to be used by this crawler.</p>
pub fn set_crawler_security_configuration(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.crawler_security_configuration = input;
self
}
/// Adds a key-value pair to `tags`.
///
/// To override the contents of this collection use [`set_tags`](Self::set_tags).
///
/// <p>The tags to use with this crawler request. You may use tags to limit access to the crawler. For more information about tags in Glue, see <a href="https://docs.aws.amazon.com/glue/latest/dg/monitor-tags.html">Amazon Web Services Tags in Glue</a> in the developer guide.</p>
pub fn tags(
mut self,
k: impl Into<std::string::String>,
v: impl Into<std::string::String>,
) -> Self {
let mut hash_map = self.tags.unwrap_or_default();
hash_map.insert(k.into(), v.into());
self.tags = Some(hash_map);
self
}
/// <p>The tags to use with this crawler request. You may use tags to limit access to the crawler. For more information about tags in Glue, see <a href="https://docs.aws.amazon.com/glue/latest/dg/monitor-tags.html">Amazon Web Services Tags in Glue</a> in the developer guide.</p>
pub fn set_tags(
mut self,
input: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
) -> Self {
self.tags = input;
self
}
/// Consumes the builder and constructs a [`CreateCrawlerInput`](crate::input::CreateCrawlerInput).
pub fn build(
self,
) -> Result<crate::input::CreateCrawlerInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::CreateCrawlerInput {
name: self.name,
role: self.role,
database_name: self.database_name,
description: self.description,
targets: self.targets,
schedule: self.schedule,
classifiers: self.classifiers,
table_prefix: self.table_prefix,
schema_change_policy: self.schema_change_policy,
recrawl_policy: self.recrawl_policy,
lineage_configuration: self.lineage_configuration,
lake_formation_configuration: self.lake_formation_configuration,
configuration: self.configuration,
crawler_security_configuration: self.crawler_security_configuration,
tags: self.tags,
})
}
}
}
impl CreateCrawlerInput {
/// Consumes the builder and constructs an Operation<[`CreateCrawler`](crate::operation::CreateCrawler)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::CreateCrawler,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::CreateCrawlerInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::CreateCrawlerInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.CreateCrawler",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_create_crawler(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::CreateCrawler::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"CreateCrawler",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`CreateCrawlerInput`](crate::input::CreateCrawlerInput).
pub fn builder() -> crate::input::create_crawler_input::Builder {
crate::input::create_crawler_input::Builder::default()
}
}
/// See [`CreateCustomEntityTypeInput`](crate::input::CreateCustomEntityTypeInput).
pub mod create_custom_entity_type_input {
/// A builder for [`CreateCustomEntityTypeInput`](crate::input::CreateCustomEntityTypeInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) name: std::option::Option<std::string::String>,
pub(crate) regex_string: std::option::Option<std::string::String>,
pub(crate) context_words: std::option::Option<std::vec::Vec<std::string::String>>,
}
impl Builder {
/// <p>A name for the custom pattern that allows it to be retrieved or deleted later. This name must be unique per Amazon Web Services account.</p>
pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
self.name = Some(input.into());
self
}
/// <p>A name for the custom pattern that allows it to be retrieved or deleted later. This name must be unique per Amazon Web Services account.</p>
pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.name = input;
self
}
/// <p>A regular expression string that is used for detecting sensitive data in a custom pattern.</p>
pub fn regex_string(mut self, input: impl Into<std::string::String>) -> Self {
self.regex_string = Some(input.into());
self
}
/// <p>A regular expression string that is used for detecting sensitive data in a custom pattern.</p>
pub fn set_regex_string(mut self, input: std::option::Option<std::string::String>) -> Self {
self.regex_string = input;
self
}
/// Appends an item to `context_words`.
///
/// To override the contents of this collection use [`set_context_words`](Self::set_context_words).
///
/// <p>A list of context words. If none of these context words are found within the vicinity of the regular expression the data will not be detected as sensitive data.</p>
/// <p>If no context words are passed only a regular expression is checked.</p>
pub fn context_words(mut self, input: impl Into<std::string::String>) -> Self {
let mut v = self.context_words.unwrap_or_default();
v.push(input.into());
self.context_words = Some(v);
self
}
/// <p>A list of context words. If none of these context words are found within the vicinity of the regular expression the data will not be detected as sensitive data.</p>
/// <p>If no context words are passed only a regular expression is checked.</p>
pub fn set_context_words(
mut self,
input: std::option::Option<std::vec::Vec<std::string::String>>,
) -> Self {
self.context_words = input;
self
}
/// Consumes the builder and constructs a [`CreateCustomEntityTypeInput`](crate::input::CreateCustomEntityTypeInput).
pub fn build(
self,
) -> Result<
crate::input::CreateCustomEntityTypeInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::CreateCustomEntityTypeInput {
name: self.name,
regex_string: self.regex_string,
context_words: self.context_words,
})
}
}
}
impl CreateCustomEntityTypeInput {
/// Consumes the builder and constructs an Operation<[`CreateCustomEntityType`](crate::operation::CreateCustomEntityType)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::CreateCustomEntityType,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::CreateCustomEntityTypeInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::CreateCustomEntityTypeInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.CreateCustomEntityType",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_create_custom_entity_type(
&self,
)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::CreateCustomEntityType::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"CreateCustomEntityType",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`CreateCustomEntityTypeInput`](crate::input::CreateCustomEntityTypeInput).
pub fn builder() -> crate::input::create_custom_entity_type_input::Builder {
crate::input::create_custom_entity_type_input::Builder::default()
}
}
/// See [`CreateDatabaseInput`](crate::input::CreateDatabaseInput).
pub mod create_database_input {
/// A builder for [`CreateDatabaseInput`](crate::input::CreateDatabaseInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) catalog_id: std::option::Option<std::string::String>,
pub(crate) database_input: std::option::Option<crate::model::DatabaseInput>,
pub(crate) tags: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
}
impl Builder {
/// <p>The ID of the Data Catalog in which to create the database. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(mut self, input: impl Into<std::string::String>) -> Self {
self.catalog_id = Some(input.into());
self
}
/// <p>The ID of the Data Catalog in which to create the database. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn set_catalog_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.catalog_id = input;
self
}
/// <p>The metadata for the database.</p>
pub fn database_input(mut self, input: crate::model::DatabaseInput) -> Self {
self.database_input = Some(input);
self
}
/// <p>The metadata for the database.</p>
pub fn set_database_input(
mut self,
input: std::option::Option<crate::model::DatabaseInput>,
) -> Self {
self.database_input = input;
self
}
/// Adds a key-value pair to `tags`.
///
/// To override the contents of this collection use [`set_tags`](Self::set_tags).
///
/// <p>The tags you assign to the database.</p>
pub fn tags(
mut self,
k: impl Into<std::string::String>,
v: impl Into<std::string::String>,
) -> Self {
let mut hash_map = self.tags.unwrap_or_default();
hash_map.insert(k.into(), v.into());
self.tags = Some(hash_map);
self
}
/// <p>The tags you assign to the database.</p>
pub fn set_tags(
mut self,
input: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
) -> Self {
self.tags = input;
self
}
/// Consumes the builder and constructs a [`CreateDatabaseInput`](crate::input::CreateDatabaseInput).
pub fn build(
self,
) -> Result<crate::input::CreateDatabaseInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::CreateDatabaseInput {
catalog_id: self.catalog_id,
database_input: self.database_input,
tags: self.tags,
})
}
}
}
impl CreateDatabaseInput {
/// Consumes the builder and constructs an Operation<[`CreateDatabase`](crate::operation::CreateDatabase)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::CreateDatabase,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::CreateDatabaseInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::CreateDatabaseInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.CreateDatabase",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_create_database(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::CreateDatabase::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"CreateDatabase",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`CreateDatabaseInput`](crate::input::CreateDatabaseInput).
pub fn builder() -> crate::input::create_database_input::Builder {
crate::input::create_database_input::Builder::default()
}
}
/// See [`CreateDataQualityRulesetInput`](crate::input::CreateDataQualityRulesetInput).
pub mod create_data_quality_ruleset_input {
/// A builder for [`CreateDataQualityRulesetInput`](crate::input::CreateDataQualityRulesetInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) name: std::option::Option<std::string::String>,
pub(crate) description: std::option::Option<std::string::String>,
pub(crate) ruleset: std::option::Option<std::string::String>,
pub(crate) tags: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
pub(crate) target_table: std::option::Option<crate::model::DataQualityTargetTable>,
pub(crate) client_token: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>A unique name for the data quality ruleset.</p>
pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
self.name = Some(input.into());
self
}
/// <p>A unique name for the data quality ruleset.</p>
pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.name = input;
self
}
/// <p>A description of the data quality ruleset.</p>
pub fn description(mut self, input: impl Into<std::string::String>) -> Self {
self.description = Some(input.into());
self
}
/// <p>A description of the data quality ruleset.</p>
pub fn set_description(mut self, input: std::option::Option<std::string::String>) -> Self {
self.description = input;
self
}
/// <p>A Data Quality Definition Language (DQDL) ruleset. For more information, see the Glue developer guide.</p>
pub fn ruleset(mut self, input: impl Into<std::string::String>) -> Self {
self.ruleset = Some(input.into());
self
}
/// <p>A Data Quality Definition Language (DQDL) ruleset. For more information, see the Glue developer guide.</p>
pub fn set_ruleset(mut self, input: std::option::Option<std::string::String>) -> Self {
self.ruleset = input;
self
}
/// Adds a key-value pair to `tags`.
///
/// To override the contents of this collection use [`set_tags`](Self::set_tags).
///
/// <p>A list of tags applied to the data quality ruleset.</p>
pub fn tags(
mut self,
k: impl Into<std::string::String>,
v: impl Into<std::string::String>,
) -> Self {
let mut hash_map = self.tags.unwrap_or_default();
hash_map.insert(k.into(), v.into());
self.tags = Some(hash_map);
self
}
/// <p>A list of tags applied to the data quality ruleset.</p>
pub fn set_tags(
mut self,
input: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
) -> Self {
self.tags = input;
self
}
/// <p>A target table associated with the data quality ruleset.</p>
pub fn target_table(mut self, input: crate::model::DataQualityTargetTable) -> Self {
self.target_table = Some(input);
self
}
/// <p>A target table associated with the data quality ruleset.</p>
pub fn set_target_table(
mut self,
input: std::option::Option<crate::model::DataQualityTargetTable>,
) -> Self {
self.target_table = input;
self
}
/// <p>Used for idempotency and is recommended to be set to a random ID (such as a UUID) to avoid creating or starting multiple instances of the same resource.</p>
pub fn client_token(mut self, input: impl Into<std::string::String>) -> Self {
self.client_token = Some(input.into());
self
}
/// <p>Used for idempotency and is recommended to be set to a random ID (such as a UUID) to avoid creating or starting multiple instances of the same resource.</p>
pub fn set_client_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.client_token = input;
self
}
/// Consumes the builder and constructs a [`CreateDataQualityRulesetInput`](crate::input::CreateDataQualityRulesetInput).
pub fn build(
self,
) -> Result<
crate::input::CreateDataQualityRulesetInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::CreateDataQualityRulesetInput {
name: self.name,
description: self.description,
ruleset: self.ruleset,
tags: self.tags,
target_table: self.target_table,
client_token: self.client_token,
})
}
}
}
impl CreateDataQualityRulesetInput {
/// Consumes the builder and constructs an Operation<[`CreateDataQualityRuleset`](crate::operation::CreateDataQualityRuleset)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::CreateDataQualityRuleset,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::CreateDataQualityRulesetInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::CreateDataQualityRulesetInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.CreateDataQualityRuleset",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_create_data_quality_ruleset(
&self,
)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::CreateDataQualityRuleset::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"CreateDataQualityRuleset",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`CreateDataQualityRulesetInput`](crate::input::CreateDataQualityRulesetInput).
pub fn builder() -> crate::input::create_data_quality_ruleset_input::Builder {
crate::input::create_data_quality_ruleset_input::Builder::default()
}
}
/// See [`CreateDevEndpointInput`](crate::input::CreateDevEndpointInput).
pub mod create_dev_endpoint_input {
/// A builder for [`CreateDevEndpointInput`](crate::input::CreateDevEndpointInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) endpoint_name: std::option::Option<std::string::String>,
pub(crate) role_arn: std::option::Option<std::string::String>,
pub(crate) security_group_ids: std::option::Option<std::vec::Vec<std::string::String>>,
pub(crate) subnet_id: std::option::Option<std::string::String>,
pub(crate) public_key: std::option::Option<std::string::String>,
pub(crate) public_keys: std::option::Option<std::vec::Vec<std::string::String>>,
pub(crate) number_of_nodes: std::option::Option<i32>,
pub(crate) worker_type: std::option::Option<crate::model::WorkerType>,
pub(crate) glue_version: std::option::Option<std::string::String>,
pub(crate) number_of_workers: std::option::Option<i32>,
pub(crate) extra_python_libs_s3_path: std::option::Option<std::string::String>,
pub(crate) extra_jars_s3_path: std::option::Option<std::string::String>,
pub(crate) security_configuration: std::option::Option<std::string::String>,
pub(crate) tags: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
pub(crate) arguments: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
}
impl Builder {
/// <p>The name to be assigned to the new <code>DevEndpoint</code>.</p>
pub fn endpoint_name(mut self, input: impl Into<std::string::String>) -> Self {
self.endpoint_name = Some(input.into());
self
}
/// <p>The name to be assigned to the new <code>DevEndpoint</code>.</p>
pub fn set_endpoint_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.endpoint_name = input;
self
}
/// <p>The IAM role for the <code>DevEndpoint</code>.</p>
pub fn role_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.role_arn = Some(input.into());
self
}
/// <p>The IAM role for the <code>DevEndpoint</code>.</p>
pub fn set_role_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.role_arn = input;
self
}
/// Appends an item to `security_group_ids`.
///
/// To override the contents of this collection use [`set_security_group_ids`](Self::set_security_group_ids).
///
/// <p>Security group IDs for the security groups to be used by the new <code>DevEndpoint</code>.</p>
pub fn security_group_ids(mut self, input: impl Into<std::string::String>) -> Self {
let mut v = self.security_group_ids.unwrap_or_default();
v.push(input.into());
self.security_group_ids = Some(v);
self
}
/// <p>Security group IDs for the security groups to be used by the new <code>DevEndpoint</code>.</p>
pub fn set_security_group_ids(
mut self,
input: std::option::Option<std::vec::Vec<std::string::String>>,
) -> Self {
self.security_group_ids = input;
self
}
/// <p>The subnet ID for the new <code>DevEndpoint</code> to use.</p>
pub fn subnet_id(mut self, input: impl Into<std::string::String>) -> Self {
self.subnet_id = Some(input.into());
self
}
/// <p>The subnet ID for the new <code>DevEndpoint</code> to use.</p>
pub fn set_subnet_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.subnet_id = input;
self
}
/// <p>The public key to be used by this <code>DevEndpoint</code> for authentication. This attribute is provided for backward compatibility because the recommended attribute to use is public keys.</p>
pub fn public_key(mut self, input: impl Into<std::string::String>) -> Self {
self.public_key = Some(input.into());
self
}
/// <p>The public key to be used by this <code>DevEndpoint</code> for authentication. This attribute is provided for backward compatibility because the recommended attribute to use is public keys.</p>
pub fn set_public_key(mut self, input: std::option::Option<std::string::String>) -> Self {
self.public_key = input;
self
}
/// Appends an item to `public_keys`.
///
/// To override the contents of this collection use [`set_public_keys`](Self::set_public_keys).
///
/// <p>A list of public keys to be used by the development endpoints for authentication. The use of this attribute is preferred over a single public key because the public keys allow you to have a different private key per client.</p> <note>
/// <p>If you previously created an endpoint with a public key, you must remove that key to be able to set a list of public keys. Call the <code>UpdateDevEndpoint</code> API with the public key content in the <code>deletePublicKeys</code> attribute, and the list of new keys in the <code>addPublicKeys</code> attribute.</p>
/// </note>
pub fn public_keys(mut self, input: impl Into<std::string::String>) -> Self {
let mut v = self.public_keys.unwrap_or_default();
v.push(input.into());
self.public_keys = Some(v);
self
}
/// <p>A list of public keys to be used by the development endpoints for authentication. The use of this attribute is preferred over a single public key because the public keys allow you to have a different private key per client.</p> <note>
/// <p>If you previously created an endpoint with a public key, you must remove that key to be able to set a list of public keys. Call the <code>UpdateDevEndpoint</code> API with the public key content in the <code>deletePublicKeys</code> attribute, and the list of new keys in the <code>addPublicKeys</code> attribute.</p>
/// </note>
pub fn set_public_keys(
mut self,
input: std::option::Option<std::vec::Vec<std::string::String>>,
) -> Self {
self.public_keys = input;
self
}
/// <p>The number of Glue Data Processing Units (DPUs) to allocate to this <code>DevEndpoint</code>.</p>
pub fn number_of_nodes(mut self, input: i32) -> Self {
self.number_of_nodes = Some(input);
self
}
/// <p>The number of Glue Data Processing Units (DPUs) to allocate to this <code>DevEndpoint</code>.</p>
pub fn set_number_of_nodes(mut self, input: std::option::Option<i32>) -> Self {
self.number_of_nodes = input;
self
}
/// <p>The type of predefined worker that is allocated to the development endpoint. Accepts a value of Standard, G.1X, or G.2X.</p>
/// <ul>
/// <li> <p>For the <code>Standard</code> worker type, each worker provides 4 vCPU, 16 GB of memory and a 50GB disk, and 2 executors per worker.</p> </li>
/// <li> <p>For the <code>G.1X</code> worker type, each worker maps to 1 DPU (4 vCPU, 16 GB of memory, 64 GB disk), and provides 1 executor per worker. We recommend this worker type for memory-intensive jobs.</p> </li>
/// <li> <p>For the <code>G.2X</code> worker type, each worker maps to 2 DPU (8 vCPU, 32 GB of memory, 128 GB disk), and provides 1 executor per worker. We recommend this worker type for memory-intensive jobs.</p> </li>
/// </ul>
/// <p>Known issue: when a development endpoint is created with the <code>G.2X</code> <code>WorkerType</code> configuration, the Spark drivers for the development endpoint will run on 4 vCPU, 16 GB of memory, and a 64 GB disk. </p>
pub fn worker_type(mut self, input: crate::model::WorkerType) -> Self {
self.worker_type = Some(input);
self
}
/// <p>The type of predefined worker that is allocated to the development endpoint. Accepts a value of Standard, G.1X, or G.2X.</p>
/// <ul>
/// <li> <p>For the <code>Standard</code> worker type, each worker provides 4 vCPU, 16 GB of memory and a 50GB disk, and 2 executors per worker.</p> </li>
/// <li> <p>For the <code>G.1X</code> worker type, each worker maps to 1 DPU (4 vCPU, 16 GB of memory, 64 GB disk), and provides 1 executor per worker. We recommend this worker type for memory-intensive jobs.</p> </li>
/// <li> <p>For the <code>G.2X</code> worker type, each worker maps to 2 DPU (8 vCPU, 32 GB of memory, 128 GB disk), and provides 1 executor per worker. We recommend this worker type for memory-intensive jobs.</p> </li>
/// </ul>
/// <p>Known issue: when a development endpoint is created with the <code>G.2X</code> <code>WorkerType</code> configuration, the Spark drivers for the development endpoint will run on 4 vCPU, 16 GB of memory, and a 64 GB disk. </p>
pub fn set_worker_type(
mut self,
input: std::option::Option<crate::model::WorkerType>,
) -> Self {
self.worker_type = input;
self
}
/// <p>Glue version determines the versions of Apache Spark and Python that Glue supports. The Python version indicates the version supported for running your ETL scripts on development endpoints. </p>
/// <p>For more information about the available Glue versions and corresponding Spark and Python versions, see <a href="https://docs.aws.amazon.com/glue/latest/dg/add-job.html">Glue version</a> in the developer guide.</p>
/// <p>Development endpoints that are created without specifying a Glue version default to Glue 0.9.</p>
/// <p>You can specify a version of Python support for development endpoints by using the <code>Arguments</code> parameter in the <code>CreateDevEndpoint</code> or <code>UpdateDevEndpoint</code> APIs. If no arguments are provided, the version defaults to Python 2.</p>
pub fn glue_version(mut self, input: impl Into<std::string::String>) -> Self {
self.glue_version = Some(input.into());
self
}
/// <p>Glue version determines the versions of Apache Spark and Python that Glue supports. The Python version indicates the version supported for running your ETL scripts on development endpoints. </p>
/// <p>For more information about the available Glue versions and corresponding Spark and Python versions, see <a href="https://docs.aws.amazon.com/glue/latest/dg/add-job.html">Glue version</a> in the developer guide.</p>
/// <p>Development endpoints that are created without specifying a Glue version default to Glue 0.9.</p>
/// <p>You can specify a version of Python support for development endpoints by using the <code>Arguments</code> parameter in the <code>CreateDevEndpoint</code> or <code>UpdateDevEndpoint</code> APIs. If no arguments are provided, the version defaults to Python 2.</p>
pub fn set_glue_version(mut self, input: std::option::Option<std::string::String>) -> Self {
self.glue_version = input;
self
}
/// <p>The number of workers of a defined <code>workerType</code> that are allocated to the development endpoint.</p>
/// <p>The maximum number of workers you can define are 299 for <code>G.1X</code>, and 149 for <code>G.2X</code>. </p>
pub fn number_of_workers(mut self, input: i32) -> Self {
self.number_of_workers = Some(input);
self
}
/// <p>The number of workers of a defined <code>workerType</code> that are allocated to the development endpoint.</p>
/// <p>The maximum number of workers you can define are 299 for <code>G.1X</code>, and 149 for <code>G.2X</code>. </p>
pub fn set_number_of_workers(mut self, input: std::option::Option<i32>) -> Self {
self.number_of_workers = input;
self
}
/// <p>The paths to one or more Python libraries in an Amazon S3 bucket that should be loaded in your <code>DevEndpoint</code>. Multiple values must be complete paths separated by a comma.</p> <note>
/// <p>You can only use pure Python libraries with a <code>DevEndpoint</code>. Libraries that rely on C extensions, such as the <a href="http://pandas.pydata.org/">pandas</a> Python data analysis library, are not yet supported.</p>
/// </note>
pub fn extra_python_libs_s3_path(mut self, input: impl Into<std::string::String>) -> Self {
self.extra_python_libs_s3_path = Some(input.into());
self
}
/// <p>The paths to one or more Python libraries in an Amazon S3 bucket that should be loaded in your <code>DevEndpoint</code>. Multiple values must be complete paths separated by a comma.</p> <note>
/// <p>You can only use pure Python libraries with a <code>DevEndpoint</code>. Libraries that rely on C extensions, such as the <a href="http://pandas.pydata.org/">pandas</a> Python data analysis library, are not yet supported.</p>
/// </note>
pub fn set_extra_python_libs_s3_path(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.extra_python_libs_s3_path = input;
self
}
/// <p>The path to one or more Java <code>.jar</code> files in an S3 bucket that should be loaded in your <code>DevEndpoint</code>.</p>
pub fn extra_jars_s3_path(mut self, input: impl Into<std::string::String>) -> Self {
self.extra_jars_s3_path = Some(input.into());
self
}
/// <p>The path to one or more Java <code>.jar</code> files in an S3 bucket that should be loaded in your <code>DevEndpoint</code>.</p>
pub fn set_extra_jars_s3_path(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.extra_jars_s3_path = input;
self
}
/// <p>The name of the <code>SecurityConfiguration</code> structure to be used with this <code>DevEndpoint</code>.</p>
pub fn security_configuration(mut self, input: impl Into<std::string::String>) -> Self {
self.security_configuration = Some(input.into());
self
}
/// <p>The name of the <code>SecurityConfiguration</code> structure to be used with this <code>DevEndpoint</code>.</p>
pub fn set_security_configuration(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.security_configuration = input;
self
}
/// Adds a key-value pair to `tags`.
///
/// To override the contents of this collection use [`set_tags`](Self::set_tags).
///
/// <p>The tags to use with this DevEndpoint. You may use tags to limit access to the DevEndpoint. For more information about tags in Glue, see <a href="https://docs.aws.amazon.com/glue/latest/dg/monitor-tags.html">Amazon Web Services Tags in Glue</a> in the developer guide.</p>
pub fn tags(
mut self,
k: impl Into<std::string::String>,
v: impl Into<std::string::String>,
) -> Self {
let mut hash_map = self.tags.unwrap_or_default();
hash_map.insert(k.into(), v.into());
self.tags = Some(hash_map);
self
}
/// <p>The tags to use with this DevEndpoint. You may use tags to limit access to the DevEndpoint. For more information about tags in Glue, see <a href="https://docs.aws.amazon.com/glue/latest/dg/monitor-tags.html">Amazon Web Services Tags in Glue</a> in the developer guide.</p>
pub fn set_tags(
mut self,
input: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
) -> Self {
self.tags = input;
self
}
/// Adds a key-value pair to `arguments`.
///
/// To override the contents of this collection use [`set_arguments`](Self::set_arguments).
///
/// <p>A map of arguments used to configure the <code>DevEndpoint</code>.</p>
pub fn arguments(
mut self,
k: impl Into<std::string::String>,
v: impl Into<std::string::String>,
) -> Self {
let mut hash_map = self.arguments.unwrap_or_default();
hash_map.insert(k.into(), v.into());
self.arguments = Some(hash_map);
self
}
/// <p>A map of arguments used to configure the <code>DevEndpoint</code>.</p>
pub fn set_arguments(
mut self,
input: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
) -> Self {
self.arguments = input;
self
}
/// Consumes the builder and constructs a [`CreateDevEndpointInput`](crate::input::CreateDevEndpointInput).
pub fn build(
self,
) -> Result<
crate::input::CreateDevEndpointInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::CreateDevEndpointInput {
endpoint_name: self.endpoint_name,
role_arn: self.role_arn,
security_group_ids: self.security_group_ids,
subnet_id: self.subnet_id,
public_key: self.public_key,
public_keys: self.public_keys,
number_of_nodes: self.number_of_nodes.unwrap_or_default(),
worker_type: self.worker_type,
glue_version: self.glue_version,
number_of_workers: self.number_of_workers,
extra_python_libs_s3_path: self.extra_python_libs_s3_path,
extra_jars_s3_path: self.extra_jars_s3_path,
security_configuration: self.security_configuration,
tags: self.tags,
arguments: self.arguments,
})
}
}
}
impl CreateDevEndpointInput {
/// Consumes the builder and constructs an Operation<[`CreateDevEndpoint`](crate::operation::CreateDevEndpoint)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::CreateDevEndpoint,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::CreateDevEndpointInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::CreateDevEndpointInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.CreateDevEndpoint",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_create_dev_endpoint(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::CreateDevEndpoint::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"CreateDevEndpoint",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`CreateDevEndpointInput`](crate::input::CreateDevEndpointInput).
pub fn builder() -> crate::input::create_dev_endpoint_input::Builder {
crate::input::create_dev_endpoint_input::Builder::default()
}
}
/// See [`CreateJobInput`](crate::input::CreateJobInput).
pub mod create_job_input {
/// A builder for [`CreateJobInput`](crate::input::CreateJobInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default)]
pub struct Builder {
pub(crate) name: std::option::Option<std::string::String>,
pub(crate) description: std::option::Option<std::string::String>,
pub(crate) log_uri: std::option::Option<std::string::String>,
pub(crate) role: std::option::Option<std::string::String>,
pub(crate) execution_property: std::option::Option<crate::model::ExecutionProperty>,
pub(crate) command: std::option::Option<crate::model::JobCommand>,
pub(crate) default_arguments: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
pub(crate) non_overridable_arguments: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
pub(crate) connections: std::option::Option<crate::model::ConnectionsList>,
pub(crate) max_retries: std::option::Option<i32>,
pub(crate) allocated_capacity: std::option::Option<i32>,
pub(crate) timeout: std::option::Option<i32>,
pub(crate) max_capacity: std::option::Option<f64>,
pub(crate) security_configuration: std::option::Option<std::string::String>,
pub(crate) tags: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
pub(crate) notification_property: std::option::Option<crate::model::NotificationProperty>,
pub(crate) glue_version: std::option::Option<std::string::String>,
pub(crate) number_of_workers: std::option::Option<i32>,
pub(crate) worker_type: std::option::Option<crate::model::WorkerType>,
pub(crate) code_gen_configuration_nodes: std::option::Option<
std::collections::HashMap<std::string::String, crate::model::CodeGenConfigurationNode>,
>,
pub(crate) execution_class: std::option::Option<crate::model::ExecutionClass>,
pub(crate) source_control_details: std::option::Option<crate::model::SourceControlDetails>,
}
impl Builder {
/// <p>The name you assign to this job definition. It must be unique in your account.</p>
pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
self.name = Some(input.into());
self
}
/// <p>The name you assign to this job definition. It must be unique in your account.</p>
pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.name = input;
self
}
/// <p>Description of the job being defined.</p>
pub fn description(mut self, input: impl Into<std::string::String>) -> Self {
self.description = Some(input.into());
self
}
/// <p>Description of the job being defined.</p>
pub fn set_description(mut self, input: std::option::Option<std::string::String>) -> Self {
self.description = input;
self
}
/// <p>This field is reserved for future use.</p>
pub fn log_uri(mut self, input: impl Into<std::string::String>) -> Self {
self.log_uri = Some(input.into());
self
}
/// <p>This field is reserved for future use.</p>
pub fn set_log_uri(mut self, input: std::option::Option<std::string::String>) -> Self {
self.log_uri = input;
self
}
/// <p>The name or Amazon Resource Name (ARN) of the IAM role associated with this job.</p>
pub fn role(mut self, input: impl Into<std::string::String>) -> Self {
self.role = Some(input.into());
self
}
/// <p>The name or Amazon Resource Name (ARN) of the IAM role associated with this job.</p>
pub fn set_role(mut self, input: std::option::Option<std::string::String>) -> Self {
self.role = input;
self
}
/// <p>An <code>ExecutionProperty</code> specifying the maximum number of concurrent runs allowed for this job.</p>
pub fn execution_property(mut self, input: crate::model::ExecutionProperty) -> Self {
self.execution_property = Some(input);
self
}
/// <p>An <code>ExecutionProperty</code> specifying the maximum number of concurrent runs allowed for this job.</p>
pub fn set_execution_property(
mut self,
input: std::option::Option<crate::model::ExecutionProperty>,
) -> Self {
self.execution_property = input;
self
}
/// <p>The <code>JobCommand</code> that runs this job.</p>
pub fn command(mut self, input: crate::model::JobCommand) -> Self {
self.command = Some(input);
self
}
/// <p>The <code>JobCommand</code> that runs this job.</p>
pub fn set_command(mut self, input: std::option::Option<crate::model::JobCommand>) -> Self {
self.command = input;
self
}
/// Adds a key-value pair to `default_arguments`.
///
/// To override the contents of this collection use [`set_default_arguments`](Self::set_default_arguments).
///
/// <p>The default arguments for this job.</p>
/// <p>You can specify arguments here that your own job-execution script consumes, as well as arguments that Glue itself consumes.</p>
/// <p>Job arguments may be logged. Do not pass plaintext secrets as arguments. Retrieve secrets from a Glue Connection, Secrets Manager or other secret management mechanism if you intend to keep them within the Job. </p>
/// <p>For information about how to specify and consume your own Job arguments, see the <a href="https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-python-calling.html">Calling Glue APIs in Python</a> topic in the developer guide.</p>
/// <p>For information about the key-value pairs that Glue consumes to set up your job, see the <a href="https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html">Special Parameters Used by Glue</a> topic in the developer guide.</p>
pub fn default_arguments(
mut self,
k: impl Into<std::string::String>,
v: impl Into<std::string::String>,
) -> Self {
let mut hash_map = self.default_arguments.unwrap_or_default();
hash_map.insert(k.into(), v.into());
self.default_arguments = Some(hash_map);
self
}
/// <p>The default arguments for this job.</p>
/// <p>You can specify arguments here that your own job-execution script consumes, as well as arguments that Glue itself consumes.</p>
/// <p>Job arguments may be logged. Do not pass plaintext secrets as arguments. Retrieve secrets from a Glue Connection, Secrets Manager or other secret management mechanism if you intend to keep them within the Job. </p>
/// <p>For information about how to specify and consume your own Job arguments, see the <a href="https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-python-calling.html">Calling Glue APIs in Python</a> topic in the developer guide.</p>
/// <p>For information about the key-value pairs that Glue consumes to set up your job, see the <a href="https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html">Special Parameters Used by Glue</a> topic in the developer guide.</p>
pub fn set_default_arguments(
mut self,
input: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
) -> Self {
self.default_arguments = input;
self
}
/// Adds a key-value pair to `non_overridable_arguments`.
///
/// To override the contents of this collection use [`set_non_overridable_arguments`](Self::set_non_overridable_arguments).
///
/// <p>Non-overridable arguments for this job, specified as name-value pairs.</p>
pub fn non_overridable_arguments(
mut self,
k: impl Into<std::string::String>,
v: impl Into<std::string::String>,
) -> Self {
let mut hash_map = self.non_overridable_arguments.unwrap_or_default();
hash_map.insert(k.into(), v.into());
self.non_overridable_arguments = Some(hash_map);
self
}
/// <p>Non-overridable arguments for this job, specified as name-value pairs.</p>
pub fn set_non_overridable_arguments(
mut self,
input: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
) -> Self {
self.non_overridable_arguments = input;
self
}
/// <p>The connections used for this job.</p>
pub fn connections(mut self, input: crate::model::ConnectionsList) -> Self {
self.connections = Some(input);
self
}
/// <p>The connections used for this job.</p>
pub fn set_connections(
mut self,
input: std::option::Option<crate::model::ConnectionsList>,
) -> Self {
self.connections = input;
self
}
/// <p>The maximum number of times to retry this job if it fails.</p>
pub fn max_retries(mut self, input: i32) -> Self {
self.max_retries = Some(input);
self
}
/// <p>The maximum number of times to retry this job if it fails.</p>
pub fn set_max_retries(mut self, input: std::option::Option<i32>) -> Self {
self.max_retries = input;
self
}
/// <p>This parameter is deprecated. Use <code>MaxCapacity</code> instead.</p>
/// <p>The number of Glue data processing units (DPUs) to allocate to this Job. You can allocate a minimum of 2 DPUs; the default is 10. A DPU is a relative measure of processing power that consists of 4 vCPUs of compute capacity and 16 GB of memory. For more information, see the <a href="https://aws.amazon.com/glue/pricing/">Glue pricing page</a>.</p>
#[deprecated(note = "This property is deprecated, use MaxCapacity instead.")]
pub fn allocated_capacity(mut self, input: i32) -> Self {
self.allocated_capacity = Some(input);
self
}
/// <p>This parameter is deprecated. Use <code>MaxCapacity</code> instead.</p>
/// <p>The number of Glue data processing units (DPUs) to allocate to this Job. You can allocate a minimum of 2 DPUs; the default is 10. A DPU is a relative measure of processing power that consists of 4 vCPUs of compute capacity and 16 GB of memory. For more information, see the <a href="https://aws.amazon.com/glue/pricing/">Glue pricing page</a>.</p>
#[deprecated(note = "This property is deprecated, use MaxCapacity instead.")]
pub fn set_allocated_capacity(mut self, input: std::option::Option<i32>) -> Self {
self.allocated_capacity = input;
self
}
/// <p>The job timeout in minutes. This is the maximum time that a job run can consume resources before it is terminated and enters <code>TIMEOUT</code> status. The default is 2,880 minutes (48 hours).</p>
pub fn timeout(mut self, input: i32) -> Self {
self.timeout = Some(input);
self
}
/// <p>The job timeout in minutes. This is the maximum time that a job run can consume resources before it is terminated and enters <code>TIMEOUT</code> status. The default is 2,880 minutes (48 hours).</p>
pub fn set_timeout(mut self, input: std::option::Option<i32>) -> Self {
self.timeout = input;
self
}
/// <p>For Glue version 1.0 or earlier jobs, using the standard worker type, the number of Glue data processing units (DPUs) that can be allocated when this job runs. A DPU is a relative measure of processing power that consists of 4 vCPUs of compute capacity and 16 GB of memory. For more information, see the <a href="https://aws.amazon.com/glue/pricing/">Glue pricing page</a>.</p>
/// <p>Do not set <code>Max Capacity</code> if using <code>WorkerType</code> and <code>NumberOfWorkers</code>.</p>
/// <p>The value that can be allocated for <code>MaxCapacity</code> depends on whether you are running a Python shell job or an Apache Spark ETL job:</p>
/// <ul>
/// <li> <p>When you specify a Python shell job (<code>JobCommand.Name</code>="pythonshell"), you can allocate either 0.0625 or 1 DPU. The default is 0.0625 DPU.</p> </li>
/// <li> <p>When you specify an Apache Spark ETL job (<code>JobCommand.Name</code>="glueetl") or Apache Spark streaming ETL job (<code>JobCommand.Name</code>="gluestreaming"), you can allocate a minimum of 2 DPUs. The default is 10 DPUs. This job type cannot have a fractional DPU allocation.</p> </li>
/// </ul>
/// <p>For Glue version 2.0 jobs, you cannot instead specify a <code>Maximum capacity</code>. Instead, you should specify a <code>Worker type</code> and the <code>Number of workers</code>.</p>
pub fn max_capacity(mut self, input: f64) -> Self {
self.max_capacity = Some(input);
self
}
/// <p>For Glue version 1.0 or earlier jobs, using the standard worker type, the number of Glue data processing units (DPUs) that can be allocated when this job runs. A DPU is a relative measure of processing power that consists of 4 vCPUs of compute capacity and 16 GB of memory. For more information, see the <a href="https://aws.amazon.com/glue/pricing/">Glue pricing page</a>.</p>
/// <p>Do not set <code>Max Capacity</code> if using <code>WorkerType</code> and <code>NumberOfWorkers</code>.</p>
/// <p>The value that can be allocated for <code>MaxCapacity</code> depends on whether you are running a Python shell job or an Apache Spark ETL job:</p>
/// <ul>
/// <li> <p>When you specify a Python shell job (<code>JobCommand.Name</code>="pythonshell"), you can allocate either 0.0625 or 1 DPU. The default is 0.0625 DPU.</p> </li>
/// <li> <p>When you specify an Apache Spark ETL job (<code>JobCommand.Name</code>="glueetl") or Apache Spark streaming ETL job (<code>JobCommand.Name</code>="gluestreaming"), you can allocate a minimum of 2 DPUs. The default is 10 DPUs. This job type cannot have a fractional DPU allocation.</p> </li>
/// </ul>
/// <p>For Glue version 2.0 jobs, you cannot instead specify a <code>Maximum capacity</code>. Instead, you should specify a <code>Worker type</code> and the <code>Number of workers</code>.</p>
pub fn set_max_capacity(mut self, input: std::option::Option<f64>) -> Self {
self.max_capacity = input;
self
}
/// <p>The name of the <code>SecurityConfiguration</code> structure to be used with this job.</p>
pub fn security_configuration(mut self, input: impl Into<std::string::String>) -> Self {
self.security_configuration = Some(input.into());
self
}
/// <p>The name of the <code>SecurityConfiguration</code> structure to be used with this job.</p>
pub fn set_security_configuration(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.security_configuration = input;
self
}
/// Adds a key-value pair to `tags`.
///
/// To override the contents of this collection use [`set_tags`](Self::set_tags).
///
/// <p>The tags to use with this job. You may use tags to limit access to the job. For more information about tags in Glue, see <a href="https://docs.aws.amazon.com/glue/latest/dg/monitor-tags.html">Amazon Web Services Tags in Glue</a> in the developer guide.</p>
pub fn tags(
mut self,
k: impl Into<std::string::String>,
v: impl Into<std::string::String>,
) -> Self {
let mut hash_map = self.tags.unwrap_or_default();
hash_map.insert(k.into(), v.into());
self.tags = Some(hash_map);
self
}
/// <p>The tags to use with this job. You may use tags to limit access to the job. For more information about tags in Glue, see <a href="https://docs.aws.amazon.com/glue/latest/dg/monitor-tags.html">Amazon Web Services Tags in Glue</a> in the developer guide.</p>
pub fn set_tags(
mut self,
input: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
) -> Self {
self.tags = input;
self
}
/// <p>Specifies configuration properties of a job notification.</p>
pub fn notification_property(mut self, input: crate::model::NotificationProperty) -> Self {
self.notification_property = Some(input);
self
}
/// <p>Specifies configuration properties of a job notification.</p>
pub fn set_notification_property(
mut self,
input: std::option::Option<crate::model::NotificationProperty>,
) -> Self {
self.notification_property = input;
self
}
/// <p>Glue version determines the versions of Apache Spark and Python that Glue supports. The Python version indicates the version supported for jobs of type Spark. </p>
/// <p>For more information about the available Glue versions and corresponding Spark and Python versions, see <a href="https://docs.aws.amazon.com/glue/latest/dg/add-job.html">Glue version</a> in the developer guide.</p>
/// <p>Jobs that are created without specifying a Glue version default to Glue 0.9.</p>
pub fn glue_version(mut self, input: impl Into<std::string::String>) -> Self {
self.glue_version = Some(input.into());
self
}
/// <p>Glue version determines the versions of Apache Spark and Python that Glue supports. The Python version indicates the version supported for jobs of type Spark. </p>
/// <p>For more information about the available Glue versions and corresponding Spark and Python versions, see <a href="https://docs.aws.amazon.com/glue/latest/dg/add-job.html">Glue version</a> in the developer guide.</p>
/// <p>Jobs that are created without specifying a Glue version default to Glue 0.9.</p>
pub fn set_glue_version(mut self, input: std::option::Option<std::string::String>) -> Self {
self.glue_version = input;
self
}
/// <p>The number of workers of a defined <code>workerType</code> that are allocated when a job runs.</p>
pub fn number_of_workers(mut self, input: i32) -> Self {
self.number_of_workers = Some(input);
self
}
/// <p>The number of workers of a defined <code>workerType</code> that are allocated when a job runs.</p>
pub fn set_number_of_workers(mut self, input: std::option::Option<i32>) -> Self {
self.number_of_workers = input;
self
}
/// <p>The type of predefined worker that is allocated when a job runs. Accepts a value of Standard, G.1X, G.2X, or G.025X.</p>
/// <ul>
/// <li> <p>For the <code>Standard</code> worker type, each worker provides 4 vCPU, 16 GB of memory and a 50GB disk, and 2 executors per worker.</p> </li>
/// <li> <p>For the <code>G.1X</code> worker type, each worker maps to 1 DPU (4 vCPU, 16 GB of memory, 64 GB disk), and provides 1 executor per worker. We recommend this worker type for memory-intensive jobs.</p> </li>
/// <li> <p>For the <code>G.2X</code> worker type, each worker maps to 2 DPU (8 vCPU, 32 GB of memory, 128 GB disk), and provides 1 executor per worker. We recommend this worker type for memory-intensive jobs.</p> </li>
/// <li> <p>For the <code>G.025X</code> worker type, each worker maps to 0.25 DPU (2 vCPU, 4 GB of memory, 64 GB disk), and provides 1 executor per worker. We recommend this worker type for low volume streaming jobs. This worker type is only available for Glue version 3.0 streaming jobs.</p> </li>
/// </ul>
pub fn worker_type(mut self, input: crate::model::WorkerType) -> Self {
self.worker_type = Some(input);
self
}
/// <p>The type of predefined worker that is allocated when a job runs. Accepts a value of Standard, G.1X, G.2X, or G.025X.</p>
/// <ul>
/// <li> <p>For the <code>Standard</code> worker type, each worker provides 4 vCPU, 16 GB of memory and a 50GB disk, and 2 executors per worker.</p> </li>
/// <li> <p>For the <code>G.1X</code> worker type, each worker maps to 1 DPU (4 vCPU, 16 GB of memory, 64 GB disk), and provides 1 executor per worker. We recommend this worker type for memory-intensive jobs.</p> </li>
/// <li> <p>For the <code>G.2X</code> worker type, each worker maps to 2 DPU (8 vCPU, 32 GB of memory, 128 GB disk), and provides 1 executor per worker. We recommend this worker type for memory-intensive jobs.</p> </li>
/// <li> <p>For the <code>G.025X</code> worker type, each worker maps to 0.25 DPU (2 vCPU, 4 GB of memory, 64 GB disk), and provides 1 executor per worker. We recommend this worker type for low volume streaming jobs. This worker type is only available for Glue version 3.0 streaming jobs.</p> </li>
/// </ul>
pub fn set_worker_type(
mut self,
input: std::option::Option<crate::model::WorkerType>,
) -> Self {
self.worker_type = input;
self
}
/// Adds a key-value pair to `code_gen_configuration_nodes`.
///
/// To override the contents of this collection use [`set_code_gen_configuration_nodes`](Self::set_code_gen_configuration_nodes).
///
/// <p>The representation of a directed acyclic graph on which both the Glue Studio visual component and Glue Studio code generation is based.</p>
pub fn code_gen_configuration_nodes(
mut self,
k: impl Into<std::string::String>,
v: crate::model::CodeGenConfigurationNode,
) -> Self {
let mut hash_map = self.code_gen_configuration_nodes.unwrap_or_default();
hash_map.insert(k.into(), v);
self.code_gen_configuration_nodes = Some(hash_map);
self
}
/// <p>The representation of a directed acyclic graph on which both the Glue Studio visual component and Glue Studio code generation is based.</p>
pub fn set_code_gen_configuration_nodes(
mut self,
input: std::option::Option<
std::collections::HashMap<
std::string::String,
crate::model::CodeGenConfigurationNode,
>,
>,
) -> Self {
self.code_gen_configuration_nodes = input;
self
}
/// <p>Indicates whether the job is run with a standard or flexible execution class. The standard execution-class is ideal for time-sensitive workloads that require fast job startup and dedicated resources.</p>
/// <p>The flexible execution class is appropriate for time-insensitive jobs whose start and completion times may vary. </p>
/// <p>Only jobs with Glue version 3.0 and above and command type <code>glueetl</code> will be allowed to set <code>ExecutionClass</code> to <code>FLEX</code>. The flexible execution class is available for Spark jobs.</p>
pub fn execution_class(mut self, input: crate::model::ExecutionClass) -> Self {
self.execution_class = Some(input);
self
}
/// <p>Indicates whether the job is run with a standard or flexible execution class. The standard execution-class is ideal for time-sensitive workloads that require fast job startup and dedicated resources.</p>
/// <p>The flexible execution class is appropriate for time-insensitive jobs whose start and completion times may vary. </p>
/// <p>Only jobs with Glue version 3.0 and above and command type <code>glueetl</code> will be allowed to set <code>ExecutionClass</code> to <code>FLEX</code>. The flexible execution class is available for Spark jobs.</p>
pub fn set_execution_class(
mut self,
input: std::option::Option<crate::model::ExecutionClass>,
) -> Self {
self.execution_class = input;
self
}
/// <p>The details for a source control configuration for a job, allowing synchronization of job artifacts to or from a remote repository.</p>
pub fn source_control_details(mut self, input: crate::model::SourceControlDetails) -> Self {
self.source_control_details = Some(input);
self
}
/// <p>The details for a source control configuration for a job, allowing synchronization of job artifacts to or from a remote repository.</p>
pub fn set_source_control_details(
mut self,
input: std::option::Option<crate::model::SourceControlDetails>,
) -> Self {
self.source_control_details = input;
self
}
/// Consumes the builder and constructs a [`CreateJobInput`](crate::input::CreateJobInput).
pub fn build(
self,
) -> Result<crate::input::CreateJobInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::CreateJobInput {
name: self.name,
description: self.description,
log_uri: self.log_uri,
role: self.role,
execution_property: self.execution_property,
command: self.command,
default_arguments: self.default_arguments,
non_overridable_arguments: self.non_overridable_arguments,
connections: self.connections,
max_retries: self.max_retries.unwrap_or_default(),
allocated_capacity: self.allocated_capacity.unwrap_or_default(),
timeout: self.timeout,
max_capacity: self.max_capacity,
security_configuration: self.security_configuration,
tags: self.tags,
notification_property: self.notification_property,
glue_version: self.glue_version,
number_of_workers: self.number_of_workers,
worker_type: self.worker_type,
code_gen_configuration_nodes: self.code_gen_configuration_nodes,
execution_class: self.execution_class,
source_control_details: self.source_control_details,
})
}
}
impl std::fmt::Debug for Builder {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("Builder");
formatter.field("name", &self.name);
formatter.field("description", &self.description);
formatter.field("log_uri", &self.log_uri);
formatter.field("role", &self.role);
formatter.field("execution_property", &self.execution_property);
formatter.field("command", &self.command);
formatter.field("default_arguments", &self.default_arguments);
formatter.field("non_overridable_arguments", &self.non_overridable_arguments);
formatter.field("connections", &self.connections);
formatter.field("max_retries", &self.max_retries);
formatter.field("allocated_capacity", &self.allocated_capacity);
formatter.field("timeout", &self.timeout);
formatter.field("max_capacity", &self.max_capacity);
formatter.field("security_configuration", &self.security_configuration);
formatter.field("tags", &self.tags);
formatter.field("notification_property", &self.notification_property);
formatter.field("glue_version", &self.glue_version);
formatter.field("number_of_workers", &self.number_of_workers);
formatter.field("worker_type", &self.worker_type);
formatter.field(
"code_gen_configuration_nodes",
&"*** Sensitive Data Redacted ***",
);
formatter.field("execution_class", &self.execution_class);
formatter.field("source_control_details", &self.source_control_details);
formatter.finish()
}
}
}
impl CreateJobInput {
/// Consumes the builder and constructs an Operation<[`CreateJob`](crate::operation::CreateJob)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::CreateJob,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::CreateJobInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::CreateJobInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.CreateJob",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_create_job(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op =
aws_smithy_http::operation::Operation::new(request, crate::operation::CreateJob::new())
.with_metadata(aws_smithy_http::operation::Metadata::new(
"CreateJob",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`CreateJobInput`](crate::input::CreateJobInput).
pub fn builder() -> crate::input::create_job_input::Builder {
crate::input::create_job_input::Builder::default()
}
}
/// See [`CreateMlTransformInput`](crate::input::CreateMlTransformInput).
pub mod create_ml_transform_input {
/// A builder for [`CreateMlTransformInput`](crate::input::CreateMlTransformInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) name: std::option::Option<std::string::String>,
pub(crate) description: std::option::Option<std::string::String>,
pub(crate) input_record_tables: std::option::Option<std::vec::Vec<crate::model::GlueTable>>,
pub(crate) parameters: std::option::Option<crate::model::TransformParameters>,
pub(crate) role: std::option::Option<std::string::String>,
pub(crate) glue_version: std::option::Option<std::string::String>,
pub(crate) max_capacity: std::option::Option<f64>,
pub(crate) worker_type: std::option::Option<crate::model::WorkerType>,
pub(crate) number_of_workers: std::option::Option<i32>,
pub(crate) timeout: std::option::Option<i32>,
pub(crate) max_retries: std::option::Option<i32>,
pub(crate) tags: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
pub(crate) transform_encryption: std::option::Option<crate::model::TransformEncryption>,
}
impl Builder {
/// <p>The unique name that you give the transform when you create it.</p>
pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
self.name = Some(input.into());
self
}
/// <p>The unique name that you give the transform when you create it.</p>
pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.name = input;
self
}
/// <p>A description of the machine learning transform that is being defined. The default is an empty string.</p>
pub fn description(mut self, input: impl Into<std::string::String>) -> Self {
self.description = Some(input.into());
self
}
/// <p>A description of the machine learning transform that is being defined. The default is an empty string.</p>
pub fn set_description(mut self, input: std::option::Option<std::string::String>) -> Self {
self.description = input;
self
}
/// Appends an item to `input_record_tables`.
///
/// To override the contents of this collection use [`set_input_record_tables`](Self::set_input_record_tables).
///
/// <p>A list of Glue table definitions used by the transform.</p>
pub fn input_record_tables(mut self, input: crate::model::GlueTable) -> Self {
let mut v = self.input_record_tables.unwrap_or_default();
v.push(input);
self.input_record_tables = Some(v);
self
}
/// <p>A list of Glue table definitions used by the transform.</p>
pub fn set_input_record_tables(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::GlueTable>>,
) -> Self {
self.input_record_tables = input;
self
}
/// <p>The algorithmic parameters that are specific to the transform type used. Conditionally dependent on the transform type.</p>
pub fn parameters(mut self, input: crate::model::TransformParameters) -> Self {
self.parameters = Some(input);
self
}
/// <p>The algorithmic parameters that are specific to the transform type used. Conditionally dependent on the transform type.</p>
pub fn set_parameters(
mut self,
input: std::option::Option<crate::model::TransformParameters>,
) -> Self {
self.parameters = input;
self
}
/// <p>The name or Amazon Resource Name (ARN) of the IAM role with the required permissions. The required permissions include both Glue service role permissions to Glue resources, and Amazon S3 permissions required by the transform. </p>
/// <ul>
/// <li> <p>This role needs Glue service role permissions to allow access to resources in Glue. See <a href="https://docs.aws.amazon.com/glue/latest/dg/attach-policy-iam-user.html">Attach a Policy to IAM Users That Access Glue</a>.</p> </li>
/// <li> <p>This role needs permission to your Amazon Simple Storage Service (Amazon S3) sources, targets, temporary directory, scripts, and any libraries used by the task run for this transform.</p> </li>
/// </ul>
pub fn role(mut self, input: impl Into<std::string::String>) -> Self {
self.role = Some(input.into());
self
}
/// <p>The name or Amazon Resource Name (ARN) of the IAM role with the required permissions. The required permissions include both Glue service role permissions to Glue resources, and Amazon S3 permissions required by the transform. </p>
/// <ul>
/// <li> <p>This role needs Glue service role permissions to allow access to resources in Glue. See <a href="https://docs.aws.amazon.com/glue/latest/dg/attach-policy-iam-user.html">Attach a Policy to IAM Users That Access Glue</a>.</p> </li>
/// <li> <p>This role needs permission to your Amazon Simple Storage Service (Amazon S3) sources, targets, temporary directory, scripts, and any libraries used by the task run for this transform.</p> </li>
/// </ul>
pub fn set_role(mut self, input: std::option::Option<std::string::String>) -> Self {
self.role = input;
self
}
/// <p>This value determines which version of Glue this machine learning transform is compatible with. Glue 1.0 is recommended for most customers. If the value is not set, the Glue compatibility defaults to Glue 0.9. For more information, see <a href="https://docs.aws.amazon.com/glue/latest/dg/release-notes.html#release-notes-versions">Glue Versions</a> in the developer guide.</p>
pub fn glue_version(mut self, input: impl Into<std::string::String>) -> Self {
self.glue_version = Some(input.into());
self
}
/// <p>This value determines which version of Glue this machine learning transform is compatible with. Glue 1.0 is recommended for most customers. If the value is not set, the Glue compatibility defaults to Glue 0.9. For more information, see <a href="https://docs.aws.amazon.com/glue/latest/dg/release-notes.html#release-notes-versions">Glue Versions</a> in the developer guide.</p>
pub fn set_glue_version(mut self, input: std::option::Option<std::string::String>) -> Self {
self.glue_version = input;
self
}
/// <p>The number of Glue data processing units (DPUs) that are allocated to task runs for this transform. You can allocate from 2 to 100 DPUs; the default is 10. A DPU is a relative measure of processing power that consists of 4 vCPUs of compute capacity and 16 GB of memory. For more information, see the <a href="https://aws.amazon.com/glue/pricing/">Glue pricing page</a>. </p>
/// <p> <code>MaxCapacity</code> is a mutually exclusive option with <code>NumberOfWorkers</code> and <code>WorkerType</code>.</p>
/// <ul>
/// <li> <p>If either <code>NumberOfWorkers</code> or <code>WorkerType</code> is set, then <code>MaxCapacity</code> cannot be set.</p> </li>
/// <li> <p>If <code>MaxCapacity</code> is set then neither <code>NumberOfWorkers</code> or <code>WorkerType</code> can be set.</p> </li>
/// <li> <p>If <code>WorkerType</code> is set, then <code>NumberOfWorkers</code> is required (and vice versa).</p> </li>
/// <li> <p> <code>MaxCapacity</code> and <code>NumberOfWorkers</code> must both be at least 1.</p> </li>
/// </ul>
/// <p>When the <code>WorkerType</code> field is set to a value other than <code>Standard</code>, the <code>MaxCapacity</code> field is set automatically and becomes read-only.</p>
/// <p>When the <code>WorkerType</code> field is set to a value other than <code>Standard</code>, the <code>MaxCapacity</code> field is set automatically and becomes read-only.</p>
pub fn max_capacity(mut self, input: f64) -> Self {
self.max_capacity = Some(input);
self
}
/// <p>The number of Glue data processing units (DPUs) that are allocated to task runs for this transform. You can allocate from 2 to 100 DPUs; the default is 10. A DPU is a relative measure of processing power that consists of 4 vCPUs of compute capacity and 16 GB of memory. For more information, see the <a href="https://aws.amazon.com/glue/pricing/">Glue pricing page</a>. </p>
/// <p> <code>MaxCapacity</code> is a mutually exclusive option with <code>NumberOfWorkers</code> and <code>WorkerType</code>.</p>
/// <ul>
/// <li> <p>If either <code>NumberOfWorkers</code> or <code>WorkerType</code> is set, then <code>MaxCapacity</code> cannot be set.</p> </li>
/// <li> <p>If <code>MaxCapacity</code> is set then neither <code>NumberOfWorkers</code> or <code>WorkerType</code> can be set.</p> </li>
/// <li> <p>If <code>WorkerType</code> is set, then <code>NumberOfWorkers</code> is required (and vice versa).</p> </li>
/// <li> <p> <code>MaxCapacity</code> and <code>NumberOfWorkers</code> must both be at least 1.</p> </li>
/// </ul>
/// <p>When the <code>WorkerType</code> field is set to a value other than <code>Standard</code>, the <code>MaxCapacity</code> field is set automatically and becomes read-only.</p>
/// <p>When the <code>WorkerType</code> field is set to a value other than <code>Standard</code>, the <code>MaxCapacity</code> field is set automatically and becomes read-only.</p>
pub fn set_max_capacity(mut self, input: std::option::Option<f64>) -> Self {
self.max_capacity = input;
self
}
/// <p>The type of predefined worker that is allocated when this task runs. Accepts a value of Standard, G.1X, or G.2X.</p>
/// <ul>
/// <li> <p>For the <code>Standard</code> worker type, each worker provides 4 vCPU, 16 GB of memory and a 50GB disk, and 2 executors per worker.</p> </li>
/// <li> <p>For the <code>G.1X</code> worker type, each worker provides 4 vCPU, 16 GB of memory and a 64GB disk, and 1 executor per worker.</p> </li>
/// <li> <p>For the <code>G.2X</code> worker type, each worker provides 8 vCPU, 32 GB of memory and a 128GB disk, and 1 executor per worker.</p> </li>
/// </ul>
/// <p> <code>MaxCapacity</code> is a mutually exclusive option with <code>NumberOfWorkers</code> and <code>WorkerType</code>.</p>
/// <ul>
/// <li> <p>If either <code>NumberOfWorkers</code> or <code>WorkerType</code> is set, then <code>MaxCapacity</code> cannot be set.</p> </li>
/// <li> <p>If <code>MaxCapacity</code> is set then neither <code>NumberOfWorkers</code> or <code>WorkerType</code> can be set.</p> </li>
/// <li> <p>If <code>WorkerType</code> is set, then <code>NumberOfWorkers</code> is required (and vice versa).</p> </li>
/// <li> <p> <code>MaxCapacity</code> and <code>NumberOfWorkers</code> must both be at least 1.</p> </li>
/// </ul>
pub fn worker_type(mut self, input: crate::model::WorkerType) -> Self {
self.worker_type = Some(input);
self
}
/// <p>The type of predefined worker that is allocated when this task runs. Accepts a value of Standard, G.1X, or G.2X.</p>
/// <ul>
/// <li> <p>For the <code>Standard</code> worker type, each worker provides 4 vCPU, 16 GB of memory and a 50GB disk, and 2 executors per worker.</p> </li>
/// <li> <p>For the <code>G.1X</code> worker type, each worker provides 4 vCPU, 16 GB of memory and a 64GB disk, and 1 executor per worker.</p> </li>
/// <li> <p>For the <code>G.2X</code> worker type, each worker provides 8 vCPU, 32 GB of memory and a 128GB disk, and 1 executor per worker.</p> </li>
/// </ul>
/// <p> <code>MaxCapacity</code> is a mutually exclusive option with <code>NumberOfWorkers</code> and <code>WorkerType</code>.</p>
/// <ul>
/// <li> <p>If either <code>NumberOfWorkers</code> or <code>WorkerType</code> is set, then <code>MaxCapacity</code> cannot be set.</p> </li>
/// <li> <p>If <code>MaxCapacity</code> is set then neither <code>NumberOfWorkers</code> or <code>WorkerType</code> can be set.</p> </li>
/// <li> <p>If <code>WorkerType</code> is set, then <code>NumberOfWorkers</code> is required (and vice versa).</p> </li>
/// <li> <p> <code>MaxCapacity</code> and <code>NumberOfWorkers</code> must both be at least 1.</p> </li>
/// </ul>
pub fn set_worker_type(
mut self,
input: std::option::Option<crate::model::WorkerType>,
) -> Self {
self.worker_type = input;
self
}
/// <p>The number of workers of a defined <code>workerType</code> that are allocated when this task runs.</p>
/// <p>If <code>WorkerType</code> is set, then <code>NumberOfWorkers</code> is required (and vice versa).</p>
pub fn number_of_workers(mut self, input: i32) -> Self {
self.number_of_workers = Some(input);
self
}
/// <p>The number of workers of a defined <code>workerType</code> that are allocated when this task runs.</p>
/// <p>If <code>WorkerType</code> is set, then <code>NumberOfWorkers</code> is required (and vice versa).</p>
pub fn set_number_of_workers(mut self, input: std::option::Option<i32>) -> Self {
self.number_of_workers = input;
self
}
/// <p>The timeout of the task run for this transform in minutes. This is the maximum time that a task run for this transform can consume resources before it is terminated and enters <code>TIMEOUT</code> status. The default is 2,880 minutes (48 hours).</p>
pub fn timeout(mut self, input: i32) -> Self {
self.timeout = Some(input);
self
}
/// <p>The timeout of the task run for this transform in minutes. This is the maximum time that a task run for this transform can consume resources before it is terminated and enters <code>TIMEOUT</code> status. The default is 2,880 minutes (48 hours).</p>
pub fn set_timeout(mut self, input: std::option::Option<i32>) -> Self {
self.timeout = input;
self
}
/// <p>The maximum number of times to retry a task for this transform after a task run fails.</p>
pub fn max_retries(mut self, input: i32) -> Self {
self.max_retries = Some(input);
self
}
/// <p>The maximum number of times to retry a task for this transform after a task run fails.</p>
pub fn set_max_retries(mut self, input: std::option::Option<i32>) -> Self {
self.max_retries = input;
self
}
/// Adds a key-value pair to `tags`.
///
/// To override the contents of this collection use [`set_tags`](Self::set_tags).
///
/// <p>The tags to use with this machine learning transform. You may use tags to limit access to the machine learning transform. For more information about tags in Glue, see <a href="https://docs.aws.amazon.com/glue/latest/dg/monitor-tags.html">Amazon Web Services Tags in Glue</a> in the developer guide.</p>
pub fn tags(
mut self,
k: impl Into<std::string::String>,
v: impl Into<std::string::String>,
) -> Self {
let mut hash_map = self.tags.unwrap_or_default();
hash_map.insert(k.into(), v.into());
self.tags = Some(hash_map);
self
}
/// <p>The tags to use with this machine learning transform. You may use tags to limit access to the machine learning transform. For more information about tags in Glue, see <a href="https://docs.aws.amazon.com/glue/latest/dg/monitor-tags.html">Amazon Web Services Tags in Glue</a> in the developer guide.</p>
pub fn set_tags(
mut self,
input: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
) -> Self {
self.tags = input;
self
}
/// <p>The encryption-at-rest settings of the transform that apply to accessing user data. Machine learning transforms can access user data encrypted in Amazon S3 using KMS.</p>
pub fn transform_encryption(mut self, input: crate::model::TransformEncryption) -> Self {
self.transform_encryption = Some(input);
self
}
/// <p>The encryption-at-rest settings of the transform that apply to accessing user data. Machine learning transforms can access user data encrypted in Amazon S3 using KMS.</p>
pub fn set_transform_encryption(
mut self,
input: std::option::Option<crate::model::TransformEncryption>,
) -> Self {
self.transform_encryption = input;
self
}
/// Consumes the builder and constructs a [`CreateMlTransformInput`](crate::input::CreateMlTransformInput).
pub fn build(
self,
) -> Result<
crate::input::CreateMlTransformInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::CreateMlTransformInput {
name: self.name,
description: self.description,
input_record_tables: self.input_record_tables,
parameters: self.parameters,
role: self.role,
glue_version: self.glue_version,
max_capacity: self.max_capacity,
worker_type: self.worker_type,
number_of_workers: self.number_of_workers,
timeout: self.timeout,
max_retries: self.max_retries,
tags: self.tags,
transform_encryption: self.transform_encryption,
})
}
}
}
impl CreateMlTransformInput {
/// Consumes the builder and constructs an Operation<[`CreateMLTransform`](crate::operation::CreateMLTransform)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::CreateMLTransform,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::CreateMlTransformInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::CreateMlTransformInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.CreateMLTransform",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_create_ml_transform(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::CreateMLTransform::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"CreateMLTransform",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`CreateMlTransformInput`](crate::input::CreateMlTransformInput).
pub fn builder() -> crate::input::create_ml_transform_input::Builder {
crate::input::create_ml_transform_input::Builder::default()
}
}
/// See [`CreatePartitionInput`](crate::input::CreatePartitionInput).
pub mod create_partition_input {
/// A builder for [`CreatePartitionInput`](crate::input::CreatePartitionInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) catalog_id: std::option::Option<std::string::String>,
pub(crate) database_name: std::option::Option<std::string::String>,
pub(crate) table_name: std::option::Option<std::string::String>,
pub(crate) partition_input: std::option::Option<crate::model::PartitionInput>,
}
impl Builder {
/// <p>The Amazon Web Services account ID of the catalog in which the partition is to be created.</p>
pub fn catalog_id(mut self, input: impl Into<std::string::String>) -> Self {
self.catalog_id = Some(input.into());
self
}
/// <p>The Amazon Web Services account ID of the catalog in which the partition is to be created.</p>
pub fn set_catalog_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.catalog_id = input;
self
}
/// <p>The name of the metadata database in which the partition is to be created.</p>
pub fn database_name(mut self, input: impl Into<std::string::String>) -> Self {
self.database_name = Some(input.into());
self
}
/// <p>The name of the metadata database in which the partition is to be created.</p>
pub fn set_database_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.database_name = input;
self
}
/// <p>The name of the metadata table in which the partition is to be created.</p>
pub fn table_name(mut self, input: impl Into<std::string::String>) -> Self {
self.table_name = Some(input.into());
self
}
/// <p>The name of the metadata table in which the partition is to be created.</p>
pub fn set_table_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.table_name = input;
self
}
/// <p>A <code>PartitionInput</code> structure defining the partition to be created.</p>
pub fn partition_input(mut self, input: crate::model::PartitionInput) -> Self {
self.partition_input = Some(input);
self
}
/// <p>A <code>PartitionInput</code> structure defining the partition to be created.</p>
pub fn set_partition_input(
mut self,
input: std::option::Option<crate::model::PartitionInput>,
) -> Self {
self.partition_input = input;
self
}
/// Consumes the builder and constructs a [`CreatePartitionInput`](crate::input::CreatePartitionInput).
pub fn build(
self,
) -> Result<crate::input::CreatePartitionInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::CreatePartitionInput {
catalog_id: self.catalog_id,
database_name: self.database_name,
table_name: self.table_name,
partition_input: self.partition_input,
})
}
}
}
impl CreatePartitionInput {
/// Consumes the builder and constructs an Operation<[`CreatePartition`](crate::operation::CreatePartition)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::CreatePartition,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::CreatePartitionInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::CreatePartitionInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.CreatePartition",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_create_partition(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::CreatePartition::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"CreatePartition",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`CreatePartitionInput`](crate::input::CreatePartitionInput).
pub fn builder() -> crate::input::create_partition_input::Builder {
crate::input::create_partition_input::Builder::default()
}
}
/// See [`CreatePartitionIndexInput`](crate::input::CreatePartitionIndexInput).
pub mod create_partition_index_input {
/// A builder for [`CreatePartitionIndexInput`](crate::input::CreatePartitionIndexInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) catalog_id: std::option::Option<std::string::String>,
pub(crate) database_name: std::option::Option<std::string::String>,
pub(crate) table_name: std::option::Option<std::string::String>,
pub(crate) partition_index: std::option::Option<crate::model::PartitionIndex>,
}
impl Builder {
/// <p>The catalog ID where the table resides.</p>
pub fn catalog_id(mut self, input: impl Into<std::string::String>) -> Self {
self.catalog_id = Some(input.into());
self
}
/// <p>The catalog ID where the table resides.</p>
pub fn set_catalog_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.catalog_id = input;
self
}
/// <p>Specifies the name of a database in which you want to create a partition index.</p>
pub fn database_name(mut self, input: impl Into<std::string::String>) -> Self {
self.database_name = Some(input.into());
self
}
/// <p>Specifies the name of a database in which you want to create a partition index.</p>
pub fn set_database_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.database_name = input;
self
}
/// <p>Specifies the name of a table in which you want to create a partition index.</p>
pub fn table_name(mut self, input: impl Into<std::string::String>) -> Self {
self.table_name = Some(input.into());
self
}
/// <p>Specifies the name of a table in which you want to create a partition index.</p>
pub fn set_table_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.table_name = input;
self
}
/// <p>Specifies a <code>PartitionIndex</code> structure to create a partition index in an existing table.</p>
pub fn partition_index(mut self, input: crate::model::PartitionIndex) -> Self {
self.partition_index = Some(input);
self
}
/// <p>Specifies a <code>PartitionIndex</code> structure to create a partition index in an existing table.</p>
pub fn set_partition_index(
mut self,
input: std::option::Option<crate::model::PartitionIndex>,
) -> Self {
self.partition_index = input;
self
}
/// Consumes the builder and constructs a [`CreatePartitionIndexInput`](crate::input::CreatePartitionIndexInput).
pub fn build(
self,
) -> Result<
crate::input::CreatePartitionIndexInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::CreatePartitionIndexInput {
catalog_id: self.catalog_id,
database_name: self.database_name,
table_name: self.table_name,
partition_index: self.partition_index,
})
}
}
}
impl CreatePartitionIndexInput {
/// Consumes the builder and constructs an Operation<[`CreatePartitionIndex`](crate::operation::CreatePartitionIndex)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::CreatePartitionIndex,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::CreatePartitionIndexInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::CreatePartitionIndexInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.CreatePartitionIndex",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_create_partition_index(
&self,
)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::CreatePartitionIndex::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"CreatePartitionIndex",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`CreatePartitionIndexInput`](crate::input::CreatePartitionIndexInput).
pub fn builder() -> crate::input::create_partition_index_input::Builder {
crate::input::create_partition_index_input::Builder::default()
}
}
/// See [`CreateRegistryInput`](crate::input::CreateRegistryInput).
pub mod create_registry_input {
/// A builder for [`CreateRegistryInput`](crate::input::CreateRegistryInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) registry_name: std::option::Option<std::string::String>,
pub(crate) description: std::option::Option<std::string::String>,
pub(crate) tags: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
}
impl Builder {
/// <p>Name of the registry to be created of max length of 255, and may only contain letters, numbers, hyphen, underscore, dollar sign, or hash mark. No whitespace.</p>
pub fn registry_name(mut self, input: impl Into<std::string::String>) -> Self {
self.registry_name = Some(input.into());
self
}
/// <p>Name of the registry to be created of max length of 255, and may only contain letters, numbers, hyphen, underscore, dollar sign, or hash mark. No whitespace.</p>
pub fn set_registry_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.registry_name = input;
self
}
/// <p>A description of the registry. If description is not provided, there will not be any default value for this.</p>
pub fn description(mut self, input: impl Into<std::string::String>) -> Self {
self.description = Some(input.into());
self
}
/// <p>A description of the registry. If description is not provided, there will not be any default value for this.</p>
pub fn set_description(mut self, input: std::option::Option<std::string::String>) -> Self {
self.description = input;
self
}
/// Adds a key-value pair to `tags`.
///
/// To override the contents of this collection use [`set_tags`](Self::set_tags).
///
/// <p>Amazon Web Services tags that contain a key value pair and may be searched by console, command line, or API.</p>
pub fn tags(
mut self,
k: impl Into<std::string::String>,
v: impl Into<std::string::String>,
) -> Self {
let mut hash_map = self.tags.unwrap_or_default();
hash_map.insert(k.into(), v.into());
self.tags = Some(hash_map);
self
}
/// <p>Amazon Web Services tags that contain a key value pair and may be searched by console, command line, or API.</p>
pub fn set_tags(
mut self,
input: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
) -> Self {
self.tags = input;
self
}
/// Consumes the builder and constructs a [`CreateRegistryInput`](crate::input::CreateRegistryInput).
pub fn build(
self,
) -> Result<crate::input::CreateRegistryInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::CreateRegistryInput {
registry_name: self.registry_name,
description: self.description,
tags: self.tags,
})
}
}
}
impl CreateRegistryInput {
/// Consumes the builder and constructs an Operation<[`CreateRegistry`](crate::operation::CreateRegistry)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::CreateRegistry,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::CreateRegistryInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::CreateRegistryInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.CreateRegistry",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_create_registry(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::CreateRegistry::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"CreateRegistry",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`CreateRegistryInput`](crate::input::CreateRegistryInput).
pub fn builder() -> crate::input::create_registry_input::Builder {
crate::input::create_registry_input::Builder::default()
}
}
/// See [`CreateSchemaInput`](crate::input::CreateSchemaInput).
pub mod create_schema_input {
/// A builder for [`CreateSchemaInput`](crate::input::CreateSchemaInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) registry_id: std::option::Option<crate::model::RegistryId>,
pub(crate) schema_name: std::option::Option<std::string::String>,
pub(crate) data_format: std::option::Option<crate::model::DataFormat>,
pub(crate) compatibility: std::option::Option<crate::model::Compatibility>,
pub(crate) description: std::option::Option<std::string::String>,
pub(crate) tags: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
pub(crate) schema_definition: std::option::Option<std::string::String>,
}
impl Builder {
/// <p> This is a wrapper shape to contain the registry identity fields. If this is not provided, the default registry will be used. The ARN format for the same will be: <code>arn:aws:glue:us-east-2:
/// <customer id>
/// :registry/default-registry:random-5-letter-id
/// </customer></code>.</p>
pub fn registry_id(mut self, input: crate::model::RegistryId) -> Self {
self.registry_id = Some(input);
self
}
/// <p> This is a wrapper shape to contain the registry identity fields. If this is not provided, the default registry will be used. The ARN format for the same will be: <code>arn:aws:glue:us-east-2:
/// <customer id>
/// :registry/default-registry:random-5-letter-id
/// </customer></code>.</p>
pub fn set_registry_id(
mut self,
input: std::option::Option<crate::model::RegistryId>,
) -> Self {
self.registry_id = input;
self
}
/// <p>Name of the schema to be created of max length of 255, and may only contain letters, numbers, hyphen, underscore, dollar sign, or hash mark. No whitespace.</p>
pub fn schema_name(mut self, input: impl Into<std::string::String>) -> Self {
self.schema_name = Some(input.into());
self
}
/// <p>Name of the schema to be created of max length of 255, and may only contain letters, numbers, hyphen, underscore, dollar sign, or hash mark. No whitespace.</p>
pub fn set_schema_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.schema_name = input;
self
}
/// <p>The data format of the schema definition. Currently <code>AVRO</code>, <code>JSON</code> and <code>PROTOBUF</code> are supported.</p>
pub fn data_format(mut self, input: crate::model::DataFormat) -> Self {
self.data_format = Some(input);
self
}
/// <p>The data format of the schema definition. Currently <code>AVRO</code>, <code>JSON</code> and <code>PROTOBUF</code> are supported.</p>
pub fn set_data_format(
mut self,
input: std::option::Option<crate::model::DataFormat>,
) -> Self {
self.data_format = input;
self
}
/// <p>The compatibility mode of the schema. The possible values are:</p>
/// <ul>
/// <li> <p> <i>NONE</i>: No compatibility mode applies. You can use this choice in development scenarios or if you do not know the compatibility mode that you want to apply to schemas. Any new version added will be accepted without undergoing a compatibility check.</p> </li>
/// <li> <p> <i>DISABLED</i>: This compatibility choice prevents versioning for a particular schema. You can use this choice to prevent future versioning of a schema.</p> </li>
/// <li> <p> <i>BACKWARD</i>: This compatibility choice is recommended as it allows data receivers to read both the current and one previous schema version. This means that for instance, a new schema version cannot drop data fields or change the type of these fields, so they can't be read by readers using the previous version.</p> </li>
/// <li> <p> <i>BACKWARD_ALL</i>: This compatibility choice allows data receivers to read both the current and all previous schema versions. You can use this choice when you need to delete fields or add optional fields, and check compatibility against all previous schema versions. </p> </li>
/// <li> <p> <i>FORWARD</i>: This compatibility choice allows data receivers to read both the current and one next schema version, but not necessarily later versions. You can use this choice when you need to add fields or delete optional fields, but only check compatibility against the last schema version.</p> </li>
/// <li> <p> <i>FORWARD_ALL</i>: This compatibility choice allows data receivers to read written by producers of any new registered schema. You can use this choice when you need to add fields or delete optional fields, and check compatibility against all previous schema versions.</p> </li>
/// <li> <p> <i>FULL</i>: This compatibility choice allows data receivers to read data written by producers using the previous or next version of the schema, but not necessarily earlier or later versions. You can use this choice when you need to add or remove optional fields, but only check compatibility against the last schema version.</p> </li>
/// <li> <p> <i>FULL_ALL</i>: This compatibility choice allows data receivers to read data written by producers using all previous schema versions. You can use this choice when you need to add or remove optional fields, and check compatibility against all previous schema versions.</p> </li>
/// </ul>
pub fn compatibility(mut self, input: crate::model::Compatibility) -> Self {
self.compatibility = Some(input);
self
}
/// <p>The compatibility mode of the schema. The possible values are:</p>
/// <ul>
/// <li> <p> <i>NONE</i>: No compatibility mode applies. You can use this choice in development scenarios or if you do not know the compatibility mode that you want to apply to schemas. Any new version added will be accepted without undergoing a compatibility check.</p> </li>
/// <li> <p> <i>DISABLED</i>: This compatibility choice prevents versioning for a particular schema. You can use this choice to prevent future versioning of a schema.</p> </li>
/// <li> <p> <i>BACKWARD</i>: This compatibility choice is recommended as it allows data receivers to read both the current and one previous schema version. This means that for instance, a new schema version cannot drop data fields or change the type of these fields, so they can't be read by readers using the previous version.</p> </li>
/// <li> <p> <i>BACKWARD_ALL</i>: This compatibility choice allows data receivers to read both the current and all previous schema versions. You can use this choice when you need to delete fields or add optional fields, and check compatibility against all previous schema versions. </p> </li>
/// <li> <p> <i>FORWARD</i>: This compatibility choice allows data receivers to read both the current and one next schema version, but not necessarily later versions. You can use this choice when you need to add fields or delete optional fields, but only check compatibility against the last schema version.</p> </li>
/// <li> <p> <i>FORWARD_ALL</i>: This compatibility choice allows data receivers to read written by producers of any new registered schema. You can use this choice when you need to add fields or delete optional fields, and check compatibility against all previous schema versions.</p> </li>
/// <li> <p> <i>FULL</i>: This compatibility choice allows data receivers to read data written by producers using the previous or next version of the schema, but not necessarily earlier or later versions. You can use this choice when you need to add or remove optional fields, but only check compatibility against the last schema version.</p> </li>
/// <li> <p> <i>FULL_ALL</i>: This compatibility choice allows data receivers to read data written by producers using all previous schema versions. You can use this choice when you need to add or remove optional fields, and check compatibility against all previous schema versions.</p> </li>
/// </ul>
pub fn set_compatibility(
mut self,
input: std::option::Option<crate::model::Compatibility>,
) -> Self {
self.compatibility = input;
self
}
/// <p>An optional description of the schema. If description is not provided, there will not be any automatic default value for this.</p>
pub fn description(mut self, input: impl Into<std::string::String>) -> Self {
self.description = Some(input.into());
self
}
/// <p>An optional description of the schema. If description is not provided, there will not be any automatic default value for this.</p>
pub fn set_description(mut self, input: std::option::Option<std::string::String>) -> Self {
self.description = input;
self
}
/// Adds a key-value pair to `tags`.
///
/// To override the contents of this collection use [`set_tags`](Self::set_tags).
///
/// <p>Amazon Web Services tags that contain a key value pair and may be searched by console, command line, or API. If specified, follows the Amazon Web Services tags-on-create pattern.</p>
pub fn tags(
mut self,
k: impl Into<std::string::String>,
v: impl Into<std::string::String>,
) -> Self {
let mut hash_map = self.tags.unwrap_or_default();
hash_map.insert(k.into(), v.into());
self.tags = Some(hash_map);
self
}
/// <p>Amazon Web Services tags that contain a key value pair and may be searched by console, command line, or API. If specified, follows the Amazon Web Services tags-on-create pattern.</p>
pub fn set_tags(
mut self,
input: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
) -> Self {
self.tags = input;
self
}
/// <p>The schema definition using the <code>DataFormat</code> setting for <code>SchemaName</code>.</p>
pub fn schema_definition(mut self, input: impl Into<std::string::String>) -> Self {
self.schema_definition = Some(input.into());
self
}
/// <p>The schema definition using the <code>DataFormat</code> setting for <code>SchemaName</code>.</p>
pub fn set_schema_definition(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.schema_definition = input;
self
}
/// Consumes the builder and constructs a [`CreateSchemaInput`](crate::input::CreateSchemaInput).
pub fn build(
self,
) -> Result<crate::input::CreateSchemaInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::CreateSchemaInput {
registry_id: self.registry_id,
schema_name: self.schema_name,
data_format: self.data_format,
compatibility: self.compatibility,
description: self.description,
tags: self.tags,
schema_definition: self.schema_definition,
})
}
}
}
impl CreateSchemaInput {
/// Consumes the builder and constructs an Operation<[`CreateSchema`](crate::operation::CreateSchema)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::CreateSchema,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::CreateSchemaInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::CreateSchemaInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.CreateSchema",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_create_schema(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::CreateSchema::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"CreateSchema",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`CreateSchemaInput`](crate::input::CreateSchemaInput).
pub fn builder() -> crate::input::create_schema_input::Builder {
crate::input::create_schema_input::Builder::default()
}
}
/// See [`CreateScriptInput`](crate::input::CreateScriptInput).
pub mod create_script_input {
/// A builder for [`CreateScriptInput`](crate::input::CreateScriptInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) dag_nodes: std::option::Option<std::vec::Vec<crate::model::CodeGenNode>>,
pub(crate) dag_edges: std::option::Option<std::vec::Vec<crate::model::CodeGenEdge>>,
pub(crate) language: std::option::Option<crate::model::Language>,
}
impl Builder {
/// Appends an item to `dag_nodes`.
///
/// To override the contents of this collection use [`set_dag_nodes`](Self::set_dag_nodes).
///
/// <p>A list of the nodes in the DAG.</p>
pub fn dag_nodes(mut self, input: crate::model::CodeGenNode) -> Self {
let mut v = self.dag_nodes.unwrap_or_default();
v.push(input);
self.dag_nodes = Some(v);
self
}
/// <p>A list of the nodes in the DAG.</p>
pub fn set_dag_nodes(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::CodeGenNode>>,
) -> Self {
self.dag_nodes = input;
self
}
/// Appends an item to `dag_edges`.
///
/// To override the contents of this collection use [`set_dag_edges`](Self::set_dag_edges).
///
/// <p>A list of the edges in the DAG.</p>
pub fn dag_edges(mut self, input: crate::model::CodeGenEdge) -> Self {
let mut v = self.dag_edges.unwrap_or_default();
v.push(input);
self.dag_edges = Some(v);
self
}
/// <p>A list of the edges in the DAG.</p>
pub fn set_dag_edges(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::CodeGenEdge>>,
) -> Self {
self.dag_edges = input;
self
}
/// <p>The programming language of the resulting code from the DAG.</p>
pub fn language(mut self, input: crate::model::Language) -> Self {
self.language = Some(input);
self
}
/// <p>The programming language of the resulting code from the DAG.</p>
pub fn set_language(mut self, input: std::option::Option<crate::model::Language>) -> Self {
self.language = input;
self
}
/// Consumes the builder and constructs a [`CreateScriptInput`](crate::input::CreateScriptInput).
pub fn build(
self,
) -> Result<crate::input::CreateScriptInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::CreateScriptInput {
dag_nodes: self.dag_nodes,
dag_edges: self.dag_edges,
language: self.language,
})
}
}
}
impl CreateScriptInput {
/// Consumes the builder and constructs an Operation<[`CreateScript`](crate::operation::CreateScript)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::CreateScript,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::CreateScriptInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::CreateScriptInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.CreateScript",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_create_script(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::CreateScript::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"CreateScript",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`CreateScriptInput`](crate::input::CreateScriptInput).
pub fn builder() -> crate::input::create_script_input::Builder {
crate::input::create_script_input::Builder::default()
}
}
/// See [`CreateSecurityConfigurationInput`](crate::input::CreateSecurityConfigurationInput).
pub mod create_security_configuration_input {
/// A builder for [`CreateSecurityConfigurationInput`](crate::input::CreateSecurityConfigurationInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) name: std::option::Option<std::string::String>,
pub(crate) encryption_configuration:
std::option::Option<crate::model::EncryptionConfiguration>,
}
impl Builder {
/// <p>The name for the new security configuration.</p>
pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
self.name = Some(input.into());
self
}
/// <p>The name for the new security configuration.</p>
pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.name = input;
self
}
/// <p>The encryption configuration for the new security configuration.</p>
pub fn encryption_configuration(
mut self,
input: crate::model::EncryptionConfiguration,
) -> Self {
self.encryption_configuration = Some(input);
self
}
/// <p>The encryption configuration for the new security configuration.</p>
pub fn set_encryption_configuration(
mut self,
input: std::option::Option<crate::model::EncryptionConfiguration>,
) -> Self {
self.encryption_configuration = input;
self
}
/// Consumes the builder and constructs a [`CreateSecurityConfigurationInput`](crate::input::CreateSecurityConfigurationInput).
pub fn build(
self,
) -> Result<
crate::input::CreateSecurityConfigurationInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::CreateSecurityConfigurationInput {
name: self.name,
encryption_configuration: self.encryption_configuration,
})
}
}
}
impl CreateSecurityConfigurationInput {
/// Consumes the builder and constructs an Operation<[`CreateSecurityConfiguration`](crate::operation::CreateSecurityConfiguration)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::CreateSecurityConfiguration,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::CreateSecurityConfigurationInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::CreateSecurityConfigurationInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.CreateSecurityConfiguration",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_create_security_configuration(&self)?
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::CreateSecurityConfiguration::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"CreateSecurityConfiguration",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`CreateSecurityConfigurationInput`](crate::input::CreateSecurityConfigurationInput).
pub fn builder() -> crate::input::create_security_configuration_input::Builder {
crate::input::create_security_configuration_input::Builder::default()
}
}
/// See [`CreateSessionInput`](crate::input::CreateSessionInput).
pub mod create_session_input {
/// A builder for [`CreateSessionInput`](crate::input::CreateSessionInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) id: std::option::Option<std::string::String>,
pub(crate) description: std::option::Option<std::string::String>,
pub(crate) role: std::option::Option<std::string::String>,
pub(crate) command: std::option::Option<crate::model::SessionCommand>,
pub(crate) timeout: std::option::Option<i32>,
pub(crate) idle_timeout: std::option::Option<i32>,
pub(crate) default_arguments: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
pub(crate) connections: std::option::Option<crate::model::ConnectionsList>,
pub(crate) max_capacity: std::option::Option<f64>,
pub(crate) number_of_workers: std::option::Option<i32>,
pub(crate) worker_type: std::option::Option<crate::model::WorkerType>,
pub(crate) security_configuration: std::option::Option<std::string::String>,
pub(crate) glue_version: std::option::Option<std::string::String>,
pub(crate) tags: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
pub(crate) request_origin: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The ID of the session request. </p>
pub fn id(mut self, input: impl Into<std::string::String>) -> Self {
self.id = Some(input.into());
self
}
/// <p>The ID of the session request. </p>
pub fn set_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.id = input;
self
}
/// <p>The description of the session. </p>
pub fn description(mut self, input: impl Into<std::string::String>) -> Self {
self.description = Some(input.into());
self
}
/// <p>The description of the session. </p>
pub fn set_description(mut self, input: std::option::Option<std::string::String>) -> Self {
self.description = input;
self
}
/// <p>The IAM Role ARN </p>
pub fn role(mut self, input: impl Into<std::string::String>) -> Self {
self.role = Some(input.into());
self
}
/// <p>The IAM Role ARN </p>
pub fn set_role(mut self, input: std::option::Option<std::string::String>) -> Self {
self.role = input;
self
}
/// <p>The <code>SessionCommand</code> that runs the job. </p>
pub fn command(mut self, input: crate::model::SessionCommand) -> Self {
self.command = Some(input);
self
}
/// <p>The <code>SessionCommand</code> that runs the job. </p>
pub fn set_command(
mut self,
input: std::option::Option<crate::model::SessionCommand>,
) -> Self {
self.command = input;
self
}
/// <p>The number of seconds before request times out. </p>
pub fn timeout(mut self, input: i32) -> Self {
self.timeout = Some(input);
self
}
/// <p>The number of seconds before request times out. </p>
pub fn set_timeout(mut self, input: std::option::Option<i32>) -> Self {
self.timeout = input;
self
}
/// <p>The number of seconds when idle before request times out. </p>
pub fn idle_timeout(mut self, input: i32) -> Self {
self.idle_timeout = Some(input);
self
}
/// <p>The number of seconds when idle before request times out. </p>
pub fn set_idle_timeout(mut self, input: std::option::Option<i32>) -> Self {
self.idle_timeout = input;
self
}
/// Adds a key-value pair to `default_arguments`.
///
/// To override the contents of this collection use [`set_default_arguments`](Self::set_default_arguments).
///
/// <p>A map array of key-value pairs. Max is 75 pairs. </p>
pub fn default_arguments(
mut self,
k: impl Into<std::string::String>,
v: impl Into<std::string::String>,
) -> Self {
let mut hash_map = self.default_arguments.unwrap_or_default();
hash_map.insert(k.into(), v.into());
self.default_arguments = Some(hash_map);
self
}
/// <p>A map array of key-value pairs. Max is 75 pairs. </p>
pub fn set_default_arguments(
mut self,
input: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
) -> Self {
self.default_arguments = input;
self
}
/// <p>The number of connections to use for the session. </p>
pub fn connections(mut self, input: crate::model::ConnectionsList) -> Self {
self.connections = Some(input);
self
}
/// <p>The number of connections to use for the session. </p>
pub fn set_connections(
mut self,
input: std::option::Option<crate::model::ConnectionsList>,
) -> Self {
self.connections = input;
self
}
/// <p>The number of Glue data processing units (DPUs) that can be allocated when the job runs. A DPU is a relative measure of processing power that consists of 4 vCPUs of compute capacity and 16 GB memory. </p>
pub fn max_capacity(mut self, input: f64) -> Self {
self.max_capacity = Some(input);
self
}
/// <p>The number of Glue data processing units (DPUs) that can be allocated when the job runs. A DPU is a relative measure of processing power that consists of 4 vCPUs of compute capacity and 16 GB memory. </p>
pub fn set_max_capacity(mut self, input: std::option::Option<f64>) -> Self {
self.max_capacity = input;
self
}
/// <p>The number of workers of a defined <code>WorkerType</code> to use for the session. </p>
pub fn number_of_workers(mut self, input: i32) -> Self {
self.number_of_workers = Some(input);
self
}
/// <p>The number of workers of a defined <code>WorkerType</code> to use for the session. </p>
pub fn set_number_of_workers(mut self, input: std::option::Option<i32>) -> Self {
self.number_of_workers = input;
self
}
/// <p>The type of predefined worker that is allocated to use for the session. Accepts a value of Standard, G.1X, G.2X, or G.025X.</p>
/// <ul>
/// <li> <p>For the <code>Standard</code> worker type, each worker provides 4 vCPU, 16 GB of memory and a 50GB disk, and 2 executors per worker.</p> </li>
/// <li> <p>For the <code>G.1X</code> worker type, each worker maps to 1 DPU (4 vCPU, 16 GB of memory, 64 GB disk), and provides 1 executor per worker. We recommend this worker type for memory-intensive jobs.</p> </li>
/// <li> <p>For the <code>G.2X</code> worker type, each worker maps to 2 DPU (8 vCPU, 32 GB of memory, 128 GB disk), and provides 1 executor per worker. We recommend this worker type for memory-intensive jobs.</p> </li>
/// <li> <p>For the <code>G.025X</code> worker type, each worker maps to 0.25 DPU (2 vCPU, 4 GB of memory, 64 GB disk), and provides 1 executor per worker. We recommend this worker type for low volume streaming jobs. This worker type is only available for Glue version 3.0 streaming jobs.</p> </li>
/// </ul>
pub fn worker_type(mut self, input: crate::model::WorkerType) -> Self {
self.worker_type = Some(input);
self
}
/// <p>The type of predefined worker that is allocated to use for the session. Accepts a value of Standard, G.1X, G.2X, or G.025X.</p>
/// <ul>
/// <li> <p>For the <code>Standard</code> worker type, each worker provides 4 vCPU, 16 GB of memory and a 50GB disk, and 2 executors per worker.</p> </li>
/// <li> <p>For the <code>G.1X</code> worker type, each worker maps to 1 DPU (4 vCPU, 16 GB of memory, 64 GB disk), and provides 1 executor per worker. We recommend this worker type for memory-intensive jobs.</p> </li>
/// <li> <p>For the <code>G.2X</code> worker type, each worker maps to 2 DPU (8 vCPU, 32 GB of memory, 128 GB disk), and provides 1 executor per worker. We recommend this worker type for memory-intensive jobs.</p> </li>
/// <li> <p>For the <code>G.025X</code> worker type, each worker maps to 0.25 DPU (2 vCPU, 4 GB of memory, 64 GB disk), and provides 1 executor per worker. We recommend this worker type for low volume streaming jobs. This worker type is only available for Glue version 3.0 streaming jobs.</p> </li>
/// </ul>
pub fn set_worker_type(
mut self,
input: std::option::Option<crate::model::WorkerType>,
) -> Self {
self.worker_type = input;
self
}
/// <p>The name of the SecurityConfiguration structure to be used with the session </p>
pub fn security_configuration(mut self, input: impl Into<std::string::String>) -> Self {
self.security_configuration = Some(input.into());
self
}
/// <p>The name of the SecurityConfiguration structure to be used with the session </p>
pub fn set_security_configuration(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.security_configuration = input;
self
}
/// <p>The Glue version determines the versions of Apache Spark and Python that Glue supports. The GlueVersion must be greater than 2.0. </p>
pub fn glue_version(mut self, input: impl Into<std::string::String>) -> Self {
self.glue_version = Some(input.into());
self
}
/// <p>The Glue version determines the versions of Apache Spark and Python that Glue supports. The GlueVersion must be greater than 2.0. </p>
pub fn set_glue_version(mut self, input: std::option::Option<std::string::String>) -> Self {
self.glue_version = input;
self
}
/// Adds a key-value pair to `tags`.
///
/// To override the contents of this collection use [`set_tags`](Self::set_tags).
///
/// <p>The map of key value pairs (tags) belonging to the session.</p>
pub fn tags(
mut self,
k: impl Into<std::string::String>,
v: impl Into<std::string::String>,
) -> Self {
let mut hash_map = self.tags.unwrap_or_default();
hash_map.insert(k.into(), v.into());
self.tags = Some(hash_map);
self
}
/// <p>The map of key value pairs (tags) belonging to the session.</p>
pub fn set_tags(
mut self,
input: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
) -> Self {
self.tags = input;
self
}
/// <p>The origin of the request. </p>
pub fn request_origin(mut self, input: impl Into<std::string::String>) -> Self {
self.request_origin = Some(input.into());
self
}
/// <p>The origin of the request. </p>
pub fn set_request_origin(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.request_origin = input;
self
}
/// Consumes the builder and constructs a [`CreateSessionInput`](crate::input::CreateSessionInput).
pub fn build(
self,
) -> Result<crate::input::CreateSessionInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::CreateSessionInput {
id: self.id,
description: self.description,
role: self.role,
command: self.command,
timeout: self.timeout,
idle_timeout: self.idle_timeout,
default_arguments: self.default_arguments,
connections: self.connections,
max_capacity: self.max_capacity,
number_of_workers: self.number_of_workers,
worker_type: self.worker_type,
security_configuration: self.security_configuration,
glue_version: self.glue_version,
tags: self.tags,
request_origin: self.request_origin,
})
}
}
}
impl CreateSessionInput {
/// Consumes the builder and constructs an Operation<[`CreateSession`](crate::operation::CreateSession)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::CreateSession,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::CreateSessionInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::CreateSessionInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.CreateSession",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_create_session(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::CreateSession::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"CreateSession",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`CreateSessionInput`](crate::input::CreateSessionInput).
pub fn builder() -> crate::input::create_session_input::Builder {
crate::input::create_session_input::Builder::default()
}
}
/// See [`CreateTableInput`](crate::input::CreateTableInput).
pub mod create_table_input {
/// A builder for [`CreateTableInput`](crate::input::CreateTableInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) catalog_id: std::option::Option<std::string::String>,
pub(crate) database_name: std::option::Option<std::string::String>,
pub(crate) table_input: std::option::Option<crate::model::TableInput>,
pub(crate) partition_indexes:
std::option::Option<std::vec::Vec<crate::model::PartitionIndex>>,
pub(crate) transaction_id: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The ID of the Data Catalog in which to create the <code>Table</code>. If none is supplied, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(mut self, input: impl Into<std::string::String>) -> Self {
self.catalog_id = Some(input.into());
self
}
/// <p>The ID of the Data Catalog in which to create the <code>Table</code>. If none is supplied, the Amazon Web Services account ID is used by default.</p>
pub fn set_catalog_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.catalog_id = input;
self
}
/// <p>The catalog database in which to create the new table. For Hive compatibility, this name is entirely lowercase.</p>
pub fn database_name(mut self, input: impl Into<std::string::String>) -> Self {
self.database_name = Some(input.into());
self
}
/// <p>The catalog database in which to create the new table. For Hive compatibility, this name is entirely lowercase.</p>
pub fn set_database_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.database_name = input;
self
}
/// <p>The <code>TableInput</code> object that defines the metadata table to create in the catalog.</p>
pub fn table_input(mut self, input: crate::model::TableInput) -> Self {
self.table_input = Some(input);
self
}
/// <p>The <code>TableInput</code> object that defines the metadata table to create in the catalog.</p>
pub fn set_table_input(
mut self,
input: std::option::Option<crate::model::TableInput>,
) -> Self {
self.table_input = input;
self
}
/// Appends an item to `partition_indexes`.
///
/// To override the contents of this collection use [`set_partition_indexes`](Self::set_partition_indexes).
///
/// <p>A list of partition indexes, <code>PartitionIndex</code> structures, to create in the table.</p>
pub fn partition_indexes(mut self, input: crate::model::PartitionIndex) -> Self {
let mut v = self.partition_indexes.unwrap_or_default();
v.push(input);
self.partition_indexes = Some(v);
self
}
/// <p>A list of partition indexes, <code>PartitionIndex</code> structures, to create in the table.</p>
pub fn set_partition_indexes(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::PartitionIndex>>,
) -> Self {
self.partition_indexes = input;
self
}
/// <p>The ID of the transaction.</p>
pub fn transaction_id(mut self, input: impl Into<std::string::String>) -> Self {
self.transaction_id = Some(input.into());
self
}
/// <p>The ID of the transaction.</p>
pub fn set_transaction_id(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.transaction_id = input;
self
}
/// Consumes the builder and constructs a [`CreateTableInput`](crate::input::CreateTableInput).
pub fn build(
self,
) -> Result<crate::input::CreateTableInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::CreateTableInput {
catalog_id: self.catalog_id,
database_name: self.database_name,
table_input: self.table_input,
partition_indexes: self.partition_indexes,
transaction_id: self.transaction_id,
})
}
}
}
impl CreateTableInput {
/// Consumes the builder and constructs an Operation<[`CreateTable`](crate::operation::CreateTable)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::CreateTable,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::CreateTableInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::CreateTableInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.CreateTable",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_create_table(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::CreateTable::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"CreateTable",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`CreateTableInput`](crate::input::CreateTableInput).
pub fn builder() -> crate::input::create_table_input::Builder {
crate::input::create_table_input::Builder::default()
}
}
/// See [`CreateTriggerInput`](crate::input::CreateTriggerInput).
pub mod create_trigger_input {
/// A builder for [`CreateTriggerInput`](crate::input::CreateTriggerInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) name: std::option::Option<std::string::String>,
pub(crate) workflow_name: std::option::Option<std::string::String>,
pub(crate) r#type: std::option::Option<crate::model::TriggerType>,
pub(crate) schedule: std::option::Option<std::string::String>,
pub(crate) predicate: std::option::Option<crate::model::Predicate>,
pub(crate) actions: std::option::Option<std::vec::Vec<crate::model::Action>>,
pub(crate) description: std::option::Option<std::string::String>,
pub(crate) start_on_creation: std::option::Option<bool>,
pub(crate) tags: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
pub(crate) event_batching_condition:
std::option::Option<crate::model::EventBatchingCondition>,
}
impl Builder {
/// <p>The name of the trigger.</p>
pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
self.name = Some(input.into());
self
}
/// <p>The name of the trigger.</p>
pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.name = input;
self
}
/// <p>The name of the workflow associated with the trigger.</p>
pub fn workflow_name(mut self, input: impl Into<std::string::String>) -> Self {
self.workflow_name = Some(input.into());
self
}
/// <p>The name of the workflow associated with the trigger.</p>
pub fn set_workflow_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.workflow_name = input;
self
}
/// <p>The type of the new trigger.</p>
pub fn r#type(mut self, input: crate::model::TriggerType) -> Self {
self.r#type = Some(input);
self
}
/// <p>The type of the new trigger.</p>
pub fn set_type(mut self, input: std::option::Option<crate::model::TriggerType>) -> Self {
self.r#type = input;
self
}
/// <p>A <code>cron</code> expression used to specify the schedule (see <a href="https://docs.aws.amazon.com/glue/latest/dg/monitor-data-warehouse-schedule.html">Time-Based Schedules for Jobs and Crawlers</a>. For example, to run something every day at 12:15 UTC, you would specify: <code>cron(15 12 * * ? *)</code>.</p>
/// <p>This field is required when the trigger type is SCHEDULED.</p>
pub fn schedule(mut self, input: impl Into<std::string::String>) -> Self {
self.schedule = Some(input.into());
self
}
/// <p>A <code>cron</code> expression used to specify the schedule (see <a href="https://docs.aws.amazon.com/glue/latest/dg/monitor-data-warehouse-schedule.html">Time-Based Schedules for Jobs and Crawlers</a>. For example, to run something every day at 12:15 UTC, you would specify: <code>cron(15 12 * * ? *)</code>.</p>
/// <p>This field is required when the trigger type is SCHEDULED.</p>
pub fn set_schedule(mut self, input: std::option::Option<std::string::String>) -> Self {
self.schedule = input;
self
}
/// <p>A predicate to specify when the new trigger should fire.</p>
/// <p>This field is required when the trigger type is <code>CONDITIONAL</code>.</p>
pub fn predicate(mut self, input: crate::model::Predicate) -> Self {
self.predicate = Some(input);
self
}
/// <p>A predicate to specify when the new trigger should fire.</p>
/// <p>This field is required when the trigger type is <code>CONDITIONAL</code>.</p>
pub fn set_predicate(
mut self,
input: std::option::Option<crate::model::Predicate>,
) -> Self {
self.predicate = input;
self
}
/// Appends an item to `actions`.
///
/// To override the contents of this collection use [`set_actions`](Self::set_actions).
///
/// <p>The actions initiated by this trigger when it fires.</p>
pub fn actions(mut self, input: crate::model::Action) -> Self {
let mut v = self.actions.unwrap_or_default();
v.push(input);
self.actions = Some(v);
self
}
/// <p>The actions initiated by this trigger when it fires.</p>
pub fn set_actions(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::Action>>,
) -> Self {
self.actions = input;
self
}
/// <p>A description of the new trigger.</p>
pub fn description(mut self, input: impl Into<std::string::String>) -> Self {
self.description = Some(input.into());
self
}
/// <p>A description of the new trigger.</p>
pub fn set_description(mut self, input: std::option::Option<std::string::String>) -> Self {
self.description = input;
self
}
/// <p>Set to <code>true</code> to start <code>SCHEDULED</code> and <code>CONDITIONAL</code> triggers when created. True is not supported for <code>ON_DEMAND</code> triggers.</p>
pub fn start_on_creation(mut self, input: bool) -> Self {
self.start_on_creation = Some(input);
self
}
/// <p>Set to <code>true</code> to start <code>SCHEDULED</code> and <code>CONDITIONAL</code> triggers when created. True is not supported for <code>ON_DEMAND</code> triggers.</p>
pub fn set_start_on_creation(mut self, input: std::option::Option<bool>) -> Self {
self.start_on_creation = input;
self
}
/// Adds a key-value pair to `tags`.
///
/// To override the contents of this collection use [`set_tags`](Self::set_tags).
///
/// <p>The tags to use with this trigger. You may use tags to limit access to the trigger. For more information about tags in Glue, see <a href="https://docs.aws.amazon.com/glue/latest/dg/monitor-tags.html">Amazon Web Services Tags in Glue</a> in the developer guide. </p>
pub fn tags(
mut self,
k: impl Into<std::string::String>,
v: impl Into<std::string::String>,
) -> Self {
let mut hash_map = self.tags.unwrap_or_default();
hash_map.insert(k.into(), v.into());
self.tags = Some(hash_map);
self
}
/// <p>The tags to use with this trigger. You may use tags to limit access to the trigger. For more information about tags in Glue, see <a href="https://docs.aws.amazon.com/glue/latest/dg/monitor-tags.html">Amazon Web Services Tags in Glue</a> in the developer guide. </p>
pub fn set_tags(
mut self,
input: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
) -> Self {
self.tags = input;
self
}
/// <p>Batch condition that must be met (specified number of events received or batch time window expired) before EventBridge event trigger fires.</p>
pub fn event_batching_condition(
mut self,
input: crate::model::EventBatchingCondition,
) -> Self {
self.event_batching_condition = Some(input);
self
}
/// <p>Batch condition that must be met (specified number of events received or batch time window expired) before EventBridge event trigger fires.</p>
pub fn set_event_batching_condition(
mut self,
input: std::option::Option<crate::model::EventBatchingCondition>,
) -> Self {
self.event_batching_condition = input;
self
}
/// Consumes the builder and constructs a [`CreateTriggerInput`](crate::input::CreateTriggerInput).
pub fn build(
self,
) -> Result<crate::input::CreateTriggerInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::CreateTriggerInput {
name: self.name,
workflow_name: self.workflow_name,
r#type: self.r#type,
schedule: self.schedule,
predicate: self.predicate,
actions: self.actions,
description: self.description,
start_on_creation: self.start_on_creation.unwrap_or_default(),
tags: self.tags,
event_batching_condition: self.event_batching_condition,
})
}
}
}
impl CreateTriggerInput {
/// Consumes the builder and constructs an Operation<[`CreateTrigger`](crate::operation::CreateTrigger)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::CreateTrigger,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::CreateTriggerInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::CreateTriggerInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.CreateTrigger",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_create_trigger(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::CreateTrigger::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"CreateTrigger",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`CreateTriggerInput`](crate::input::CreateTriggerInput).
pub fn builder() -> crate::input::create_trigger_input::Builder {
crate::input::create_trigger_input::Builder::default()
}
}
/// See [`CreateUserDefinedFunctionInput`](crate::input::CreateUserDefinedFunctionInput).
pub mod create_user_defined_function_input {
/// A builder for [`CreateUserDefinedFunctionInput`](crate::input::CreateUserDefinedFunctionInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) catalog_id: std::option::Option<std::string::String>,
pub(crate) database_name: std::option::Option<std::string::String>,
pub(crate) function_input: std::option::Option<crate::model::UserDefinedFunctionInput>,
}
impl Builder {
/// <p>The ID of the Data Catalog in which to create the function. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(mut self, input: impl Into<std::string::String>) -> Self {
self.catalog_id = Some(input.into());
self
}
/// <p>The ID of the Data Catalog in which to create the function. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn set_catalog_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.catalog_id = input;
self
}
/// <p>The name of the catalog database in which to create the function.</p>
pub fn database_name(mut self, input: impl Into<std::string::String>) -> Self {
self.database_name = Some(input.into());
self
}
/// <p>The name of the catalog database in which to create the function.</p>
pub fn set_database_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.database_name = input;
self
}
/// <p>A <code>FunctionInput</code> object that defines the function to create in the Data Catalog.</p>
pub fn function_input(mut self, input: crate::model::UserDefinedFunctionInput) -> Self {
self.function_input = Some(input);
self
}
/// <p>A <code>FunctionInput</code> object that defines the function to create in the Data Catalog.</p>
pub fn set_function_input(
mut self,
input: std::option::Option<crate::model::UserDefinedFunctionInput>,
) -> Self {
self.function_input = input;
self
}
/// Consumes the builder and constructs a [`CreateUserDefinedFunctionInput`](crate::input::CreateUserDefinedFunctionInput).
pub fn build(
self,
) -> Result<
crate::input::CreateUserDefinedFunctionInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::CreateUserDefinedFunctionInput {
catalog_id: self.catalog_id,
database_name: self.database_name,
function_input: self.function_input,
})
}
}
}
impl CreateUserDefinedFunctionInput {
/// Consumes the builder and constructs an Operation<[`CreateUserDefinedFunction`](crate::operation::CreateUserDefinedFunction)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::CreateUserDefinedFunction,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::CreateUserDefinedFunctionInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::CreateUserDefinedFunctionInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.CreateUserDefinedFunction",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_create_user_defined_function(
&self,
)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::CreateUserDefinedFunction::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"CreateUserDefinedFunction",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`CreateUserDefinedFunctionInput`](crate::input::CreateUserDefinedFunctionInput).
pub fn builder() -> crate::input::create_user_defined_function_input::Builder {
crate::input::create_user_defined_function_input::Builder::default()
}
}
/// See [`CreateWorkflowInput`](crate::input::CreateWorkflowInput).
pub mod create_workflow_input {
/// A builder for [`CreateWorkflowInput`](crate::input::CreateWorkflowInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) name: std::option::Option<std::string::String>,
pub(crate) description: std::option::Option<std::string::String>,
pub(crate) default_run_properties: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
pub(crate) tags: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
pub(crate) max_concurrent_runs: std::option::Option<i32>,
}
impl Builder {
/// <p>The name to be assigned to the workflow. It should be unique within your account.</p>
pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
self.name = Some(input.into());
self
}
/// <p>The name to be assigned to the workflow. It should be unique within your account.</p>
pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.name = input;
self
}
/// <p>A description of the workflow.</p>
pub fn description(mut self, input: impl Into<std::string::String>) -> Self {
self.description = Some(input.into());
self
}
/// <p>A description of the workflow.</p>
pub fn set_description(mut self, input: std::option::Option<std::string::String>) -> Self {
self.description = input;
self
}
/// Adds a key-value pair to `default_run_properties`.
///
/// To override the contents of this collection use [`set_default_run_properties`](Self::set_default_run_properties).
///
/// <p>A collection of properties to be used as part of each execution of the workflow.</p>
pub fn default_run_properties(
mut self,
k: impl Into<std::string::String>,
v: impl Into<std::string::String>,
) -> Self {
let mut hash_map = self.default_run_properties.unwrap_or_default();
hash_map.insert(k.into(), v.into());
self.default_run_properties = Some(hash_map);
self
}
/// <p>A collection of properties to be used as part of each execution of the workflow.</p>
pub fn set_default_run_properties(
mut self,
input: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
) -> Self {
self.default_run_properties = input;
self
}
/// Adds a key-value pair to `tags`.
///
/// To override the contents of this collection use [`set_tags`](Self::set_tags).
///
/// <p>The tags to be used with this workflow.</p>
pub fn tags(
mut self,
k: impl Into<std::string::String>,
v: impl Into<std::string::String>,
) -> Self {
let mut hash_map = self.tags.unwrap_or_default();
hash_map.insert(k.into(), v.into());
self.tags = Some(hash_map);
self
}
/// <p>The tags to be used with this workflow.</p>
pub fn set_tags(
mut self,
input: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
) -> Self {
self.tags = input;
self
}
/// <p>You can use this parameter to prevent unwanted multiple updates to data, to control costs, or in some cases, to prevent exceeding the maximum number of concurrent runs of any of the component jobs. If you leave this parameter blank, there is no limit to the number of concurrent workflow runs.</p>
pub fn max_concurrent_runs(mut self, input: i32) -> Self {
self.max_concurrent_runs = Some(input);
self
}
/// <p>You can use this parameter to prevent unwanted multiple updates to data, to control costs, or in some cases, to prevent exceeding the maximum number of concurrent runs of any of the component jobs. If you leave this parameter blank, there is no limit to the number of concurrent workflow runs.</p>
pub fn set_max_concurrent_runs(mut self, input: std::option::Option<i32>) -> Self {
self.max_concurrent_runs = input;
self
}
/// Consumes the builder and constructs a [`CreateWorkflowInput`](crate::input::CreateWorkflowInput).
pub fn build(
self,
) -> Result<crate::input::CreateWorkflowInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::CreateWorkflowInput {
name: self.name,
description: self.description,
default_run_properties: self.default_run_properties,
tags: self.tags,
max_concurrent_runs: self.max_concurrent_runs,
})
}
}
}
impl CreateWorkflowInput {
/// Consumes the builder and constructs an Operation<[`CreateWorkflow`](crate::operation::CreateWorkflow)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::CreateWorkflow,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::CreateWorkflowInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::CreateWorkflowInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.CreateWorkflow",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_create_workflow(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::CreateWorkflow::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"CreateWorkflow",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`CreateWorkflowInput`](crate::input::CreateWorkflowInput).
pub fn builder() -> crate::input::create_workflow_input::Builder {
crate::input::create_workflow_input::Builder::default()
}
}
/// See [`DeleteBlueprintInput`](crate::input::DeleteBlueprintInput).
pub mod delete_blueprint_input {
/// A builder for [`DeleteBlueprintInput`](crate::input::DeleteBlueprintInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) name: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The name of the blueprint to delete.</p>
pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
self.name = Some(input.into());
self
}
/// <p>The name of the blueprint to delete.</p>
pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.name = input;
self
}
/// Consumes the builder and constructs a [`DeleteBlueprintInput`](crate::input::DeleteBlueprintInput).
pub fn build(
self,
) -> Result<crate::input::DeleteBlueprintInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::DeleteBlueprintInput { name: self.name })
}
}
}
impl DeleteBlueprintInput {
/// Consumes the builder and constructs an Operation<[`DeleteBlueprint`](crate::operation::DeleteBlueprint)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::DeleteBlueprint,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::DeleteBlueprintInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::DeleteBlueprintInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.DeleteBlueprint",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_delete_blueprint(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::DeleteBlueprint::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DeleteBlueprint",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`DeleteBlueprintInput`](crate::input::DeleteBlueprintInput).
pub fn builder() -> crate::input::delete_blueprint_input::Builder {
crate::input::delete_blueprint_input::Builder::default()
}
}
/// See [`DeleteClassifierInput`](crate::input::DeleteClassifierInput).
pub mod delete_classifier_input {
/// A builder for [`DeleteClassifierInput`](crate::input::DeleteClassifierInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) name: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>Name of the classifier to remove.</p>
pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
self.name = Some(input.into());
self
}
/// <p>Name of the classifier to remove.</p>
pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.name = input;
self
}
/// Consumes the builder and constructs a [`DeleteClassifierInput`](crate::input::DeleteClassifierInput).
pub fn build(
self,
) -> Result<
crate::input::DeleteClassifierInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::DeleteClassifierInput { name: self.name })
}
}
}
impl DeleteClassifierInput {
/// Consumes the builder and constructs an Operation<[`DeleteClassifier`](crate::operation::DeleteClassifier)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::DeleteClassifier,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::DeleteClassifierInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::DeleteClassifierInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.DeleteClassifier",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_delete_classifier(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::DeleteClassifier::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DeleteClassifier",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`DeleteClassifierInput`](crate::input::DeleteClassifierInput).
pub fn builder() -> crate::input::delete_classifier_input::Builder {
crate::input::delete_classifier_input::Builder::default()
}
}
/// See [`DeleteColumnStatisticsForPartitionInput`](crate::input::DeleteColumnStatisticsForPartitionInput).
pub mod delete_column_statistics_for_partition_input {
/// A builder for [`DeleteColumnStatisticsForPartitionInput`](crate::input::DeleteColumnStatisticsForPartitionInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) catalog_id: std::option::Option<std::string::String>,
pub(crate) database_name: std::option::Option<std::string::String>,
pub(crate) table_name: std::option::Option<std::string::String>,
pub(crate) partition_values: std::option::Option<std::vec::Vec<std::string::String>>,
pub(crate) column_name: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The ID of the Data Catalog where the partitions in question reside. If none is supplied, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(mut self, input: impl Into<std::string::String>) -> Self {
self.catalog_id = Some(input.into());
self
}
/// <p>The ID of the Data Catalog where the partitions in question reside. If none is supplied, the Amazon Web Services account ID is used by default.</p>
pub fn set_catalog_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.catalog_id = input;
self
}
/// <p>The name of the catalog database where the partitions reside.</p>
pub fn database_name(mut self, input: impl Into<std::string::String>) -> Self {
self.database_name = Some(input.into());
self
}
/// <p>The name of the catalog database where the partitions reside.</p>
pub fn set_database_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.database_name = input;
self
}
/// <p>The name of the partitions' table.</p>
pub fn table_name(mut self, input: impl Into<std::string::String>) -> Self {
self.table_name = Some(input.into());
self
}
/// <p>The name of the partitions' table.</p>
pub fn set_table_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.table_name = input;
self
}
/// Appends an item to `partition_values`.
///
/// To override the contents of this collection use [`set_partition_values`](Self::set_partition_values).
///
/// <p>A list of partition values identifying the partition.</p>
pub fn partition_values(mut self, input: impl Into<std::string::String>) -> Self {
let mut v = self.partition_values.unwrap_or_default();
v.push(input.into());
self.partition_values = Some(v);
self
}
/// <p>A list of partition values identifying the partition.</p>
pub fn set_partition_values(
mut self,
input: std::option::Option<std::vec::Vec<std::string::String>>,
) -> Self {
self.partition_values = input;
self
}
/// <p>Name of the column.</p>
pub fn column_name(mut self, input: impl Into<std::string::String>) -> Self {
self.column_name = Some(input.into());
self
}
/// <p>Name of the column.</p>
pub fn set_column_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.column_name = input;
self
}
/// Consumes the builder and constructs a [`DeleteColumnStatisticsForPartitionInput`](crate::input::DeleteColumnStatisticsForPartitionInput).
pub fn build(
self,
) -> Result<
crate::input::DeleteColumnStatisticsForPartitionInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::DeleteColumnStatisticsForPartitionInput {
catalog_id: self.catalog_id,
database_name: self.database_name,
table_name: self.table_name,
partition_values: self.partition_values,
column_name: self.column_name,
})
}
}
}
impl DeleteColumnStatisticsForPartitionInput {
/// Consumes the builder and constructs an Operation<[`DeleteColumnStatisticsForPartition`](crate::operation::DeleteColumnStatisticsForPartition)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::DeleteColumnStatisticsForPartition,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::DeleteColumnStatisticsForPartitionInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::DeleteColumnStatisticsForPartitionInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.DeleteColumnStatisticsForPartition",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_delete_column_statistics_for_partition(&self)?
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::DeleteColumnStatisticsForPartition::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DeleteColumnStatisticsForPartition",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`DeleteColumnStatisticsForPartitionInput`](crate::input::DeleteColumnStatisticsForPartitionInput).
pub fn builder() -> crate::input::delete_column_statistics_for_partition_input::Builder {
crate::input::delete_column_statistics_for_partition_input::Builder::default()
}
}
/// See [`DeleteColumnStatisticsForTableInput`](crate::input::DeleteColumnStatisticsForTableInput).
pub mod delete_column_statistics_for_table_input {
/// A builder for [`DeleteColumnStatisticsForTableInput`](crate::input::DeleteColumnStatisticsForTableInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) catalog_id: std::option::Option<std::string::String>,
pub(crate) database_name: std::option::Option<std::string::String>,
pub(crate) table_name: std::option::Option<std::string::String>,
pub(crate) column_name: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The ID of the Data Catalog where the partitions in question reside. If none is supplied, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(mut self, input: impl Into<std::string::String>) -> Self {
self.catalog_id = Some(input.into());
self
}
/// <p>The ID of the Data Catalog where the partitions in question reside. If none is supplied, the Amazon Web Services account ID is used by default.</p>
pub fn set_catalog_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.catalog_id = input;
self
}
/// <p>The name of the catalog database where the partitions reside.</p>
pub fn database_name(mut self, input: impl Into<std::string::String>) -> Self {
self.database_name = Some(input.into());
self
}
/// <p>The name of the catalog database where the partitions reside.</p>
pub fn set_database_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.database_name = input;
self
}
/// <p>The name of the partitions' table.</p>
pub fn table_name(mut self, input: impl Into<std::string::String>) -> Self {
self.table_name = Some(input.into());
self
}
/// <p>The name of the partitions' table.</p>
pub fn set_table_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.table_name = input;
self
}
/// <p>The name of the column.</p>
pub fn column_name(mut self, input: impl Into<std::string::String>) -> Self {
self.column_name = Some(input.into());
self
}
/// <p>The name of the column.</p>
pub fn set_column_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.column_name = input;
self
}
/// Consumes the builder and constructs a [`DeleteColumnStatisticsForTableInput`](crate::input::DeleteColumnStatisticsForTableInput).
pub fn build(
self,
) -> Result<
crate::input::DeleteColumnStatisticsForTableInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::DeleteColumnStatisticsForTableInput {
catalog_id: self.catalog_id,
database_name: self.database_name,
table_name: self.table_name,
column_name: self.column_name,
})
}
}
}
impl DeleteColumnStatisticsForTableInput {
/// Consumes the builder and constructs an Operation<[`DeleteColumnStatisticsForTable`](crate::operation::DeleteColumnStatisticsForTable)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::DeleteColumnStatisticsForTable,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::DeleteColumnStatisticsForTableInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::DeleteColumnStatisticsForTableInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.DeleteColumnStatisticsForTable",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_delete_column_statistics_for_table(&self)?
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::DeleteColumnStatisticsForTable::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DeleteColumnStatisticsForTable",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`DeleteColumnStatisticsForTableInput`](crate::input::DeleteColumnStatisticsForTableInput).
pub fn builder() -> crate::input::delete_column_statistics_for_table_input::Builder {
crate::input::delete_column_statistics_for_table_input::Builder::default()
}
}
/// See [`DeleteConnectionInput`](crate::input::DeleteConnectionInput).
pub mod delete_connection_input {
/// A builder for [`DeleteConnectionInput`](crate::input::DeleteConnectionInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) catalog_id: std::option::Option<std::string::String>,
pub(crate) connection_name: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The ID of the Data Catalog in which the connection resides. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(mut self, input: impl Into<std::string::String>) -> Self {
self.catalog_id = Some(input.into());
self
}
/// <p>The ID of the Data Catalog in which the connection resides. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn set_catalog_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.catalog_id = input;
self
}
/// <p>The name of the connection to delete.</p>
pub fn connection_name(mut self, input: impl Into<std::string::String>) -> Self {
self.connection_name = Some(input.into());
self
}
/// <p>The name of the connection to delete.</p>
pub fn set_connection_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.connection_name = input;
self
}
/// Consumes the builder and constructs a [`DeleteConnectionInput`](crate::input::DeleteConnectionInput).
pub fn build(
self,
) -> Result<
crate::input::DeleteConnectionInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::DeleteConnectionInput {
catalog_id: self.catalog_id,
connection_name: self.connection_name,
})
}
}
}
impl DeleteConnectionInput {
/// Consumes the builder and constructs an Operation<[`DeleteConnection`](crate::operation::DeleteConnection)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::DeleteConnection,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::DeleteConnectionInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::DeleteConnectionInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.DeleteConnection",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_delete_connection(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::DeleteConnection::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DeleteConnection",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`DeleteConnectionInput`](crate::input::DeleteConnectionInput).
pub fn builder() -> crate::input::delete_connection_input::Builder {
crate::input::delete_connection_input::Builder::default()
}
}
/// See [`DeleteCrawlerInput`](crate::input::DeleteCrawlerInput).
pub mod delete_crawler_input {
/// A builder for [`DeleteCrawlerInput`](crate::input::DeleteCrawlerInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) name: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The name of the crawler to remove.</p>
pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
self.name = Some(input.into());
self
}
/// <p>The name of the crawler to remove.</p>
pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.name = input;
self
}
/// Consumes the builder and constructs a [`DeleteCrawlerInput`](crate::input::DeleteCrawlerInput).
pub fn build(
self,
) -> Result<crate::input::DeleteCrawlerInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::DeleteCrawlerInput { name: self.name })
}
}
}
impl DeleteCrawlerInput {
/// Consumes the builder and constructs an Operation<[`DeleteCrawler`](crate::operation::DeleteCrawler)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::DeleteCrawler,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::DeleteCrawlerInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::DeleteCrawlerInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.DeleteCrawler",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_delete_crawler(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::DeleteCrawler::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DeleteCrawler",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`DeleteCrawlerInput`](crate::input::DeleteCrawlerInput).
pub fn builder() -> crate::input::delete_crawler_input::Builder {
crate::input::delete_crawler_input::Builder::default()
}
}
/// See [`DeleteCustomEntityTypeInput`](crate::input::DeleteCustomEntityTypeInput).
pub mod delete_custom_entity_type_input {
/// A builder for [`DeleteCustomEntityTypeInput`](crate::input::DeleteCustomEntityTypeInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) name: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The name of the custom pattern that you want to delete.</p>
pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
self.name = Some(input.into());
self
}
/// <p>The name of the custom pattern that you want to delete.</p>
pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.name = input;
self
}
/// Consumes the builder and constructs a [`DeleteCustomEntityTypeInput`](crate::input::DeleteCustomEntityTypeInput).
pub fn build(
self,
) -> Result<
crate::input::DeleteCustomEntityTypeInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::DeleteCustomEntityTypeInput { name: self.name })
}
}
}
impl DeleteCustomEntityTypeInput {
/// Consumes the builder and constructs an Operation<[`DeleteCustomEntityType`](crate::operation::DeleteCustomEntityType)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::DeleteCustomEntityType,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::DeleteCustomEntityTypeInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::DeleteCustomEntityTypeInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.DeleteCustomEntityType",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_delete_custom_entity_type(
&self,
)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::DeleteCustomEntityType::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DeleteCustomEntityType",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`DeleteCustomEntityTypeInput`](crate::input::DeleteCustomEntityTypeInput).
pub fn builder() -> crate::input::delete_custom_entity_type_input::Builder {
crate::input::delete_custom_entity_type_input::Builder::default()
}
}
/// See [`DeleteDatabaseInput`](crate::input::DeleteDatabaseInput).
pub mod delete_database_input {
/// A builder for [`DeleteDatabaseInput`](crate::input::DeleteDatabaseInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) catalog_id: std::option::Option<std::string::String>,
pub(crate) name: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The ID of the Data Catalog in which the database resides. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(mut self, input: impl Into<std::string::String>) -> Self {
self.catalog_id = Some(input.into());
self
}
/// <p>The ID of the Data Catalog in which the database resides. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn set_catalog_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.catalog_id = input;
self
}
/// <p>The name of the database to delete. For Hive compatibility, this must be all lowercase.</p>
pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
self.name = Some(input.into());
self
}
/// <p>The name of the database to delete. For Hive compatibility, this must be all lowercase.</p>
pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.name = input;
self
}
/// Consumes the builder and constructs a [`DeleteDatabaseInput`](crate::input::DeleteDatabaseInput).
pub fn build(
self,
) -> Result<crate::input::DeleteDatabaseInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::DeleteDatabaseInput {
catalog_id: self.catalog_id,
name: self.name,
})
}
}
}
impl DeleteDatabaseInput {
/// Consumes the builder and constructs an Operation<[`DeleteDatabase`](crate::operation::DeleteDatabase)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::DeleteDatabase,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::DeleteDatabaseInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::DeleteDatabaseInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.DeleteDatabase",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_delete_database(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::DeleteDatabase::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DeleteDatabase",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`DeleteDatabaseInput`](crate::input::DeleteDatabaseInput).
pub fn builder() -> crate::input::delete_database_input::Builder {
crate::input::delete_database_input::Builder::default()
}
}
/// See [`DeleteDataQualityRulesetInput`](crate::input::DeleteDataQualityRulesetInput).
pub mod delete_data_quality_ruleset_input {
/// A builder for [`DeleteDataQualityRulesetInput`](crate::input::DeleteDataQualityRulesetInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) name: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>A name for the data quality ruleset.</p>
pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
self.name = Some(input.into());
self
}
/// <p>A name for the data quality ruleset.</p>
pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.name = input;
self
}
/// Consumes the builder and constructs a [`DeleteDataQualityRulesetInput`](crate::input::DeleteDataQualityRulesetInput).
pub fn build(
self,
) -> Result<
crate::input::DeleteDataQualityRulesetInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::DeleteDataQualityRulesetInput { name: self.name })
}
}
}
impl DeleteDataQualityRulesetInput {
/// Consumes the builder and constructs an Operation<[`DeleteDataQualityRuleset`](crate::operation::DeleteDataQualityRuleset)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::DeleteDataQualityRuleset,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::DeleteDataQualityRulesetInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::DeleteDataQualityRulesetInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.DeleteDataQualityRuleset",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_delete_data_quality_ruleset(
&self,
)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::DeleteDataQualityRuleset::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DeleteDataQualityRuleset",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`DeleteDataQualityRulesetInput`](crate::input::DeleteDataQualityRulesetInput).
pub fn builder() -> crate::input::delete_data_quality_ruleset_input::Builder {
crate::input::delete_data_quality_ruleset_input::Builder::default()
}
}
/// See [`DeleteDevEndpointInput`](crate::input::DeleteDevEndpointInput).
pub mod delete_dev_endpoint_input {
/// A builder for [`DeleteDevEndpointInput`](crate::input::DeleteDevEndpointInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) endpoint_name: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The name of the <code>DevEndpoint</code>.</p>
pub fn endpoint_name(mut self, input: impl Into<std::string::String>) -> Self {
self.endpoint_name = Some(input.into());
self
}
/// <p>The name of the <code>DevEndpoint</code>.</p>
pub fn set_endpoint_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.endpoint_name = input;
self
}
/// Consumes the builder and constructs a [`DeleteDevEndpointInput`](crate::input::DeleteDevEndpointInput).
pub fn build(
self,
) -> Result<
crate::input::DeleteDevEndpointInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::DeleteDevEndpointInput {
endpoint_name: self.endpoint_name,
})
}
}
}
impl DeleteDevEndpointInput {
/// Consumes the builder and constructs an Operation<[`DeleteDevEndpoint`](crate::operation::DeleteDevEndpoint)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::DeleteDevEndpoint,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::DeleteDevEndpointInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::DeleteDevEndpointInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.DeleteDevEndpoint",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_delete_dev_endpoint(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::DeleteDevEndpoint::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DeleteDevEndpoint",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`DeleteDevEndpointInput`](crate::input::DeleteDevEndpointInput).
pub fn builder() -> crate::input::delete_dev_endpoint_input::Builder {
crate::input::delete_dev_endpoint_input::Builder::default()
}
}
/// See [`DeleteJobInput`](crate::input::DeleteJobInput).
pub mod delete_job_input {
/// A builder for [`DeleteJobInput`](crate::input::DeleteJobInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) job_name: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The name of the job definition to delete.</p>
pub fn job_name(mut self, input: impl Into<std::string::String>) -> Self {
self.job_name = Some(input.into());
self
}
/// <p>The name of the job definition to delete.</p>
pub fn set_job_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.job_name = input;
self
}
/// Consumes the builder and constructs a [`DeleteJobInput`](crate::input::DeleteJobInput).
pub fn build(
self,
) -> Result<crate::input::DeleteJobInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::DeleteJobInput {
job_name: self.job_name,
})
}
}
}
impl DeleteJobInput {
/// Consumes the builder and constructs an Operation<[`DeleteJob`](crate::operation::DeleteJob)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::DeleteJob,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::DeleteJobInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::DeleteJobInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.DeleteJob",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_delete_job(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op =
aws_smithy_http::operation::Operation::new(request, crate::operation::DeleteJob::new())
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DeleteJob",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`DeleteJobInput`](crate::input::DeleteJobInput).
pub fn builder() -> crate::input::delete_job_input::Builder {
crate::input::delete_job_input::Builder::default()
}
}
/// See [`DeleteMlTransformInput`](crate::input::DeleteMlTransformInput).
pub mod delete_ml_transform_input {
/// A builder for [`DeleteMlTransformInput`](crate::input::DeleteMlTransformInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) transform_id: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The unique identifier of the transform to delete.</p>
pub fn transform_id(mut self, input: impl Into<std::string::String>) -> Self {
self.transform_id = Some(input.into());
self
}
/// <p>The unique identifier of the transform to delete.</p>
pub fn set_transform_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.transform_id = input;
self
}
/// Consumes the builder and constructs a [`DeleteMlTransformInput`](crate::input::DeleteMlTransformInput).
pub fn build(
self,
) -> Result<
crate::input::DeleteMlTransformInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::DeleteMlTransformInput {
transform_id: self.transform_id,
})
}
}
}
impl DeleteMlTransformInput {
/// Consumes the builder and constructs an Operation<[`DeleteMLTransform`](crate::operation::DeleteMLTransform)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::DeleteMLTransform,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::DeleteMlTransformInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::DeleteMlTransformInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.DeleteMLTransform",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_delete_ml_transform(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::DeleteMLTransform::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DeleteMLTransform",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`DeleteMlTransformInput`](crate::input::DeleteMlTransformInput).
pub fn builder() -> crate::input::delete_ml_transform_input::Builder {
crate::input::delete_ml_transform_input::Builder::default()
}
}
/// See [`DeletePartitionInput`](crate::input::DeletePartitionInput).
pub mod delete_partition_input {
/// A builder for [`DeletePartitionInput`](crate::input::DeletePartitionInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) catalog_id: std::option::Option<std::string::String>,
pub(crate) database_name: std::option::Option<std::string::String>,
pub(crate) table_name: std::option::Option<std::string::String>,
pub(crate) partition_values: std::option::Option<std::vec::Vec<std::string::String>>,
}
impl Builder {
/// <p>The ID of the Data Catalog where the partition to be deleted resides. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(mut self, input: impl Into<std::string::String>) -> Self {
self.catalog_id = Some(input.into());
self
}
/// <p>The ID of the Data Catalog where the partition to be deleted resides. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn set_catalog_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.catalog_id = input;
self
}
/// <p>The name of the catalog database in which the table in question resides.</p>
pub fn database_name(mut self, input: impl Into<std::string::String>) -> Self {
self.database_name = Some(input.into());
self
}
/// <p>The name of the catalog database in which the table in question resides.</p>
pub fn set_database_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.database_name = input;
self
}
/// <p>The name of the table that contains the partition to be deleted.</p>
pub fn table_name(mut self, input: impl Into<std::string::String>) -> Self {
self.table_name = Some(input.into());
self
}
/// <p>The name of the table that contains the partition to be deleted.</p>
pub fn set_table_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.table_name = input;
self
}
/// Appends an item to `partition_values`.
///
/// To override the contents of this collection use [`set_partition_values`](Self::set_partition_values).
///
/// <p>The values that define the partition.</p>
pub fn partition_values(mut self, input: impl Into<std::string::String>) -> Self {
let mut v = self.partition_values.unwrap_or_default();
v.push(input.into());
self.partition_values = Some(v);
self
}
/// <p>The values that define the partition.</p>
pub fn set_partition_values(
mut self,
input: std::option::Option<std::vec::Vec<std::string::String>>,
) -> Self {
self.partition_values = input;
self
}
/// Consumes the builder and constructs a [`DeletePartitionInput`](crate::input::DeletePartitionInput).
pub fn build(
self,
) -> Result<crate::input::DeletePartitionInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::DeletePartitionInput {
catalog_id: self.catalog_id,
database_name: self.database_name,
table_name: self.table_name,
partition_values: self.partition_values,
})
}
}
}
impl DeletePartitionInput {
/// Consumes the builder and constructs an Operation<[`DeletePartition`](crate::operation::DeletePartition)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::DeletePartition,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::DeletePartitionInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::DeletePartitionInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.DeletePartition",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_delete_partition(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::DeletePartition::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DeletePartition",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`DeletePartitionInput`](crate::input::DeletePartitionInput).
pub fn builder() -> crate::input::delete_partition_input::Builder {
crate::input::delete_partition_input::Builder::default()
}
}
/// See [`DeletePartitionIndexInput`](crate::input::DeletePartitionIndexInput).
pub mod delete_partition_index_input {
/// A builder for [`DeletePartitionIndexInput`](crate::input::DeletePartitionIndexInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) catalog_id: std::option::Option<std::string::String>,
pub(crate) database_name: std::option::Option<std::string::String>,
pub(crate) table_name: std::option::Option<std::string::String>,
pub(crate) index_name: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The catalog ID where the table resides.</p>
pub fn catalog_id(mut self, input: impl Into<std::string::String>) -> Self {
self.catalog_id = Some(input.into());
self
}
/// <p>The catalog ID where the table resides.</p>
pub fn set_catalog_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.catalog_id = input;
self
}
/// <p>Specifies the name of a database from which you want to delete a partition index.</p>
pub fn database_name(mut self, input: impl Into<std::string::String>) -> Self {
self.database_name = Some(input.into());
self
}
/// <p>Specifies the name of a database from which you want to delete a partition index.</p>
pub fn set_database_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.database_name = input;
self
}
/// <p>Specifies the name of a table from which you want to delete a partition index.</p>
pub fn table_name(mut self, input: impl Into<std::string::String>) -> Self {
self.table_name = Some(input.into());
self
}
/// <p>Specifies the name of a table from which you want to delete a partition index.</p>
pub fn set_table_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.table_name = input;
self
}
/// <p>The name of the partition index to be deleted.</p>
pub fn index_name(mut self, input: impl Into<std::string::String>) -> Self {
self.index_name = Some(input.into());
self
}
/// <p>The name of the partition index to be deleted.</p>
pub fn set_index_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.index_name = input;
self
}
/// Consumes the builder and constructs a [`DeletePartitionIndexInput`](crate::input::DeletePartitionIndexInput).
pub fn build(
self,
) -> Result<
crate::input::DeletePartitionIndexInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::DeletePartitionIndexInput {
catalog_id: self.catalog_id,
database_name: self.database_name,
table_name: self.table_name,
index_name: self.index_name,
})
}
}
}
impl DeletePartitionIndexInput {
/// Consumes the builder and constructs an Operation<[`DeletePartitionIndex`](crate::operation::DeletePartitionIndex)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::DeletePartitionIndex,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::DeletePartitionIndexInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::DeletePartitionIndexInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.DeletePartitionIndex",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_delete_partition_index(
&self,
)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::DeletePartitionIndex::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DeletePartitionIndex",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`DeletePartitionIndexInput`](crate::input::DeletePartitionIndexInput).
pub fn builder() -> crate::input::delete_partition_index_input::Builder {
crate::input::delete_partition_index_input::Builder::default()
}
}
/// See [`DeleteRegistryInput`](crate::input::DeleteRegistryInput).
pub mod delete_registry_input {
/// A builder for [`DeleteRegistryInput`](crate::input::DeleteRegistryInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) registry_id: std::option::Option<crate::model::RegistryId>,
}
impl Builder {
/// <p>This is a wrapper structure that may contain the registry name and Amazon Resource Name (ARN).</p>
pub fn registry_id(mut self, input: crate::model::RegistryId) -> Self {
self.registry_id = Some(input);
self
}
/// <p>This is a wrapper structure that may contain the registry name and Amazon Resource Name (ARN).</p>
pub fn set_registry_id(
mut self,
input: std::option::Option<crate::model::RegistryId>,
) -> Self {
self.registry_id = input;
self
}
/// Consumes the builder and constructs a [`DeleteRegistryInput`](crate::input::DeleteRegistryInput).
pub fn build(
self,
) -> Result<crate::input::DeleteRegistryInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::DeleteRegistryInput {
registry_id: self.registry_id,
})
}
}
}
impl DeleteRegistryInput {
/// Consumes the builder and constructs an Operation<[`DeleteRegistry`](crate::operation::DeleteRegistry)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::DeleteRegistry,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::DeleteRegistryInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::DeleteRegistryInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.DeleteRegistry",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_delete_registry(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::DeleteRegistry::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DeleteRegistry",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`DeleteRegistryInput`](crate::input::DeleteRegistryInput).
pub fn builder() -> crate::input::delete_registry_input::Builder {
crate::input::delete_registry_input::Builder::default()
}
}
/// See [`DeleteResourcePolicyInput`](crate::input::DeleteResourcePolicyInput).
pub mod delete_resource_policy_input {
/// A builder for [`DeleteResourcePolicyInput`](crate::input::DeleteResourcePolicyInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) policy_hash_condition: std::option::Option<std::string::String>,
pub(crate) resource_arn: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The hash value returned when this policy was set.</p>
pub fn policy_hash_condition(mut self, input: impl Into<std::string::String>) -> Self {
self.policy_hash_condition = Some(input.into());
self
}
/// <p>The hash value returned when this policy was set.</p>
pub fn set_policy_hash_condition(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.policy_hash_condition = input;
self
}
/// <p>The ARN of the Glue resource for the resource policy to be deleted.</p>
pub fn resource_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.resource_arn = Some(input.into());
self
}
/// <p>The ARN of the Glue resource for the resource policy to be deleted.</p>
pub fn set_resource_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.resource_arn = input;
self
}
/// Consumes the builder and constructs a [`DeleteResourcePolicyInput`](crate::input::DeleteResourcePolicyInput).
pub fn build(
self,
) -> Result<
crate::input::DeleteResourcePolicyInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::DeleteResourcePolicyInput {
policy_hash_condition: self.policy_hash_condition,
resource_arn: self.resource_arn,
})
}
}
}
impl DeleteResourcePolicyInput {
/// Consumes the builder and constructs an Operation<[`DeleteResourcePolicy`](crate::operation::DeleteResourcePolicy)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::DeleteResourcePolicy,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::DeleteResourcePolicyInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::DeleteResourcePolicyInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.DeleteResourcePolicy",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_delete_resource_policy(
&self,
)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::DeleteResourcePolicy::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DeleteResourcePolicy",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`DeleteResourcePolicyInput`](crate::input::DeleteResourcePolicyInput).
pub fn builder() -> crate::input::delete_resource_policy_input::Builder {
crate::input::delete_resource_policy_input::Builder::default()
}
}
/// See [`DeleteSchemaInput`](crate::input::DeleteSchemaInput).
pub mod delete_schema_input {
/// A builder for [`DeleteSchemaInput`](crate::input::DeleteSchemaInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) schema_id: std::option::Option<crate::model::SchemaId>,
}
impl Builder {
/// <p>This is a wrapper structure that may contain the schema name and Amazon Resource Name (ARN).</p>
pub fn schema_id(mut self, input: crate::model::SchemaId) -> Self {
self.schema_id = Some(input);
self
}
/// <p>This is a wrapper structure that may contain the schema name and Amazon Resource Name (ARN).</p>
pub fn set_schema_id(mut self, input: std::option::Option<crate::model::SchemaId>) -> Self {
self.schema_id = input;
self
}
/// Consumes the builder and constructs a [`DeleteSchemaInput`](crate::input::DeleteSchemaInput).
pub fn build(
self,
) -> Result<crate::input::DeleteSchemaInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::DeleteSchemaInput {
schema_id: self.schema_id,
})
}
}
}
impl DeleteSchemaInput {
/// Consumes the builder and constructs an Operation<[`DeleteSchema`](crate::operation::DeleteSchema)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::DeleteSchema,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::DeleteSchemaInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::DeleteSchemaInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.DeleteSchema",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_delete_schema(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::DeleteSchema::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DeleteSchema",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`DeleteSchemaInput`](crate::input::DeleteSchemaInput).
pub fn builder() -> crate::input::delete_schema_input::Builder {
crate::input::delete_schema_input::Builder::default()
}
}
/// See [`DeleteSchemaVersionsInput`](crate::input::DeleteSchemaVersionsInput).
pub mod delete_schema_versions_input {
/// A builder for [`DeleteSchemaVersionsInput`](crate::input::DeleteSchemaVersionsInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) schema_id: std::option::Option<crate::model::SchemaId>,
pub(crate) versions: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>This is a wrapper structure that may contain the schema name and Amazon Resource Name (ARN).</p>
pub fn schema_id(mut self, input: crate::model::SchemaId) -> Self {
self.schema_id = Some(input);
self
}
/// <p>This is a wrapper structure that may contain the schema name and Amazon Resource Name (ARN).</p>
pub fn set_schema_id(mut self, input: std::option::Option<crate::model::SchemaId>) -> Self {
self.schema_id = input;
self
}
/// <p>A version range may be supplied which may be of the format:</p>
/// <ul>
/// <li> <p>a single version number, 5</p> </li>
/// <li> <p>a range, 5-8 : deletes versions 5, 6, 7, 8</p> </li>
/// </ul>
pub fn versions(mut self, input: impl Into<std::string::String>) -> Self {
self.versions = Some(input.into());
self
}
/// <p>A version range may be supplied which may be of the format:</p>
/// <ul>
/// <li> <p>a single version number, 5</p> </li>
/// <li> <p>a range, 5-8 : deletes versions 5, 6, 7, 8</p> </li>
/// </ul>
pub fn set_versions(mut self, input: std::option::Option<std::string::String>) -> Self {
self.versions = input;
self
}
/// Consumes the builder and constructs a [`DeleteSchemaVersionsInput`](crate::input::DeleteSchemaVersionsInput).
pub fn build(
self,
) -> Result<
crate::input::DeleteSchemaVersionsInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::DeleteSchemaVersionsInput {
schema_id: self.schema_id,
versions: self.versions,
})
}
}
}
impl DeleteSchemaVersionsInput {
/// Consumes the builder and constructs an Operation<[`DeleteSchemaVersions`](crate::operation::DeleteSchemaVersions)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::DeleteSchemaVersions,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::DeleteSchemaVersionsInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::DeleteSchemaVersionsInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.DeleteSchemaVersions",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_delete_schema_versions(
&self,
)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::DeleteSchemaVersions::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DeleteSchemaVersions",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`DeleteSchemaVersionsInput`](crate::input::DeleteSchemaVersionsInput).
pub fn builder() -> crate::input::delete_schema_versions_input::Builder {
crate::input::delete_schema_versions_input::Builder::default()
}
}
/// See [`DeleteSecurityConfigurationInput`](crate::input::DeleteSecurityConfigurationInput).
pub mod delete_security_configuration_input {
/// A builder for [`DeleteSecurityConfigurationInput`](crate::input::DeleteSecurityConfigurationInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) name: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The name of the security configuration to delete.</p>
pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
self.name = Some(input.into());
self
}
/// <p>The name of the security configuration to delete.</p>
pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.name = input;
self
}
/// Consumes the builder and constructs a [`DeleteSecurityConfigurationInput`](crate::input::DeleteSecurityConfigurationInput).
pub fn build(
self,
) -> Result<
crate::input::DeleteSecurityConfigurationInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::DeleteSecurityConfigurationInput { name: self.name })
}
}
}
impl DeleteSecurityConfigurationInput {
/// Consumes the builder and constructs an Operation<[`DeleteSecurityConfiguration`](crate::operation::DeleteSecurityConfiguration)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::DeleteSecurityConfiguration,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::DeleteSecurityConfigurationInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::DeleteSecurityConfigurationInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.DeleteSecurityConfiguration",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_delete_security_configuration(&self)?
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::DeleteSecurityConfiguration::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DeleteSecurityConfiguration",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`DeleteSecurityConfigurationInput`](crate::input::DeleteSecurityConfigurationInput).
pub fn builder() -> crate::input::delete_security_configuration_input::Builder {
crate::input::delete_security_configuration_input::Builder::default()
}
}
/// See [`DeleteSessionInput`](crate::input::DeleteSessionInput).
pub mod delete_session_input {
/// A builder for [`DeleteSessionInput`](crate::input::DeleteSessionInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) id: std::option::Option<std::string::String>,
pub(crate) request_origin: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The ID of the session to be deleted.</p>
pub fn id(mut self, input: impl Into<std::string::String>) -> Self {
self.id = Some(input.into());
self
}
/// <p>The ID of the session to be deleted.</p>
pub fn set_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.id = input;
self
}
/// <p>The name of the origin of the delete session request.</p>
pub fn request_origin(mut self, input: impl Into<std::string::String>) -> Self {
self.request_origin = Some(input.into());
self
}
/// <p>The name of the origin of the delete session request.</p>
pub fn set_request_origin(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.request_origin = input;
self
}
/// Consumes the builder and constructs a [`DeleteSessionInput`](crate::input::DeleteSessionInput).
pub fn build(
self,
) -> Result<crate::input::DeleteSessionInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::DeleteSessionInput {
id: self.id,
request_origin: self.request_origin,
})
}
}
}
impl DeleteSessionInput {
/// Consumes the builder and constructs an Operation<[`DeleteSession`](crate::operation::DeleteSession)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::DeleteSession,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::DeleteSessionInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::DeleteSessionInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.DeleteSession",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_delete_session(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::DeleteSession::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DeleteSession",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`DeleteSessionInput`](crate::input::DeleteSessionInput).
pub fn builder() -> crate::input::delete_session_input::Builder {
crate::input::delete_session_input::Builder::default()
}
}
/// See [`DeleteTableInput`](crate::input::DeleteTableInput).
pub mod delete_table_input {
/// A builder for [`DeleteTableInput`](crate::input::DeleteTableInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) catalog_id: std::option::Option<std::string::String>,
pub(crate) database_name: std::option::Option<std::string::String>,
pub(crate) name: std::option::Option<std::string::String>,
pub(crate) transaction_id: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The ID of the Data Catalog where the table resides. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(mut self, input: impl Into<std::string::String>) -> Self {
self.catalog_id = Some(input.into());
self
}
/// <p>The ID of the Data Catalog where the table resides. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn set_catalog_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.catalog_id = input;
self
}
/// <p>The name of the catalog database in which the table resides. For Hive compatibility, this name is entirely lowercase.</p>
pub fn database_name(mut self, input: impl Into<std::string::String>) -> Self {
self.database_name = Some(input.into());
self
}
/// <p>The name of the catalog database in which the table resides. For Hive compatibility, this name is entirely lowercase.</p>
pub fn set_database_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.database_name = input;
self
}
/// <p>The name of the table to be deleted. For Hive compatibility, this name is entirely lowercase.</p>
pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
self.name = Some(input.into());
self
}
/// <p>The name of the table to be deleted. For Hive compatibility, this name is entirely lowercase.</p>
pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.name = input;
self
}
/// <p>The transaction ID at which to delete the table contents.</p>
pub fn transaction_id(mut self, input: impl Into<std::string::String>) -> Self {
self.transaction_id = Some(input.into());
self
}
/// <p>The transaction ID at which to delete the table contents.</p>
pub fn set_transaction_id(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.transaction_id = input;
self
}
/// Consumes the builder and constructs a [`DeleteTableInput`](crate::input::DeleteTableInput).
pub fn build(
self,
) -> Result<crate::input::DeleteTableInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::DeleteTableInput {
catalog_id: self.catalog_id,
database_name: self.database_name,
name: self.name,
transaction_id: self.transaction_id,
})
}
}
}
impl DeleteTableInput {
/// Consumes the builder and constructs an Operation<[`DeleteTable`](crate::operation::DeleteTable)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::DeleteTable,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::DeleteTableInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::DeleteTableInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.DeleteTable",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_delete_table(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::DeleteTable::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DeleteTable",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`DeleteTableInput`](crate::input::DeleteTableInput).
pub fn builder() -> crate::input::delete_table_input::Builder {
crate::input::delete_table_input::Builder::default()
}
}
/// See [`DeleteTableVersionInput`](crate::input::DeleteTableVersionInput).
pub mod delete_table_version_input {
/// A builder for [`DeleteTableVersionInput`](crate::input::DeleteTableVersionInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) catalog_id: std::option::Option<std::string::String>,
pub(crate) database_name: std::option::Option<std::string::String>,
pub(crate) table_name: std::option::Option<std::string::String>,
pub(crate) version_id: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The ID of the Data Catalog where the tables reside. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(mut self, input: impl Into<std::string::String>) -> Self {
self.catalog_id = Some(input.into());
self
}
/// <p>The ID of the Data Catalog where the tables reside. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn set_catalog_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.catalog_id = input;
self
}
/// <p>The database in the catalog in which the table resides. For Hive compatibility, this name is entirely lowercase.</p>
pub fn database_name(mut self, input: impl Into<std::string::String>) -> Self {
self.database_name = Some(input.into());
self
}
/// <p>The database in the catalog in which the table resides. For Hive compatibility, this name is entirely lowercase.</p>
pub fn set_database_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.database_name = input;
self
}
/// <p>The name of the table. For Hive compatibility, this name is entirely lowercase.</p>
pub fn table_name(mut self, input: impl Into<std::string::String>) -> Self {
self.table_name = Some(input.into());
self
}
/// <p>The name of the table. For Hive compatibility, this name is entirely lowercase.</p>
pub fn set_table_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.table_name = input;
self
}
/// <p>The ID of the table version to be deleted. A <code>VersionID</code> is a string representation of an integer. Each version is incremented by 1.</p>
pub fn version_id(mut self, input: impl Into<std::string::String>) -> Self {
self.version_id = Some(input.into());
self
}
/// <p>The ID of the table version to be deleted. A <code>VersionID</code> is a string representation of an integer. Each version is incremented by 1.</p>
pub fn set_version_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.version_id = input;
self
}
/// Consumes the builder and constructs a [`DeleteTableVersionInput`](crate::input::DeleteTableVersionInput).
pub fn build(
self,
) -> Result<
crate::input::DeleteTableVersionInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::DeleteTableVersionInput {
catalog_id: self.catalog_id,
database_name: self.database_name,
table_name: self.table_name,
version_id: self.version_id,
})
}
}
}
impl DeleteTableVersionInput {
/// Consumes the builder and constructs an Operation<[`DeleteTableVersion`](crate::operation::DeleteTableVersion)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::DeleteTableVersion,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::DeleteTableVersionInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::DeleteTableVersionInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.DeleteTableVersion",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_delete_table_version(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::DeleteTableVersion::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DeleteTableVersion",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`DeleteTableVersionInput`](crate::input::DeleteTableVersionInput).
pub fn builder() -> crate::input::delete_table_version_input::Builder {
crate::input::delete_table_version_input::Builder::default()
}
}
/// See [`DeleteTriggerInput`](crate::input::DeleteTriggerInput).
pub mod delete_trigger_input {
/// A builder for [`DeleteTriggerInput`](crate::input::DeleteTriggerInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) name: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The name of the trigger to delete.</p>
pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
self.name = Some(input.into());
self
}
/// <p>The name of the trigger to delete.</p>
pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.name = input;
self
}
/// Consumes the builder and constructs a [`DeleteTriggerInput`](crate::input::DeleteTriggerInput).
pub fn build(
self,
) -> Result<crate::input::DeleteTriggerInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::DeleteTriggerInput { name: self.name })
}
}
}
impl DeleteTriggerInput {
/// Consumes the builder and constructs an Operation<[`DeleteTrigger`](crate::operation::DeleteTrigger)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::DeleteTrigger,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::DeleteTriggerInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::DeleteTriggerInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.DeleteTrigger",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_delete_trigger(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::DeleteTrigger::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DeleteTrigger",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`DeleteTriggerInput`](crate::input::DeleteTriggerInput).
pub fn builder() -> crate::input::delete_trigger_input::Builder {
crate::input::delete_trigger_input::Builder::default()
}
}
/// See [`DeleteUserDefinedFunctionInput`](crate::input::DeleteUserDefinedFunctionInput).
pub mod delete_user_defined_function_input {
/// A builder for [`DeleteUserDefinedFunctionInput`](crate::input::DeleteUserDefinedFunctionInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) catalog_id: std::option::Option<std::string::String>,
pub(crate) database_name: std::option::Option<std::string::String>,
pub(crate) function_name: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The ID of the Data Catalog where the function to be deleted is located. If none is supplied, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(mut self, input: impl Into<std::string::String>) -> Self {
self.catalog_id = Some(input.into());
self
}
/// <p>The ID of the Data Catalog where the function to be deleted is located. If none is supplied, the Amazon Web Services account ID is used by default.</p>
pub fn set_catalog_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.catalog_id = input;
self
}
/// <p>The name of the catalog database where the function is located.</p>
pub fn database_name(mut self, input: impl Into<std::string::String>) -> Self {
self.database_name = Some(input.into());
self
}
/// <p>The name of the catalog database where the function is located.</p>
pub fn set_database_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.database_name = input;
self
}
/// <p>The name of the function definition to be deleted.</p>
pub fn function_name(mut self, input: impl Into<std::string::String>) -> Self {
self.function_name = Some(input.into());
self
}
/// <p>The name of the function definition to be deleted.</p>
pub fn set_function_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.function_name = input;
self
}
/// Consumes the builder and constructs a [`DeleteUserDefinedFunctionInput`](crate::input::DeleteUserDefinedFunctionInput).
pub fn build(
self,
) -> Result<
crate::input::DeleteUserDefinedFunctionInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::DeleteUserDefinedFunctionInput {
catalog_id: self.catalog_id,
database_name: self.database_name,
function_name: self.function_name,
})
}
}
}
impl DeleteUserDefinedFunctionInput {
/// Consumes the builder and constructs an Operation<[`DeleteUserDefinedFunction`](crate::operation::DeleteUserDefinedFunction)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::DeleteUserDefinedFunction,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::DeleteUserDefinedFunctionInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::DeleteUserDefinedFunctionInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.DeleteUserDefinedFunction",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_delete_user_defined_function(
&self,
)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::DeleteUserDefinedFunction::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DeleteUserDefinedFunction",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`DeleteUserDefinedFunctionInput`](crate::input::DeleteUserDefinedFunctionInput).
pub fn builder() -> crate::input::delete_user_defined_function_input::Builder {
crate::input::delete_user_defined_function_input::Builder::default()
}
}
/// See [`DeleteWorkflowInput`](crate::input::DeleteWorkflowInput).
pub mod delete_workflow_input {
/// A builder for [`DeleteWorkflowInput`](crate::input::DeleteWorkflowInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) name: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>Name of the workflow to be deleted.</p>
pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
self.name = Some(input.into());
self
}
/// <p>Name of the workflow to be deleted.</p>
pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.name = input;
self
}
/// Consumes the builder and constructs a [`DeleteWorkflowInput`](crate::input::DeleteWorkflowInput).
pub fn build(
self,
) -> Result<crate::input::DeleteWorkflowInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::DeleteWorkflowInput { name: self.name })
}
}
}
impl DeleteWorkflowInput {
/// Consumes the builder and constructs an Operation<[`DeleteWorkflow`](crate::operation::DeleteWorkflow)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::DeleteWorkflow,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::DeleteWorkflowInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::DeleteWorkflowInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.DeleteWorkflow",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_delete_workflow(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::DeleteWorkflow::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DeleteWorkflow",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`DeleteWorkflowInput`](crate::input::DeleteWorkflowInput).
pub fn builder() -> crate::input::delete_workflow_input::Builder {
crate::input::delete_workflow_input::Builder::default()
}
}
/// See [`GetBlueprintInput`](crate::input::GetBlueprintInput).
pub mod get_blueprint_input {
/// A builder for [`GetBlueprintInput`](crate::input::GetBlueprintInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) name: std::option::Option<std::string::String>,
pub(crate) include_blueprint: std::option::Option<bool>,
pub(crate) include_parameter_spec: std::option::Option<bool>,
}
impl Builder {
/// <p>The name of the blueprint.</p>
pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
self.name = Some(input.into());
self
}
/// <p>The name of the blueprint.</p>
pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.name = input;
self
}
/// <p>Specifies whether or not to include the blueprint in the response.</p>
pub fn include_blueprint(mut self, input: bool) -> Self {
self.include_blueprint = Some(input);
self
}
/// <p>Specifies whether or not to include the blueprint in the response.</p>
pub fn set_include_blueprint(mut self, input: std::option::Option<bool>) -> Self {
self.include_blueprint = input;
self
}
/// <p>Specifies whether or not to include the parameter specification.</p>
pub fn include_parameter_spec(mut self, input: bool) -> Self {
self.include_parameter_spec = Some(input);
self
}
/// <p>Specifies whether or not to include the parameter specification.</p>
pub fn set_include_parameter_spec(mut self, input: std::option::Option<bool>) -> Self {
self.include_parameter_spec = input;
self
}
/// Consumes the builder and constructs a [`GetBlueprintInput`](crate::input::GetBlueprintInput).
pub fn build(
self,
) -> Result<crate::input::GetBlueprintInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::GetBlueprintInput {
name: self.name,
include_blueprint: self.include_blueprint,
include_parameter_spec: self.include_parameter_spec,
})
}
}
}
impl GetBlueprintInput {
/// Consumes the builder and constructs an Operation<[`GetBlueprint`](crate::operation::GetBlueprint)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetBlueprint,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::GetBlueprintInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetBlueprintInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.GetBlueprint",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_get_blueprint(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::GetBlueprint::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetBlueprint",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`GetBlueprintInput`](crate::input::GetBlueprintInput).
pub fn builder() -> crate::input::get_blueprint_input::Builder {
crate::input::get_blueprint_input::Builder::default()
}
}
/// See [`GetBlueprintRunInput`](crate::input::GetBlueprintRunInput).
pub mod get_blueprint_run_input {
/// A builder for [`GetBlueprintRunInput`](crate::input::GetBlueprintRunInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) blueprint_name: std::option::Option<std::string::String>,
pub(crate) run_id: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The name of the blueprint.</p>
pub fn blueprint_name(mut self, input: impl Into<std::string::String>) -> Self {
self.blueprint_name = Some(input.into());
self
}
/// <p>The name of the blueprint.</p>
pub fn set_blueprint_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.blueprint_name = input;
self
}
/// <p>The run ID for the blueprint run you want to retrieve.</p>
pub fn run_id(mut self, input: impl Into<std::string::String>) -> Self {
self.run_id = Some(input.into());
self
}
/// <p>The run ID for the blueprint run you want to retrieve.</p>
pub fn set_run_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.run_id = input;
self
}
/// Consumes the builder and constructs a [`GetBlueprintRunInput`](crate::input::GetBlueprintRunInput).
pub fn build(
self,
) -> Result<crate::input::GetBlueprintRunInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::GetBlueprintRunInput {
blueprint_name: self.blueprint_name,
run_id: self.run_id,
})
}
}
}
impl GetBlueprintRunInput {
/// Consumes the builder and constructs an Operation<[`GetBlueprintRun`](crate::operation::GetBlueprintRun)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetBlueprintRun,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::GetBlueprintRunInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetBlueprintRunInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.GetBlueprintRun",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_get_blueprint_run(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::GetBlueprintRun::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetBlueprintRun",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`GetBlueprintRunInput`](crate::input::GetBlueprintRunInput).
pub fn builder() -> crate::input::get_blueprint_run_input::Builder {
crate::input::get_blueprint_run_input::Builder::default()
}
}
/// See [`GetBlueprintRunsInput`](crate::input::GetBlueprintRunsInput).
pub mod get_blueprint_runs_input {
/// A builder for [`GetBlueprintRunsInput`](crate::input::GetBlueprintRunsInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) blueprint_name: std::option::Option<std::string::String>,
pub(crate) next_token: std::option::Option<std::string::String>,
pub(crate) max_results: std::option::Option<i32>,
}
impl Builder {
/// <p>The name of the blueprint.</p>
pub fn blueprint_name(mut self, input: impl Into<std::string::String>) -> Self {
self.blueprint_name = Some(input.into());
self
}
/// <p>The name of the blueprint.</p>
pub fn set_blueprint_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.blueprint_name = input;
self
}
/// <p>A continuation token, if this is a continuation request.</p>
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
/// <p>A continuation token, if this is a continuation request.</p>
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
/// <p>The maximum size of a list to return.</p>
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
/// <p>The maximum size of a list to return.</p>
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
/// Consumes the builder and constructs a [`GetBlueprintRunsInput`](crate::input::GetBlueprintRunsInput).
pub fn build(
self,
) -> Result<
crate::input::GetBlueprintRunsInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::GetBlueprintRunsInput {
blueprint_name: self.blueprint_name,
next_token: self.next_token,
max_results: self.max_results,
})
}
}
}
impl GetBlueprintRunsInput {
/// Consumes the builder and constructs an Operation<[`GetBlueprintRuns`](crate::operation::GetBlueprintRuns)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetBlueprintRuns,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::GetBlueprintRunsInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetBlueprintRunsInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.GetBlueprintRuns",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_get_blueprint_runs(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::GetBlueprintRuns::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetBlueprintRuns",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`GetBlueprintRunsInput`](crate::input::GetBlueprintRunsInput).
pub fn builder() -> crate::input::get_blueprint_runs_input::Builder {
crate::input::get_blueprint_runs_input::Builder::default()
}
}
/// See [`GetCatalogImportStatusInput`](crate::input::GetCatalogImportStatusInput).
pub mod get_catalog_import_status_input {
/// A builder for [`GetCatalogImportStatusInput`](crate::input::GetCatalogImportStatusInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) catalog_id: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The ID of the catalog to migrate. Currently, this should be the Amazon Web Services account ID.</p>
pub fn catalog_id(mut self, input: impl Into<std::string::String>) -> Self {
self.catalog_id = Some(input.into());
self
}
/// <p>The ID of the catalog to migrate. Currently, this should be the Amazon Web Services account ID.</p>
pub fn set_catalog_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.catalog_id = input;
self
}
/// Consumes the builder and constructs a [`GetCatalogImportStatusInput`](crate::input::GetCatalogImportStatusInput).
pub fn build(
self,
) -> Result<
crate::input::GetCatalogImportStatusInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::GetCatalogImportStatusInput {
catalog_id: self.catalog_id,
})
}
}
}
impl GetCatalogImportStatusInput {
/// Consumes the builder and constructs an Operation<[`GetCatalogImportStatus`](crate::operation::GetCatalogImportStatus)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetCatalogImportStatus,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::GetCatalogImportStatusInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetCatalogImportStatusInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.GetCatalogImportStatus",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_get_catalog_import_status(
&self,
)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::GetCatalogImportStatus::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetCatalogImportStatus",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`GetCatalogImportStatusInput`](crate::input::GetCatalogImportStatusInput).
pub fn builder() -> crate::input::get_catalog_import_status_input::Builder {
crate::input::get_catalog_import_status_input::Builder::default()
}
}
/// See [`GetClassifierInput`](crate::input::GetClassifierInput).
pub mod get_classifier_input {
/// A builder for [`GetClassifierInput`](crate::input::GetClassifierInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) name: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>Name of the classifier to retrieve.</p>
pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
self.name = Some(input.into());
self
}
/// <p>Name of the classifier to retrieve.</p>
pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.name = input;
self
}
/// Consumes the builder and constructs a [`GetClassifierInput`](crate::input::GetClassifierInput).
pub fn build(
self,
) -> Result<crate::input::GetClassifierInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::GetClassifierInput { name: self.name })
}
}
}
impl GetClassifierInput {
/// Consumes the builder and constructs an Operation<[`GetClassifier`](crate::operation::GetClassifier)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetClassifier,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::GetClassifierInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetClassifierInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.GetClassifier",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_get_classifier(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::GetClassifier::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetClassifier",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`GetClassifierInput`](crate::input::GetClassifierInput).
pub fn builder() -> crate::input::get_classifier_input::Builder {
crate::input::get_classifier_input::Builder::default()
}
}
/// See [`GetClassifiersInput`](crate::input::GetClassifiersInput).
pub mod get_classifiers_input {
/// A builder for [`GetClassifiersInput`](crate::input::GetClassifiersInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) max_results: std::option::Option<i32>,
pub(crate) next_token: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The size of the list to return (optional).</p>
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
/// <p>The size of the list to return (optional).</p>
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
/// <p>An optional continuation token.</p>
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
/// <p>An optional continuation token.</p>
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
/// Consumes the builder and constructs a [`GetClassifiersInput`](crate::input::GetClassifiersInput).
pub fn build(
self,
) -> Result<crate::input::GetClassifiersInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::GetClassifiersInput {
max_results: self.max_results,
next_token: self.next_token,
})
}
}
}
impl GetClassifiersInput {
/// Consumes the builder and constructs an Operation<[`GetClassifiers`](crate::operation::GetClassifiers)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetClassifiers,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::GetClassifiersInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetClassifiersInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.GetClassifiers",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_get_classifiers(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::GetClassifiers::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetClassifiers",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`GetClassifiersInput`](crate::input::GetClassifiersInput).
pub fn builder() -> crate::input::get_classifiers_input::Builder {
crate::input::get_classifiers_input::Builder::default()
}
}
/// See [`GetColumnStatisticsForPartitionInput`](crate::input::GetColumnStatisticsForPartitionInput).
pub mod get_column_statistics_for_partition_input {
/// A builder for [`GetColumnStatisticsForPartitionInput`](crate::input::GetColumnStatisticsForPartitionInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) catalog_id: std::option::Option<std::string::String>,
pub(crate) database_name: std::option::Option<std::string::String>,
pub(crate) table_name: std::option::Option<std::string::String>,
pub(crate) partition_values: std::option::Option<std::vec::Vec<std::string::String>>,
pub(crate) column_names: std::option::Option<std::vec::Vec<std::string::String>>,
}
impl Builder {
/// <p>The ID of the Data Catalog where the partitions in question reside. If none is supplied, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(mut self, input: impl Into<std::string::String>) -> Self {
self.catalog_id = Some(input.into());
self
}
/// <p>The ID of the Data Catalog where the partitions in question reside. If none is supplied, the Amazon Web Services account ID is used by default.</p>
pub fn set_catalog_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.catalog_id = input;
self
}
/// <p>The name of the catalog database where the partitions reside.</p>
pub fn database_name(mut self, input: impl Into<std::string::String>) -> Self {
self.database_name = Some(input.into());
self
}
/// <p>The name of the catalog database where the partitions reside.</p>
pub fn set_database_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.database_name = input;
self
}
/// <p>The name of the partitions' table.</p>
pub fn table_name(mut self, input: impl Into<std::string::String>) -> Self {
self.table_name = Some(input.into());
self
}
/// <p>The name of the partitions' table.</p>
pub fn set_table_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.table_name = input;
self
}
/// Appends an item to `partition_values`.
///
/// To override the contents of this collection use [`set_partition_values`](Self::set_partition_values).
///
/// <p>A list of partition values identifying the partition.</p>
pub fn partition_values(mut self, input: impl Into<std::string::String>) -> Self {
let mut v = self.partition_values.unwrap_or_default();
v.push(input.into());
self.partition_values = Some(v);
self
}
/// <p>A list of partition values identifying the partition.</p>
pub fn set_partition_values(
mut self,
input: std::option::Option<std::vec::Vec<std::string::String>>,
) -> Self {
self.partition_values = input;
self
}
/// Appends an item to `column_names`.
///
/// To override the contents of this collection use [`set_column_names`](Self::set_column_names).
///
/// <p>A list of the column names.</p>
pub fn column_names(mut self, input: impl Into<std::string::String>) -> Self {
let mut v = self.column_names.unwrap_or_default();
v.push(input.into());
self.column_names = Some(v);
self
}
/// <p>A list of the column names.</p>
pub fn set_column_names(
mut self,
input: std::option::Option<std::vec::Vec<std::string::String>>,
) -> Self {
self.column_names = input;
self
}
/// Consumes the builder and constructs a [`GetColumnStatisticsForPartitionInput`](crate::input::GetColumnStatisticsForPartitionInput).
pub fn build(
self,
) -> Result<
crate::input::GetColumnStatisticsForPartitionInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::GetColumnStatisticsForPartitionInput {
catalog_id: self.catalog_id,
database_name: self.database_name,
table_name: self.table_name,
partition_values: self.partition_values,
column_names: self.column_names,
})
}
}
}
impl GetColumnStatisticsForPartitionInput {
/// Consumes the builder and constructs an Operation<[`GetColumnStatisticsForPartition`](crate::operation::GetColumnStatisticsForPartition)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetColumnStatisticsForPartition,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::GetColumnStatisticsForPartitionInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetColumnStatisticsForPartitionInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.GetColumnStatisticsForPartition",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_get_column_statistics_for_partition(&self)?
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::GetColumnStatisticsForPartition::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetColumnStatisticsForPartition",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`GetColumnStatisticsForPartitionInput`](crate::input::GetColumnStatisticsForPartitionInput).
pub fn builder() -> crate::input::get_column_statistics_for_partition_input::Builder {
crate::input::get_column_statistics_for_partition_input::Builder::default()
}
}
/// See [`GetColumnStatisticsForTableInput`](crate::input::GetColumnStatisticsForTableInput).
pub mod get_column_statistics_for_table_input {
/// A builder for [`GetColumnStatisticsForTableInput`](crate::input::GetColumnStatisticsForTableInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) catalog_id: std::option::Option<std::string::String>,
pub(crate) database_name: std::option::Option<std::string::String>,
pub(crate) table_name: std::option::Option<std::string::String>,
pub(crate) column_names: std::option::Option<std::vec::Vec<std::string::String>>,
}
impl Builder {
/// <p>The ID of the Data Catalog where the partitions in question reside. If none is supplied, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(mut self, input: impl Into<std::string::String>) -> Self {
self.catalog_id = Some(input.into());
self
}
/// <p>The ID of the Data Catalog where the partitions in question reside. If none is supplied, the Amazon Web Services account ID is used by default.</p>
pub fn set_catalog_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.catalog_id = input;
self
}
/// <p>The name of the catalog database where the partitions reside.</p>
pub fn database_name(mut self, input: impl Into<std::string::String>) -> Self {
self.database_name = Some(input.into());
self
}
/// <p>The name of the catalog database where the partitions reside.</p>
pub fn set_database_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.database_name = input;
self
}
/// <p>The name of the partitions' table.</p>
pub fn table_name(mut self, input: impl Into<std::string::String>) -> Self {
self.table_name = Some(input.into());
self
}
/// <p>The name of the partitions' table.</p>
pub fn set_table_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.table_name = input;
self
}
/// Appends an item to `column_names`.
///
/// To override the contents of this collection use [`set_column_names`](Self::set_column_names).
///
/// <p>A list of the column names.</p>
pub fn column_names(mut self, input: impl Into<std::string::String>) -> Self {
let mut v = self.column_names.unwrap_or_default();
v.push(input.into());
self.column_names = Some(v);
self
}
/// <p>A list of the column names.</p>
pub fn set_column_names(
mut self,
input: std::option::Option<std::vec::Vec<std::string::String>>,
) -> Self {
self.column_names = input;
self
}
/// Consumes the builder and constructs a [`GetColumnStatisticsForTableInput`](crate::input::GetColumnStatisticsForTableInput).
pub fn build(
self,
) -> Result<
crate::input::GetColumnStatisticsForTableInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::GetColumnStatisticsForTableInput {
catalog_id: self.catalog_id,
database_name: self.database_name,
table_name: self.table_name,
column_names: self.column_names,
})
}
}
}
impl GetColumnStatisticsForTableInput {
/// Consumes the builder and constructs an Operation<[`GetColumnStatisticsForTable`](crate::operation::GetColumnStatisticsForTable)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetColumnStatisticsForTable,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::GetColumnStatisticsForTableInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetColumnStatisticsForTableInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.GetColumnStatisticsForTable",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_get_column_statistics_for_table(&self)?
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::GetColumnStatisticsForTable::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetColumnStatisticsForTable",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`GetColumnStatisticsForTableInput`](crate::input::GetColumnStatisticsForTableInput).
pub fn builder() -> crate::input::get_column_statistics_for_table_input::Builder {
crate::input::get_column_statistics_for_table_input::Builder::default()
}
}
/// See [`GetConnectionInput`](crate::input::GetConnectionInput).
pub mod get_connection_input {
/// A builder for [`GetConnectionInput`](crate::input::GetConnectionInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) catalog_id: std::option::Option<std::string::String>,
pub(crate) name: std::option::Option<std::string::String>,
pub(crate) hide_password: std::option::Option<bool>,
}
impl Builder {
/// <p>The ID of the Data Catalog in which the connection resides. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(mut self, input: impl Into<std::string::String>) -> Self {
self.catalog_id = Some(input.into());
self
}
/// <p>The ID of the Data Catalog in which the connection resides. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn set_catalog_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.catalog_id = input;
self
}
/// <p>The name of the connection definition to retrieve.</p>
pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
self.name = Some(input.into());
self
}
/// <p>The name of the connection definition to retrieve.</p>
pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.name = input;
self
}
/// <p>Allows you to retrieve the connection metadata without returning the password. For instance, the Glue console uses this flag to retrieve the connection, and does not display the password. Set this parameter when the caller might not have permission to use the KMS key to decrypt the password, but it does have permission to access the rest of the connection properties.</p>
pub fn hide_password(mut self, input: bool) -> Self {
self.hide_password = Some(input);
self
}
/// <p>Allows you to retrieve the connection metadata without returning the password. For instance, the Glue console uses this flag to retrieve the connection, and does not display the password. Set this parameter when the caller might not have permission to use the KMS key to decrypt the password, but it does have permission to access the rest of the connection properties.</p>
pub fn set_hide_password(mut self, input: std::option::Option<bool>) -> Self {
self.hide_password = input;
self
}
/// Consumes the builder and constructs a [`GetConnectionInput`](crate::input::GetConnectionInput).
pub fn build(
self,
) -> Result<crate::input::GetConnectionInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::GetConnectionInput {
catalog_id: self.catalog_id,
name: self.name,
hide_password: self.hide_password.unwrap_or_default(),
})
}
}
}
impl GetConnectionInput {
/// Consumes the builder and constructs an Operation<[`GetConnection`](crate::operation::GetConnection)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetConnection,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::GetConnectionInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetConnectionInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.GetConnection",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_get_connection(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::GetConnection::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetConnection",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`GetConnectionInput`](crate::input::GetConnectionInput).
pub fn builder() -> crate::input::get_connection_input::Builder {
crate::input::get_connection_input::Builder::default()
}
}
/// See [`GetConnectionsInput`](crate::input::GetConnectionsInput).
pub mod get_connections_input {
/// A builder for [`GetConnectionsInput`](crate::input::GetConnectionsInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) catalog_id: std::option::Option<std::string::String>,
pub(crate) filter: std::option::Option<crate::model::GetConnectionsFilter>,
pub(crate) hide_password: std::option::Option<bool>,
pub(crate) next_token: std::option::Option<std::string::String>,
pub(crate) max_results: std::option::Option<i32>,
}
impl Builder {
/// <p>The ID of the Data Catalog in which the connections reside. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(mut self, input: impl Into<std::string::String>) -> Self {
self.catalog_id = Some(input.into());
self
}
/// <p>The ID of the Data Catalog in which the connections reside. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn set_catalog_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.catalog_id = input;
self
}
/// <p>A filter that controls which connections are returned.</p>
pub fn filter(mut self, input: crate::model::GetConnectionsFilter) -> Self {
self.filter = Some(input);
self
}
/// <p>A filter that controls which connections are returned.</p>
pub fn set_filter(
mut self,
input: std::option::Option<crate::model::GetConnectionsFilter>,
) -> Self {
self.filter = input;
self
}
/// <p>Allows you to retrieve the connection metadata without returning the password. For instance, the Glue console uses this flag to retrieve the connection, and does not display the password. Set this parameter when the caller might not have permission to use the KMS key to decrypt the password, but it does have permission to access the rest of the connection properties.</p>
pub fn hide_password(mut self, input: bool) -> Self {
self.hide_password = Some(input);
self
}
/// <p>Allows you to retrieve the connection metadata without returning the password. For instance, the Glue console uses this flag to retrieve the connection, and does not display the password. Set this parameter when the caller might not have permission to use the KMS key to decrypt the password, but it does have permission to access the rest of the connection properties.</p>
pub fn set_hide_password(mut self, input: std::option::Option<bool>) -> Self {
self.hide_password = input;
self
}
/// <p>A continuation token, if this is a continuation call.</p>
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
/// <p>A continuation token, if this is a continuation call.</p>
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
/// <p>The maximum number of connections to return in one response.</p>
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
/// <p>The maximum number of connections to return in one response.</p>
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
/// Consumes the builder and constructs a [`GetConnectionsInput`](crate::input::GetConnectionsInput).
pub fn build(
self,
) -> Result<crate::input::GetConnectionsInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::GetConnectionsInput {
catalog_id: self.catalog_id,
filter: self.filter,
hide_password: self.hide_password.unwrap_or_default(),
next_token: self.next_token,
max_results: self.max_results,
})
}
}
}
impl GetConnectionsInput {
/// Consumes the builder and constructs an Operation<[`GetConnections`](crate::operation::GetConnections)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetConnections,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::GetConnectionsInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetConnectionsInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.GetConnections",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_get_connections(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::GetConnections::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetConnections",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`GetConnectionsInput`](crate::input::GetConnectionsInput).
pub fn builder() -> crate::input::get_connections_input::Builder {
crate::input::get_connections_input::Builder::default()
}
}
/// See [`GetCrawlerInput`](crate::input::GetCrawlerInput).
pub mod get_crawler_input {
/// A builder for [`GetCrawlerInput`](crate::input::GetCrawlerInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) name: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The name of the crawler to retrieve metadata for.</p>
pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
self.name = Some(input.into());
self
}
/// <p>The name of the crawler to retrieve metadata for.</p>
pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.name = input;
self
}
/// Consumes the builder and constructs a [`GetCrawlerInput`](crate::input::GetCrawlerInput).
pub fn build(
self,
) -> Result<crate::input::GetCrawlerInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::GetCrawlerInput { name: self.name })
}
}
}
impl GetCrawlerInput {
/// Consumes the builder and constructs an Operation<[`GetCrawler`](crate::operation::GetCrawler)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetCrawler,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::GetCrawlerInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetCrawlerInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.GetCrawler",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_get_crawler(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::GetCrawler::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetCrawler",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`GetCrawlerInput`](crate::input::GetCrawlerInput).
pub fn builder() -> crate::input::get_crawler_input::Builder {
crate::input::get_crawler_input::Builder::default()
}
}
/// See [`GetCrawlerMetricsInput`](crate::input::GetCrawlerMetricsInput).
pub mod get_crawler_metrics_input {
/// A builder for [`GetCrawlerMetricsInput`](crate::input::GetCrawlerMetricsInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) crawler_name_list: std::option::Option<std::vec::Vec<std::string::String>>,
pub(crate) max_results: std::option::Option<i32>,
pub(crate) next_token: std::option::Option<std::string::String>,
}
impl Builder {
/// Appends an item to `crawler_name_list`.
///
/// To override the contents of this collection use [`set_crawler_name_list`](Self::set_crawler_name_list).
///
/// <p>A list of the names of crawlers about which to retrieve metrics.</p>
pub fn crawler_name_list(mut self, input: impl Into<std::string::String>) -> Self {
let mut v = self.crawler_name_list.unwrap_or_default();
v.push(input.into());
self.crawler_name_list = Some(v);
self
}
/// <p>A list of the names of crawlers about which to retrieve metrics.</p>
pub fn set_crawler_name_list(
mut self,
input: std::option::Option<std::vec::Vec<std::string::String>>,
) -> Self {
self.crawler_name_list = input;
self
}
/// <p>The maximum size of a list to return.</p>
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
/// <p>The maximum size of a list to return.</p>
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
/// <p>A continuation token, if this is a continuation call.</p>
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
/// <p>A continuation token, if this is a continuation call.</p>
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
/// Consumes the builder and constructs a [`GetCrawlerMetricsInput`](crate::input::GetCrawlerMetricsInput).
pub fn build(
self,
) -> Result<
crate::input::GetCrawlerMetricsInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::GetCrawlerMetricsInput {
crawler_name_list: self.crawler_name_list,
max_results: self.max_results,
next_token: self.next_token,
})
}
}
}
impl GetCrawlerMetricsInput {
/// Consumes the builder and constructs an Operation<[`GetCrawlerMetrics`](crate::operation::GetCrawlerMetrics)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetCrawlerMetrics,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::GetCrawlerMetricsInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetCrawlerMetricsInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.GetCrawlerMetrics",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_get_crawler_metrics(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::GetCrawlerMetrics::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetCrawlerMetrics",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`GetCrawlerMetricsInput`](crate::input::GetCrawlerMetricsInput).
pub fn builder() -> crate::input::get_crawler_metrics_input::Builder {
crate::input::get_crawler_metrics_input::Builder::default()
}
}
/// See [`GetCrawlersInput`](crate::input::GetCrawlersInput).
pub mod get_crawlers_input {
/// A builder for [`GetCrawlersInput`](crate::input::GetCrawlersInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) max_results: std::option::Option<i32>,
pub(crate) next_token: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The number of crawlers to return on each call.</p>
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
/// <p>The number of crawlers to return on each call.</p>
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
/// <p>A continuation token, if this is a continuation request.</p>
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
/// <p>A continuation token, if this is a continuation request.</p>
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
/// Consumes the builder and constructs a [`GetCrawlersInput`](crate::input::GetCrawlersInput).
pub fn build(
self,
) -> Result<crate::input::GetCrawlersInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::GetCrawlersInput {
max_results: self.max_results,
next_token: self.next_token,
})
}
}
}
impl GetCrawlersInput {
/// Consumes the builder and constructs an Operation<[`GetCrawlers`](crate::operation::GetCrawlers)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetCrawlers,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::GetCrawlersInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetCrawlersInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.GetCrawlers",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_get_crawlers(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::GetCrawlers::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetCrawlers",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`GetCrawlersInput`](crate::input::GetCrawlersInput).
pub fn builder() -> crate::input::get_crawlers_input::Builder {
crate::input::get_crawlers_input::Builder::default()
}
}
/// See [`GetCustomEntityTypeInput`](crate::input::GetCustomEntityTypeInput).
pub mod get_custom_entity_type_input {
/// A builder for [`GetCustomEntityTypeInput`](crate::input::GetCustomEntityTypeInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) name: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The name of the custom pattern that you want to retrieve.</p>
pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
self.name = Some(input.into());
self
}
/// <p>The name of the custom pattern that you want to retrieve.</p>
pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.name = input;
self
}
/// Consumes the builder and constructs a [`GetCustomEntityTypeInput`](crate::input::GetCustomEntityTypeInput).
pub fn build(
self,
) -> Result<
crate::input::GetCustomEntityTypeInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::GetCustomEntityTypeInput { name: self.name })
}
}
}
impl GetCustomEntityTypeInput {
/// Consumes the builder and constructs an Operation<[`GetCustomEntityType`](crate::operation::GetCustomEntityType)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetCustomEntityType,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::GetCustomEntityTypeInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetCustomEntityTypeInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.GetCustomEntityType",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_get_custom_entity_type(
&self,
)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::GetCustomEntityType::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetCustomEntityType",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`GetCustomEntityTypeInput`](crate::input::GetCustomEntityTypeInput).
pub fn builder() -> crate::input::get_custom_entity_type_input::Builder {
crate::input::get_custom_entity_type_input::Builder::default()
}
}
/// See [`GetDatabaseInput`](crate::input::GetDatabaseInput).
pub mod get_database_input {
/// A builder for [`GetDatabaseInput`](crate::input::GetDatabaseInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) catalog_id: std::option::Option<std::string::String>,
pub(crate) name: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The ID of the Data Catalog in which the database resides. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(mut self, input: impl Into<std::string::String>) -> Self {
self.catalog_id = Some(input.into());
self
}
/// <p>The ID of the Data Catalog in which the database resides. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn set_catalog_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.catalog_id = input;
self
}
/// <p>The name of the database to retrieve. For Hive compatibility, this should be all lowercase.</p>
pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
self.name = Some(input.into());
self
}
/// <p>The name of the database to retrieve. For Hive compatibility, this should be all lowercase.</p>
pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.name = input;
self
}
/// Consumes the builder and constructs a [`GetDatabaseInput`](crate::input::GetDatabaseInput).
pub fn build(
self,
) -> Result<crate::input::GetDatabaseInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::GetDatabaseInput {
catalog_id: self.catalog_id,
name: self.name,
})
}
}
}
impl GetDatabaseInput {
/// Consumes the builder and constructs an Operation<[`GetDatabase`](crate::operation::GetDatabase)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetDatabase,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::GetDatabaseInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetDatabaseInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.GetDatabase",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_get_database(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::GetDatabase::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetDatabase",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`GetDatabaseInput`](crate::input::GetDatabaseInput).
pub fn builder() -> crate::input::get_database_input::Builder {
crate::input::get_database_input::Builder::default()
}
}
/// See [`GetDatabasesInput`](crate::input::GetDatabasesInput).
pub mod get_databases_input {
/// A builder for [`GetDatabasesInput`](crate::input::GetDatabasesInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) catalog_id: std::option::Option<std::string::String>,
pub(crate) next_token: std::option::Option<std::string::String>,
pub(crate) max_results: std::option::Option<i32>,
pub(crate) resource_share_type: std::option::Option<crate::model::ResourceShareType>,
}
impl Builder {
/// <p>The ID of the Data Catalog from which to retrieve <code>Databases</code>. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(mut self, input: impl Into<std::string::String>) -> Self {
self.catalog_id = Some(input.into());
self
}
/// <p>The ID of the Data Catalog from which to retrieve <code>Databases</code>. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn set_catalog_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.catalog_id = input;
self
}
/// <p>A continuation token, if this is a continuation call.</p>
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
/// <p>A continuation token, if this is a continuation call.</p>
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
/// <p>The maximum number of databases to return in one response.</p>
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
/// <p>The maximum number of databases to return in one response.</p>
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
/// <p>Allows you to specify that you want to list the databases shared with your account. The allowable values are <code>FOREIGN</code> or <code>ALL</code>. </p>
/// <ul>
/// <li> <p>If set to <code>FOREIGN</code>, will list the databases shared with your account. </p> </li>
/// <li> <p>If set to <code>ALL</code>, will list the databases shared with your account, as well as the databases in yor local account. </p> </li>
/// </ul>
pub fn resource_share_type(mut self, input: crate::model::ResourceShareType) -> Self {
self.resource_share_type = Some(input);
self
}
/// <p>Allows you to specify that you want to list the databases shared with your account. The allowable values are <code>FOREIGN</code> or <code>ALL</code>. </p>
/// <ul>
/// <li> <p>If set to <code>FOREIGN</code>, will list the databases shared with your account. </p> </li>
/// <li> <p>If set to <code>ALL</code>, will list the databases shared with your account, as well as the databases in yor local account. </p> </li>
/// </ul>
pub fn set_resource_share_type(
mut self,
input: std::option::Option<crate::model::ResourceShareType>,
) -> Self {
self.resource_share_type = input;
self
}
/// Consumes the builder and constructs a [`GetDatabasesInput`](crate::input::GetDatabasesInput).
pub fn build(
self,
) -> Result<crate::input::GetDatabasesInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::GetDatabasesInput {
catalog_id: self.catalog_id,
next_token: self.next_token,
max_results: self.max_results,
resource_share_type: self.resource_share_type,
})
}
}
}
impl GetDatabasesInput {
/// Consumes the builder and constructs an Operation<[`GetDatabases`](crate::operation::GetDatabases)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetDatabases,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::GetDatabasesInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetDatabasesInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.GetDatabases",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_get_databases(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::GetDatabases::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetDatabases",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`GetDatabasesInput`](crate::input::GetDatabasesInput).
pub fn builder() -> crate::input::get_databases_input::Builder {
crate::input::get_databases_input::Builder::default()
}
}
/// See [`GetDataCatalogEncryptionSettingsInput`](crate::input::GetDataCatalogEncryptionSettingsInput).
pub mod get_data_catalog_encryption_settings_input {
/// A builder for [`GetDataCatalogEncryptionSettingsInput`](crate::input::GetDataCatalogEncryptionSettingsInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) catalog_id: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The ID of the Data Catalog to retrieve the security configuration for. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(mut self, input: impl Into<std::string::String>) -> Self {
self.catalog_id = Some(input.into());
self
}
/// <p>The ID of the Data Catalog to retrieve the security configuration for. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn set_catalog_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.catalog_id = input;
self
}
/// Consumes the builder and constructs a [`GetDataCatalogEncryptionSettingsInput`](crate::input::GetDataCatalogEncryptionSettingsInput).
pub fn build(
self,
) -> Result<
crate::input::GetDataCatalogEncryptionSettingsInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::GetDataCatalogEncryptionSettingsInput {
catalog_id: self.catalog_id,
})
}
}
}
impl GetDataCatalogEncryptionSettingsInput {
/// Consumes the builder and constructs an Operation<[`GetDataCatalogEncryptionSettings`](crate::operation::GetDataCatalogEncryptionSettings)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetDataCatalogEncryptionSettings,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::GetDataCatalogEncryptionSettingsInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetDataCatalogEncryptionSettingsInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.GetDataCatalogEncryptionSettings",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_get_data_catalog_encryption_settings(&self)?
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::GetDataCatalogEncryptionSettings::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetDataCatalogEncryptionSettings",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`GetDataCatalogEncryptionSettingsInput`](crate::input::GetDataCatalogEncryptionSettingsInput).
pub fn builder() -> crate::input::get_data_catalog_encryption_settings_input::Builder {
crate::input::get_data_catalog_encryption_settings_input::Builder::default()
}
}
/// See [`GetDataflowGraphInput`](crate::input::GetDataflowGraphInput).
pub mod get_dataflow_graph_input {
/// A builder for [`GetDataflowGraphInput`](crate::input::GetDataflowGraphInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) python_script: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The Python script to transform.</p>
pub fn python_script(mut self, input: impl Into<std::string::String>) -> Self {
self.python_script = Some(input.into());
self
}
/// <p>The Python script to transform.</p>
pub fn set_python_script(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.python_script = input;
self
}
/// Consumes the builder and constructs a [`GetDataflowGraphInput`](crate::input::GetDataflowGraphInput).
pub fn build(
self,
) -> Result<
crate::input::GetDataflowGraphInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::GetDataflowGraphInput {
python_script: self.python_script,
})
}
}
}
impl GetDataflowGraphInput {
/// Consumes the builder and constructs an Operation<[`GetDataflowGraph`](crate::operation::GetDataflowGraph)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetDataflowGraph,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::GetDataflowGraphInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetDataflowGraphInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.GetDataflowGraph",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_get_dataflow_graph(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::GetDataflowGraph::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetDataflowGraph",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`GetDataflowGraphInput`](crate::input::GetDataflowGraphInput).
pub fn builder() -> crate::input::get_dataflow_graph_input::Builder {
crate::input::get_dataflow_graph_input::Builder::default()
}
}
/// See [`GetDataQualityResultInput`](crate::input::GetDataQualityResultInput).
pub mod get_data_quality_result_input {
/// A builder for [`GetDataQualityResultInput`](crate::input::GetDataQualityResultInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) result_id: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>A unique result ID for the data quality result.</p>
pub fn result_id(mut self, input: impl Into<std::string::String>) -> Self {
self.result_id = Some(input.into());
self
}
/// <p>A unique result ID for the data quality result.</p>
pub fn set_result_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.result_id = input;
self
}
/// Consumes the builder and constructs a [`GetDataQualityResultInput`](crate::input::GetDataQualityResultInput).
pub fn build(
self,
) -> Result<
crate::input::GetDataQualityResultInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::GetDataQualityResultInput {
result_id: self.result_id,
})
}
}
}
impl GetDataQualityResultInput {
/// Consumes the builder and constructs an Operation<[`GetDataQualityResult`](crate::operation::GetDataQualityResult)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetDataQualityResult,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::GetDataQualityResultInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetDataQualityResultInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.GetDataQualityResult",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_get_data_quality_result(
&self,
)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::GetDataQualityResult::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetDataQualityResult",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`GetDataQualityResultInput`](crate::input::GetDataQualityResultInput).
pub fn builder() -> crate::input::get_data_quality_result_input::Builder {
crate::input::get_data_quality_result_input::Builder::default()
}
}
/// See [`GetDataQualityRuleRecommendationRunInput`](crate::input::GetDataQualityRuleRecommendationRunInput).
pub mod get_data_quality_rule_recommendation_run_input {
/// A builder for [`GetDataQualityRuleRecommendationRunInput`](crate::input::GetDataQualityRuleRecommendationRunInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) run_id: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The unique run identifier associated with this run.</p>
pub fn run_id(mut self, input: impl Into<std::string::String>) -> Self {
self.run_id = Some(input.into());
self
}
/// <p>The unique run identifier associated with this run.</p>
pub fn set_run_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.run_id = input;
self
}
/// Consumes the builder and constructs a [`GetDataQualityRuleRecommendationRunInput`](crate::input::GetDataQualityRuleRecommendationRunInput).
pub fn build(
self,
) -> Result<
crate::input::GetDataQualityRuleRecommendationRunInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::GetDataQualityRuleRecommendationRunInput {
run_id: self.run_id,
})
}
}
}
impl GetDataQualityRuleRecommendationRunInput {
/// Consumes the builder and constructs an Operation<[`GetDataQualityRuleRecommendationRun`](crate::operation::GetDataQualityRuleRecommendationRun)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetDataQualityRuleRecommendationRun,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::GetDataQualityRuleRecommendationRunInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetDataQualityRuleRecommendationRunInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.GetDataQualityRuleRecommendationRun",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_get_data_quality_rule_recommendation_run(&self)?
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::GetDataQualityRuleRecommendationRun::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetDataQualityRuleRecommendationRun",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`GetDataQualityRuleRecommendationRunInput`](crate::input::GetDataQualityRuleRecommendationRunInput).
pub fn builder() -> crate::input::get_data_quality_rule_recommendation_run_input::Builder {
crate::input::get_data_quality_rule_recommendation_run_input::Builder::default()
}
}
/// See [`GetDataQualityRulesetInput`](crate::input::GetDataQualityRulesetInput).
pub mod get_data_quality_ruleset_input {
/// A builder for [`GetDataQualityRulesetInput`](crate::input::GetDataQualityRulesetInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) name: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The name of the ruleset.</p>
pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
self.name = Some(input.into());
self
}
/// <p>The name of the ruleset.</p>
pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.name = input;
self
}
/// Consumes the builder and constructs a [`GetDataQualityRulesetInput`](crate::input::GetDataQualityRulesetInput).
pub fn build(
self,
) -> Result<
crate::input::GetDataQualityRulesetInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::GetDataQualityRulesetInput { name: self.name })
}
}
}
impl GetDataQualityRulesetInput {
/// Consumes the builder and constructs an Operation<[`GetDataQualityRuleset`](crate::operation::GetDataQualityRuleset)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetDataQualityRuleset,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::GetDataQualityRulesetInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetDataQualityRulesetInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.GetDataQualityRuleset",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_get_data_quality_ruleset(
&self,
)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::GetDataQualityRuleset::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetDataQualityRuleset",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`GetDataQualityRulesetInput`](crate::input::GetDataQualityRulesetInput).
pub fn builder() -> crate::input::get_data_quality_ruleset_input::Builder {
crate::input::get_data_quality_ruleset_input::Builder::default()
}
}
/// See [`GetDataQualityRulesetEvaluationRunInput`](crate::input::GetDataQualityRulesetEvaluationRunInput).
pub mod get_data_quality_ruleset_evaluation_run_input {
/// A builder for [`GetDataQualityRulesetEvaluationRunInput`](crate::input::GetDataQualityRulesetEvaluationRunInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) run_id: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The unique run identifier associated with this run.</p>
pub fn run_id(mut self, input: impl Into<std::string::String>) -> Self {
self.run_id = Some(input.into());
self
}
/// <p>The unique run identifier associated with this run.</p>
pub fn set_run_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.run_id = input;
self
}
/// Consumes the builder and constructs a [`GetDataQualityRulesetEvaluationRunInput`](crate::input::GetDataQualityRulesetEvaluationRunInput).
pub fn build(
self,
) -> Result<
crate::input::GetDataQualityRulesetEvaluationRunInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::GetDataQualityRulesetEvaluationRunInput {
run_id: self.run_id,
})
}
}
}
impl GetDataQualityRulesetEvaluationRunInput {
/// Consumes the builder and constructs an Operation<[`GetDataQualityRulesetEvaluationRun`](crate::operation::GetDataQualityRulesetEvaluationRun)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetDataQualityRulesetEvaluationRun,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::GetDataQualityRulesetEvaluationRunInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetDataQualityRulesetEvaluationRunInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.GetDataQualityRulesetEvaluationRun",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_get_data_quality_ruleset_evaluation_run(&self)?
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::GetDataQualityRulesetEvaluationRun::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetDataQualityRulesetEvaluationRun",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`GetDataQualityRulesetEvaluationRunInput`](crate::input::GetDataQualityRulesetEvaluationRunInput).
pub fn builder() -> crate::input::get_data_quality_ruleset_evaluation_run_input::Builder {
crate::input::get_data_quality_ruleset_evaluation_run_input::Builder::default()
}
}
/// See [`GetDevEndpointInput`](crate::input::GetDevEndpointInput).
pub mod get_dev_endpoint_input {
/// A builder for [`GetDevEndpointInput`](crate::input::GetDevEndpointInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) endpoint_name: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>Name of the <code>DevEndpoint</code> to retrieve information for.</p>
pub fn endpoint_name(mut self, input: impl Into<std::string::String>) -> Self {
self.endpoint_name = Some(input.into());
self
}
/// <p>Name of the <code>DevEndpoint</code> to retrieve information for.</p>
pub fn set_endpoint_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.endpoint_name = input;
self
}
/// Consumes the builder and constructs a [`GetDevEndpointInput`](crate::input::GetDevEndpointInput).
pub fn build(
self,
) -> Result<crate::input::GetDevEndpointInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::GetDevEndpointInput {
endpoint_name: self.endpoint_name,
})
}
}
}
impl GetDevEndpointInput {
/// Consumes the builder and constructs an Operation<[`GetDevEndpoint`](crate::operation::GetDevEndpoint)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetDevEndpoint,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::GetDevEndpointInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetDevEndpointInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.GetDevEndpoint",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_get_dev_endpoint(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::GetDevEndpoint::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetDevEndpoint",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`GetDevEndpointInput`](crate::input::GetDevEndpointInput).
pub fn builder() -> crate::input::get_dev_endpoint_input::Builder {
crate::input::get_dev_endpoint_input::Builder::default()
}
}
/// See [`GetDevEndpointsInput`](crate::input::GetDevEndpointsInput).
pub mod get_dev_endpoints_input {
/// A builder for [`GetDevEndpointsInput`](crate::input::GetDevEndpointsInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) max_results: std::option::Option<i32>,
pub(crate) next_token: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The maximum size of information to return.</p>
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
/// <p>The maximum size of information to return.</p>
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
/// <p>A continuation token, if this is a continuation call.</p>
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
/// <p>A continuation token, if this is a continuation call.</p>
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
/// Consumes the builder and constructs a [`GetDevEndpointsInput`](crate::input::GetDevEndpointsInput).
pub fn build(
self,
) -> Result<crate::input::GetDevEndpointsInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::GetDevEndpointsInput {
max_results: self.max_results,
next_token: self.next_token,
})
}
}
}
impl GetDevEndpointsInput {
/// Consumes the builder and constructs an Operation<[`GetDevEndpoints`](crate::operation::GetDevEndpoints)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetDevEndpoints,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::GetDevEndpointsInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetDevEndpointsInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.GetDevEndpoints",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_get_dev_endpoints(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::GetDevEndpoints::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetDevEndpoints",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`GetDevEndpointsInput`](crate::input::GetDevEndpointsInput).
pub fn builder() -> crate::input::get_dev_endpoints_input::Builder {
crate::input::get_dev_endpoints_input::Builder::default()
}
}
/// See [`GetJobInput`](crate::input::GetJobInput).
pub mod get_job_input {
/// A builder for [`GetJobInput`](crate::input::GetJobInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) job_name: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The name of the job definition to retrieve.</p>
pub fn job_name(mut self, input: impl Into<std::string::String>) -> Self {
self.job_name = Some(input.into());
self
}
/// <p>The name of the job definition to retrieve.</p>
pub fn set_job_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.job_name = input;
self
}
/// Consumes the builder and constructs a [`GetJobInput`](crate::input::GetJobInput).
pub fn build(
self,
) -> Result<crate::input::GetJobInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::GetJobInput {
job_name: self.job_name,
})
}
}
}
impl GetJobInput {
/// Consumes the builder and constructs an Operation<[`GetJob`](crate::operation::GetJob)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetJob,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::GetJobInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetJobInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.GetJob",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_get_job(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op =
aws_smithy_http::operation::Operation::new(request, crate::operation::GetJob::new())
.with_metadata(aws_smithy_http::operation::Metadata::new("GetJob", "glue"));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`GetJobInput`](crate::input::GetJobInput).
pub fn builder() -> crate::input::get_job_input::Builder {
crate::input::get_job_input::Builder::default()
}
}
/// See [`GetJobBookmarkInput`](crate::input::GetJobBookmarkInput).
pub mod get_job_bookmark_input {
/// A builder for [`GetJobBookmarkInput`](crate::input::GetJobBookmarkInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) job_name: std::option::Option<std::string::String>,
pub(crate) run_id: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The name of the job in question.</p>
pub fn job_name(mut self, input: impl Into<std::string::String>) -> Self {
self.job_name = Some(input.into());
self
}
/// <p>The name of the job in question.</p>
pub fn set_job_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.job_name = input;
self
}
/// <p>The unique run identifier associated with this job run.</p>
pub fn run_id(mut self, input: impl Into<std::string::String>) -> Self {
self.run_id = Some(input.into());
self
}
/// <p>The unique run identifier associated with this job run.</p>
pub fn set_run_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.run_id = input;
self
}
/// Consumes the builder and constructs a [`GetJobBookmarkInput`](crate::input::GetJobBookmarkInput).
pub fn build(
self,
) -> Result<crate::input::GetJobBookmarkInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::GetJobBookmarkInput {
job_name: self.job_name,
run_id: self.run_id,
})
}
}
}
impl GetJobBookmarkInput {
/// Consumes the builder and constructs an Operation<[`GetJobBookmark`](crate::operation::GetJobBookmark)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetJobBookmark,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::GetJobBookmarkInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetJobBookmarkInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.GetJobBookmark",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_get_job_bookmark(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::GetJobBookmark::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetJobBookmark",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`GetJobBookmarkInput`](crate::input::GetJobBookmarkInput).
pub fn builder() -> crate::input::get_job_bookmark_input::Builder {
crate::input::get_job_bookmark_input::Builder::default()
}
}
/// See [`GetJobRunInput`](crate::input::GetJobRunInput).
pub mod get_job_run_input {
/// A builder for [`GetJobRunInput`](crate::input::GetJobRunInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) job_name: std::option::Option<std::string::String>,
pub(crate) run_id: std::option::Option<std::string::String>,
pub(crate) predecessors_included: std::option::Option<bool>,
}
impl Builder {
/// <p>Name of the job definition being run.</p>
pub fn job_name(mut self, input: impl Into<std::string::String>) -> Self {
self.job_name = Some(input.into());
self
}
/// <p>Name of the job definition being run.</p>
pub fn set_job_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.job_name = input;
self
}
/// <p>The ID of the job run.</p>
pub fn run_id(mut self, input: impl Into<std::string::String>) -> Self {
self.run_id = Some(input.into());
self
}
/// <p>The ID of the job run.</p>
pub fn set_run_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.run_id = input;
self
}
/// <p>True if a list of predecessor runs should be returned.</p>
pub fn predecessors_included(mut self, input: bool) -> Self {
self.predecessors_included = Some(input);
self
}
/// <p>True if a list of predecessor runs should be returned.</p>
pub fn set_predecessors_included(mut self, input: std::option::Option<bool>) -> Self {
self.predecessors_included = input;
self
}
/// Consumes the builder and constructs a [`GetJobRunInput`](crate::input::GetJobRunInput).
pub fn build(
self,
) -> Result<crate::input::GetJobRunInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::GetJobRunInput {
job_name: self.job_name,
run_id: self.run_id,
predecessors_included: self.predecessors_included.unwrap_or_default(),
})
}
}
}
impl GetJobRunInput {
/// Consumes the builder and constructs an Operation<[`GetJobRun`](crate::operation::GetJobRun)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetJobRun,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::GetJobRunInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetJobRunInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.GetJobRun",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_get_job_run(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op =
aws_smithy_http::operation::Operation::new(request, crate::operation::GetJobRun::new())
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetJobRun",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`GetJobRunInput`](crate::input::GetJobRunInput).
pub fn builder() -> crate::input::get_job_run_input::Builder {
crate::input::get_job_run_input::Builder::default()
}
}
/// See [`GetJobRunsInput`](crate::input::GetJobRunsInput).
pub mod get_job_runs_input {
/// A builder for [`GetJobRunsInput`](crate::input::GetJobRunsInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) job_name: std::option::Option<std::string::String>,
pub(crate) next_token: std::option::Option<std::string::String>,
pub(crate) max_results: std::option::Option<i32>,
}
impl Builder {
/// <p>The name of the job definition for which to retrieve all job runs.</p>
pub fn job_name(mut self, input: impl Into<std::string::String>) -> Self {
self.job_name = Some(input.into());
self
}
/// <p>The name of the job definition for which to retrieve all job runs.</p>
pub fn set_job_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.job_name = input;
self
}
/// <p>A continuation token, if this is a continuation call.</p>
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
/// <p>A continuation token, if this is a continuation call.</p>
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
/// <p>The maximum size of the response.</p>
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
/// <p>The maximum size of the response.</p>
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
/// Consumes the builder and constructs a [`GetJobRunsInput`](crate::input::GetJobRunsInput).
pub fn build(
self,
) -> Result<crate::input::GetJobRunsInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::GetJobRunsInput {
job_name: self.job_name,
next_token: self.next_token,
max_results: self.max_results,
})
}
}
}
impl GetJobRunsInput {
/// Consumes the builder and constructs an Operation<[`GetJobRuns`](crate::operation::GetJobRuns)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetJobRuns,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::GetJobRunsInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetJobRunsInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.GetJobRuns",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_get_job_runs(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::GetJobRuns::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetJobRuns",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`GetJobRunsInput`](crate::input::GetJobRunsInput).
pub fn builder() -> crate::input::get_job_runs_input::Builder {
crate::input::get_job_runs_input::Builder::default()
}
}
/// See [`GetJobsInput`](crate::input::GetJobsInput).
pub mod get_jobs_input {
/// A builder for [`GetJobsInput`](crate::input::GetJobsInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) next_token: std::option::Option<std::string::String>,
pub(crate) max_results: std::option::Option<i32>,
}
impl Builder {
/// <p>A continuation token, if this is a continuation call.</p>
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
/// <p>A continuation token, if this is a continuation call.</p>
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
/// <p>The maximum size of the response.</p>
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
/// <p>The maximum size of the response.</p>
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
/// Consumes the builder and constructs a [`GetJobsInput`](crate::input::GetJobsInput).
pub fn build(
self,
) -> Result<crate::input::GetJobsInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::GetJobsInput {
next_token: self.next_token,
max_results: self.max_results,
})
}
}
}
impl GetJobsInput {
/// Consumes the builder and constructs an Operation<[`GetJobs`](crate::operation::GetJobs)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetJobs,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::GetJobsInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetJobsInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.GetJobs",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_get_jobs(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op =
aws_smithy_http::operation::Operation::new(request, crate::operation::GetJobs::new())
.with_metadata(aws_smithy_http::operation::Metadata::new("GetJobs", "glue"));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`GetJobsInput`](crate::input::GetJobsInput).
pub fn builder() -> crate::input::get_jobs_input::Builder {
crate::input::get_jobs_input::Builder::default()
}
}
/// See [`GetMappingInput`](crate::input::GetMappingInput).
pub mod get_mapping_input {
/// A builder for [`GetMappingInput`](crate::input::GetMappingInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) source: std::option::Option<crate::model::CatalogEntry>,
pub(crate) sinks: std::option::Option<std::vec::Vec<crate::model::CatalogEntry>>,
pub(crate) location: std::option::Option<crate::model::Location>,
}
impl Builder {
/// <p>Specifies the source table.</p>
pub fn source(mut self, input: crate::model::CatalogEntry) -> Self {
self.source = Some(input);
self
}
/// <p>Specifies the source table.</p>
pub fn set_source(
mut self,
input: std::option::Option<crate::model::CatalogEntry>,
) -> Self {
self.source = input;
self
}
/// Appends an item to `sinks`.
///
/// To override the contents of this collection use [`set_sinks`](Self::set_sinks).
///
/// <p>A list of target tables.</p>
pub fn sinks(mut self, input: crate::model::CatalogEntry) -> Self {
let mut v = self.sinks.unwrap_or_default();
v.push(input);
self.sinks = Some(v);
self
}
/// <p>A list of target tables.</p>
pub fn set_sinks(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::CatalogEntry>>,
) -> Self {
self.sinks = input;
self
}
/// <p>Parameters for the mapping.</p>
pub fn location(mut self, input: crate::model::Location) -> Self {
self.location = Some(input);
self
}
/// <p>Parameters for the mapping.</p>
pub fn set_location(mut self, input: std::option::Option<crate::model::Location>) -> Self {
self.location = input;
self
}
/// Consumes the builder and constructs a [`GetMappingInput`](crate::input::GetMappingInput).
pub fn build(
self,
) -> Result<crate::input::GetMappingInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::GetMappingInput {
source: self.source,
sinks: self.sinks,
location: self.location,
})
}
}
}
impl GetMappingInput {
/// Consumes the builder and constructs an Operation<[`GetMapping`](crate::operation::GetMapping)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetMapping,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::GetMappingInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetMappingInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.GetMapping",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_get_mapping(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::GetMapping::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetMapping",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`GetMappingInput`](crate::input::GetMappingInput).
pub fn builder() -> crate::input::get_mapping_input::Builder {
crate::input::get_mapping_input::Builder::default()
}
}
/// See [`GetMlTaskRunInput`](crate::input::GetMlTaskRunInput).
pub mod get_ml_task_run_input {
/// A builder for [`GetMlTaskRunInput`](crate::input::GetMlTaskRunInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) transform_id: std::option::Option<std::string::String>,
pub(crate) task_run_id: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The unique identifier of the machine learning transform.</p>
pub fn transform_id(mut self, input: impl Into<std::string::String>) -> Self {
self.transform_id = Some(input.into());
self
}
/// <p>The unique identifier of the machine learning transform.</p>
pub fn set_transform_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.transform_id = input;
self
}
/// <p>The unique identifier of the task run.</p>
pub fn task_run_id(mut self, input: impl Into<std::string::String>) -> Self {
self.task_run_id = Some(input.into());
self
}
/// <p>The unique identifier of the task run.</p>
pub fn set_task_run_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.task_run_id = input;
self
}
/// Consumes the builder and constructs a [`GetMlTaskRunInput`](crate::input::GetMlTaskRunInput).
pub fn build(
self,
) -> Result<crate::input::GetMlTaskRunInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::GetMlTaskRunInput {
transform_id: self.transform_id,
task_run_id: self.task_run_id,
})
}
}
}
impl GetMlTaskRunInput {
/// Consumes the builder and constructs an Operation<[`GetMLTaskRun`](crate::operation::GetMLTaskRun)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetMLTaskRun,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::GetMlTaskRunInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetMlTaskRunInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.GetMLTaskRun",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_get_ml_task_run(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::GetMLTaskRun::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetMLTaskRun",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`GetMlTaskRunInput`](crate::input::GetMlTaskRunInput).
pub fn builder() -> crate::input::get_ml_task_run_input::Builder {
crate::input::get_ml_task_run_input::Builder::default()
}
}
/// See [`GetMlTaskRunsInput`](crate::input::GetMlTaskRunsInput).
pub mod get_ml_task_runs_input {
/// A builder for [`GetMlTaskRunsInput`](crate::input::GetMlTaskRunsInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) transform_id: std::option::Option<std::string::String>,
pub(crate) next_token: std::option::Option<std::string::String>,
pub(crate) max_results: std::option::Option<i32>,
pub(crate) filter: std::option::Option<crate::model::TaskRunFilterCriteria>,
pub(crate) sort: std::option::Option<crate::model::TaskRunSortCriteria>,
}
impl Builder {
/// <p>The unique identifier of the machine learning transform.</p>
pub fn transform_id(mut self, input: impl Into<std::string::String>) -> Self {
self.transform_id = Some(input.into());
self
}
/// <p>The unique identifier of the machine learning transform.</p>
pub fn set_transform_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.transform_id = input;
self
}
/// <p>A token for pagination of the results. The default is empty.</p>
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
/// <p>A token for pagination of the results. The default is empty.</p>
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
/// <p>The maximum number of results to return. </p>
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
/// <p>The maximum number of results to return. </p>
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
/// <p>The filter criteria, in the <code>TaskRunFilterCriteria</code> structure, for the task run.</p>
pub fn filter(mut self, input: crate::model::TaskRunFilterCriteria) -> Self {
self.filter = Some(input);
self
}
/// <p>The filter criteria, in the <code>TaskRunFilterCriteria</code> structure, for the task run.</p>
pub fn set_filter(
mut self,
input: std::option::Option<crate::model::TaskRunFilterCriteria>,
) -> Self {
self.filter = input;
self
}
/// <p>The sorting criteria, in the <code>TaskRunSortCriteria</code> structure, for the task run.</p>
pub fn sort(mut self, input: crate::model::TaskRunSortCriteria) -> Self {
self.sort = Some(input);
self
}
/// <p>The sorting criteria, in the <code>TaskRunSortCriteria</code> structure, for the task run.</p>
pub fn set_sort(
mut self,
input: std::option::Option<crate::model::TaskRunSortCriteria>,
) -> Self {
self.sort = input;
self
}
/// Consumes the builder and constructs a [`GetMlTaskRunsInput`](crate::input::GetMlTaskRunsInput).
pub fn build(
self,
) -> Result<crate::input::GetMlTaskRunsInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::GetMlTaskRunsInput {
transform_id: self.transform_id,
next_token: self.next_token,
max_results: self.max_results,
filter: self.filter,
sort: self.sort,
})
}
}
}
impl GetMlTaskRunsInput {
/// Consumes the builder and constructs an Operation<[`GetMLTaskRuns`](crate::operation::GetMLTaskRuns)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetMLTaskRuns,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::GetMlTaskRunsInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetMlTaskRunsInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.GetMLTaskRuns",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_get_ml_task_runs(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::GetMLTaskRuns::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetMLTaskRuns",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`GetMlTaskRunsInput`](crate::input::GetMlTaskRunsInput).
pub fn builder() -> crate::input::get_ml_task_runs_input::Builder {
crate::input::get_ml_task_runs_input::Builder::default()
}
}
/// See [`GetMlTransformInput`](crate::input::GetMlTransformInput).
pub mod get_ml_transform_input {
/// A builder for [`GetMlTransformInput`](crate::input::GetMlTransformInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) transform_id: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The unique identifier of the transform, generated at the time that the transform was created.</p>
pub fn transform_id(mut self, input: impl Into<std::string::String>) -> Self {
self.transform_id = Some(input.into());
self
}
/// <p>The unique identifier of the transform, generated at the time that the transform was created.</p>
pub fn set_transform_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.transform_id = input;
self
}
/// Consumes the builder and constructs a [`GetMlTransformInput`](crate::input::GetMlTransformInput).
pub fn build(
self,
) -> Result<crate::input::GetMlTransformInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::GetMlTransformInput {
transform_id: self.transform_id,
})
}
}
}
impl GetMlTransformInput {
/// Consumes the builder and constructs an Operation<[`GetMLTransform`](crate::operation::GetMLTransform)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetMLTransform,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::GetMlTransformInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetMlTransformInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.GetMLTransform",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_get_ml_transform(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::GetMLTransform::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetMLTransform",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`GetMlTransformInput`](crate::input::GetMlTransformInput).
pub fn builder() -> crate::input::get_ml_transform_input::Builder {
crate::input::get_ml_transform_input::Builder::default()
}
}
/// See [`GetMlTransformsInput`](crate::input::GetMlTransformsInput).
pub mod get_ml_transforms_input {
/// A builder for [`GetMlTransformsInput`](crate::input::GetMlTransformsInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) next_token: std::option::Option<std::string::String>,
pub(crate) max_results: std::option::Option<i32>,
pub(crate) filter: std::option::Option<crate::model::TransformFilterCriteria>,
pub(crate) sort: std::option::Option<crate::model::TransformSortCriteria>,
}
impl Builder {
/// <p>A paginated token to offset the results.</p>
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
/// <p>A paginated token to offset the results.</p>
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
/// <p>The maximum number of results to return.</p>
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
/// <p>The maximum number of results to return.</p>
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
/// <p>The filter transformation criteria.</p>
pub fn filter(mut self, input: crate::model::TransformFilterCriteria) -> Self {
self.filter = Some(input);
self
}
/// <p>The filter transformation criteria.</p>
pub fn set_filter(
mut self,
input: std::option::Option<crate::model::TransformFilterCriteria>,
) -> Self {
self.filter = input;
self
}
/// <p>The sorting criteria.</p>
pub fn sort(mut self, input: crate::model::TransformSortCriteria) -> Self {
self.sort = Some(input);
self
}
/// <p>The sorting criteria.</p>
pub fn set_sort(
mut self,
input: std::option::Option<crate::model::TransformSortCriteria>,
) -> Self {
self.sort = input;
self
}
/// Consumes the builder and constructs a [`GetMlTransformsInput`](crate::input::GetMlTransformsInput).
pub fn build(
self,
) -> Result<crate::input::GetMlTransformsInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::GetMlTransformsInput {
next_token: self.next_token,
max_results: self.max_results,
filter: self.filter,
sort: self.sort,
})
}
}
}
impl GetMlTransformsInput {
/// Consumes the builder and constructs an Operation<[`GetMLTransforms`](crate::operation::GetMLTransforms)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetMLTransforms,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::GetMlTransformsInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetMlTransformsInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.GetMLTransforms",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_get_ml_transforms(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::GetMLTransforms::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetMLTransforms",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`GetMlTransformsInput`](crate::input::GetMlTransformsInput).
pub fn builder() -> crate::input::get_ml_transforms_input::Builder {
crate::input::get_ml_transforms_input::Builder::default()
}
}
/// See [`GetPartitionInput`](crate::input::GetPartitionInput).
pub mod get_partition_input {
/// A builder for [`GetPartitionInput`](crate::input::GetPartitionInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) catalog_id: std::option::Option<std::string::String>,
pub(crate) database_name: std::option::Option<std::string::String>,
pub(crate) table_name: std::option::Option<std::string::String>,
pub(crate) partition_values: std::option::Option<std::vec::Vec<std::string::String>>,
}
impl Builder {
/// <p>The ID of the Data Catalog where the partition in question resides. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(mut self, input: impl Into<std::string::String>) -> Self {
self.catalog_id = Some(input.into());
self
}
/// <p>The ID of the Data Catalog where the partition in question resides. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn set_catalog_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.catalog_id = input;
self
}
/// <p>The name of the catalog database where the partition resides.</p>
pub fn database_name(mut self, input: impl Into<std::string::String>) -> Self {
self.database_name = Some(input.into());
self
}
/// <p>The name of the catalog database where the partition resides.</p>
pub fn set_database_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.database_name = input;
self
}
/// <p>The name of the partition's table.</p>
pub fn table_name(mut self, input: impl Into<std::string::String>) -> Self {
self.table_name = Some(input.into());
self
}
/// <p>The name of the partition's table.</p>
pub fn set_table_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.table_name = input;
self
}
/// Appends an item to `partition_values`.
///
/// To override the contents of this collection use [`set_partition_values`](Self::set_partition_values).
///
/// <p>The values that define the partition.</p>
pub fn partition_values(mut self, input: impl Into<std::string::String>) -> Self {
let mut v = self.partition_values.unwrap_or_default();
v.push(input.into());
self.partition_values = Some(v);
self
}
/// <p>The values that define the partition.</p>
pub fn set_partition_values(
mut self,
input: std::option::Option<std::vec::Vec<std::string::String>>,
) -> Self {
self.partition_values = input;
self
}
/// Consumes the builder and constructs a [`GetPartitionInput`](crate::input::GetPartitionInput).
pub fn build(
self,
) -> Result<crate::input::GetPartitionInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::GetPartitionInput {
catalog_id: self.catalog_id,
database_name: self.database_name,
table_name: self.table_name,
partition_values: self.partition_values,
})
}
}
}
impl GetPartitionInput {
/// Consumes the builder and constructs an Operation<[`GetPartition`](crate::operation::GetPartition)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetPartition,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::GetPartitionInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetPartitionInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.GetPartition",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_get_partition(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::GetPartition::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetPartition",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`GetPartitionInput`](crate::input::GetPartitionInput).
pub fn builder() -> crate::input::get_partition_input::Builder {
crate::input::get_partition_input::Builder::default()
}
}
/// See [`GetPartitionIndexesInput`](crate::input::GetPartitionIndexesInput).
pub mod get_partition_indexes_input {
/// A builder for [`GetPartitionIndexesInput`](crate::input::GetPartitionIndexesInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) catalog_id: std::option::Option<std::string::String>,
pub(crate) database_name: std::option::Option<std::string::String>,
pub(crate) table_name: std::option::Option<std::string::String>,
pub(crate) next_token: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The catalog ID where the table resides.</p>
pub fn catalog_id(mut self, input: impl Into<std::string::String>) -> Self {
self.catalog_id = Some(input.into());
self
}
/// <p>The catalog ID where the table resides.</p>
pub fn set_catalog_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.catalog_id = input;
self
}
/// <p>Specifies the name of a database from which you want to retrieve partition indexes.</p>
pub fn database_name(mut self, input: impl Into<std::string::String>) -> Self {
self.database_name = Some(input.into());
self
}
/// <p>Specifies the name of a database from which you want to retrieve partition indexes.</p>
pub fn set_database_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.database_name = input;
self
}
/// <p>Specifies the name of a table for which you want to retrieve the partition indexes.</p>
pub fn table_name(mut self, input: impl Into<std::string::String>) -> Self {
self.table_name = Some(input.into());
self
}
/// <p>Specifies the name of a table for which you want to retrieve the partition indexes.</p>
pub fn set_table_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.table_name = input;
self
}
/// <p>A continuation token, included if this is a continuation call.</p>
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
/// <p>A continuation token, included if this is a continuation call.</p>
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
/// Consumes the builder and constructs a [`GetPartitionIndexesInput`](crate::input::GetPartitionIndexesInput).
pub fn build(
self,
) -> Result<
crate::input::GetPartitionIndexesInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::GetPartitionIndexesInput {
catalog_id: self.catalog_id,
database_name: self.database_name,
table_name: self.table_name,
next_token: self.next_token,
})
}
}
}
impl GetPartitionIndexesInput {
/// Consumes the builder and constructs an Operation<[`GetPartitionIndexes`](crate::operation::GetPartitionIndexes)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetPartitionIndexes,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::GetPartitionIndexesInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetPartitionIndexesInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.GetPartitionIndexes",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_get_partition_indexes(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::GetPartitionIndexes::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetPartitionIndexes",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`GetPartitionIndexesInput`](crate::input::GetPartitionIndexesInput).
pub fn builder() -> crate::input::get_partition_indexes_input::Builder {
crate::input::get_partition_indexes_input::Builder::default()
}
}
/// See [`GetPartitionsInput`](crate::input::GetPartitionsInput).
pub mod get_partitions_input {
/// A builder for [`GetPartitionsInput`](crate::input::GetPartitionsInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) catalog_id: std::option::Option<std::string::String>,
pub(crate) database_name: std::option::Option<std::string::String>,
pub(crate) table_name: std::option::Option<std::string::String>,
pub(crate) expression: std::option::Option<std::string::String>,
pub(crate) next_token: std::option::Option<std::string::String>,
pub(crate) segment: std::option::Option<crate::model::Segment>,
pub(crate) max_results: std::option::Option<i32>,
pub(crate) exclude_column_schema: std::option::Option<bool>,
pub(crate) transaction_id: std::option::Option<std::string::String>,
pub(crate) query_as_of_time: std::option::Option<aws_smithy_types::DateTime>,
}
impl Builder {
/// <p>The ID of the Data Catalog where the partitions in question reside. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(mut self, input: impl Into<std::string::String>) -> Self {
self.catalog_id = Some(input.into());
self
}
/// <p>The ID of the Data Catalog where the partitions in question reside. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn set_catalog_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.catalog_id = input;
self
}
/// <p>The name of the catalog database where the partitions reside.</p>
pub fn database_name(mut self, input: impl Into<std::string::String>) -> Self {
self.database_name = Some(input.into());
self
}
/// <p>The name of the catalog database where the partitions reside.</p>
pub fn set_database_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.database_name = input;
self
}
/// <p>The name of the partitions' table.</p>
pub fn table_name(mut self, input: impl Into<std::string::String>) -> Self {
self.table_name = Some(input.into());
self
}
/// <p>The name of the partitions' table.</p>
pub fn set_table_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.table_name = input;
self
}
/// <p>An expression that filters the partitions to be returned.</p>
/// <p>The expression uses SQL syntax similar to the SQL <code>WHERE</code> filter clause. The SQL statement parser <a href="http://jsqlparser.sourceforge.net/home.php">JSQLParser</a> parses the expression. </p>
/// <p> <i>Operators</i>: The following are the operators that you can use in the <code>Expression</code> API call:</p>
/// <dl>
/// <dt>
/// =
/// </dt>
/// <dd>
/// <p>Checks whether the values of the two operands are equal; if yes, then the condition becomes true.</p>
/// <p>Example: Assume 'variable a' holds 10 and 'variable b' holds 20. </p>
/// <p>(a = b) is not true.</p>
/// </dd>
/// <dt>
/// < >
/// </dt>
/// <dd>
/// <p>Checks whether the values of two operands are equal; if the values are not equal, then the condition becomes true.</p>
/// <p>Example: (a < > b) is true.</p>
/// </dd>
/// <dt>
/// >
/// </dt>
/// <dd>
/// <p>Checks whether the value of the left operand is greater than the value of the right operand; if yes, then the condition becomes true.</p>
/// <p>Example: (a > b) is not true.</p>
/// </dd>
/// <dt>
/// <
/// </dt>
/// <dd>
/// <p>Checks whether the value of the left operand is less than the value of the right operand; if yes, then the condition becomes true.</p>
/// <p>Example: (a < b) is true.</p>
/// </dd>
/// <dt>
/// >=
/// </dt>
/// <dd>
/// <p>Checks whether the value of the left operand is greater than or equal to the value of the right operand; if yes, then the condition becomes true.</p>
/// <p>Example: (a >= b) is not true.</p>
/// </dd>
/// <dt>
/// <=
/// </dt>
/// <dd>
/// <p>Checks whether the value of the left operand is less than or equal to the value of the right operand; if yes, then the condition becomes true.</p>
/// <p>Example: (a <= b) is true.</p>
/// </dd>
/// <dt>
/// AND, OR, IN, BETWEEN, LIKE, NOT, IS NULL
/// </dt>
/// <dd>
/// <p>Logical operators.</p>
/// </dd>
/// </dl>
/// <p> <i>Supported Partition Key Types</i>: The following are the supported partition keys.</p>
/// <ul>
/// <li> <p> <code>string</code> </p> </li>
/// <li> <p> <code>date</code> </p> </li>
/// <li> <p> <code>timestamp</code> </p> </li>
/// <li> <p> <code>int</code> </p> </li>
/// <li> <p> <code>bigint</code> </p> </li>
/// <li> <p> <code>long</code> </p> </li>
/// <li> <p> <code>tinyint</code> </p> </li>
/// <li> <p> <code>smallint</code> </p> </li>
/// <li> <p> <code>decimal</code> </p> </li>
/// </ul>
/// <p>If an type is encountered that is not valid, an exception is thrown. </p>
/// <p>The following list shows the valid operators on each type. When you define a crawler, the <code>partitionKey</code> type is created as a <code>STRING</code>, to be compatible with the catalog partitions. </p>
/// <p> <i>Sample API Call</i>: </p>
pub fn expression(mut self, input: impl Into<std::string::String>) -> Self {
self.expression = Some(input.into());
self
}
/// <p>An expression that filters the partitions to be returned.</p>
/// <p>The expression uses SQL syntax similar to the SQL <code>WHERE</code> filter clause. The SQL statement parser <a href="http://jsqlparser.sourceforge.net/home.php">JSQLParser</a> parses the expression. </p>
/// <p> <i>Operators</i>: The following are the operators that you can use in the <code>Expression</code> API call:</p>
/// <dl>
/// <dt>
/// =
/// </dt>
/// <dd>
/// <p>Checks whether the values of the two operands are equal; if yes, then the condition becomes true.</p>
/// <p>Example: Assume 'variable a' holds 10 and 'variable b' holds 20. </p>
/// <p>(a = b) is not true.</p>
/// </dd>
/// <dt>
/// < >
/// </dt>
/// <dd>
/// <p>Checks whether the values of two operands are equal; if the values are not equal, then the condition becomes true.</p>
/// <p>Example: (a < > b) is true.</p>
/// </dd>
/// <dt>
/// >
/// </dt>
/// <dd>
/// <p>Checks whether the value of the left operand is greater than the value of the right operand; if yes, then the condition becomes true.</p>
/// <p>Example: (a > b) is not true.</p>
/// </dd>
/// <dt>
/// <
/// </dt>
/// <dd>
/// <p>Checks whether the value of the left operand is less than the value of the right operand; if yes, then the condition becomes true.</p>
/// <p>Example: (a < b) is true.</p>
/// </dd>
/// <dt>
/// >=
/// </dt>
/// <dd>
/// <p>Checks whether the value of the left operand is greater than or equal to the value of the right operand; if yes, then the condition becomes true.</p>
/// <p>Example: (a >= b) is not true.</p>
/// </dd>
/// <dt>
/// <=
/// </dt>
/// <dd>
/// <p>Checks whether the value of the left operand is less than or equal to the value of the right operand; if yes, then the condition becomes true.</p>
/// <p>Example: (a <= b) is true.</p>
/// </dd>
/// <dt>
/// AND, OR, IN, BETWEEN, LIKE, NOT, IS NULL
/// </dt>
/// <dd>
/// <p>Logical operators.</p>
/// </dd>
/// </dl>
/// <p> <i>Supported Partition Key Types</i>: The following are the supported partition keys.</p>
/// <ul>
/// <li> <p> <code>string</code> </p> </li>
/// <li> <p> <code>date</code> </p> </li>
/// <li> <p> <code>timestamp</code> </p> </li>
/// <li> <p> <code>int</code> </p> </li>
/// <li> <p> <code>bigint</code> </p> </li>
/// <li> <p> <code>long</code> </p> </li>
/// <li> <p> <code>tinyint</code> </p> </li>
/// <li> <p> <code>smallint</code> </p> </li>
/// <li> <p> <code>decimal</code> </p> </li>
/// </ul>
/// <p>If an type is encountered that is not valid, an exception is thrown. </p>
/// <p>The following list shows the valid operators on each type. When you define a crawler, the <code>partitionKey</code> type is created as a <code>STRING</code>, to be compatible with the catalog partitions. </p>
/// <p> <i>Sample API Call</i>: </p>
pub fn set_expression(mut self, input: std::option::Option<std::string::String>) -> Self {
self.expression = input;
self
}
/// <p>A continuation token, if this is not the first call to retrieve these partitions.</p>
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
/// <p>A continuation token, if this is not the first call to retrieve these partitions.</p>
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
/// <p>The segment of the table's partitions to scan in this request.</p>
pub fn segment(mut self, input: crate::model::Segment) -> Self {
self.segment = Some(input);
self
}
/// <p>The segment of the table's partitions to scan in this request.</p>
pub fn set_segment(mut self, input: std::option::Option<crate::model::Segment>) -> Self {
self.segment = input;
self
}
/// <p>The maximum number of partitions to return in a single response.</p>
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
/// <p>The maximum number of partitions to return in a single response.</p>
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
/// <p>When true, specifies not returning the partition column schema. Useful when you are interested only in other partition attributes such as partition values or location. This approach avoids the problem of a large response by not returning duplicate data.</p>
pub fn exclude_column_schema(mut self, input: bool) -> Self {
self.exclude_column_schema = Some(input);
self
}
/// <p>When true, specifies not returning the partition column schema. Useful when you are interested only in other partition attributes such as partition values or location. This approach avoids the problem of a large response by not returning duplicate data.</p>
pub fn set_exclude_column_schema(mut self, input: std::option::Option<bool>) -> Self {
self.exclude_column_schema = input;
self
}
/// <p>The transaction ID at which to read the partition contents.</p>
pub fn transaction_id(mut self, input: impl Into<std::string::String>) -> Self {
self.transaction_id = Some(input.into());
self
}
/// <p>The transaction ID at which to read the partition contents.</p>
pub fn set_transaction_id(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.transaction_id = input;
self
}
/// <p>The time as of when to read the partition contents. If not set, the most recent transaction commit time will be used. Cannot be specified along with <code>TransactionId</code>.</p>
pub fn query_as_of_time(mut self, input: aws_smithy_types::DateTime) -> Self {
self.query_as_of_time = Some(input);
self
}
/// <p>The time as of when to read the partition contents. If not set, the most recent transaction commit time will be used. Cannot be specified along with <code>TransactionId</code>.</p>
pub fn set_query_as_of_time(
mut self,
input: std::option::Option<aws_smithy_types::DateTime>,
) -> Self {
self.query_as_of_time = input;
self
}
/// Consumes the builder and constructs a [`GetPartitionsInput`](crate::input::GetPartitionsInput).
pub fn build(
self,
) -> Result<crate::input::GetPartitionsInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::GetPartitionsInput {
catalog_id: self.catalog_id,
database_name: self.database_name,
table_name: self.table_name,
expression: self.expression,
next_token: self.next_token,
segment: self.segment,
max_results: self.max_results,
exclude_column_schema: self.exclude_column_schema,
transaction_id: self.transaction_id,
query_as_of_time: self.query_as_of_time,
})
}
}
}
impl GetPartitionsInput {
/// Consumes the builder and constructs an Operation<[`GetPartitions`](crate::operation::GetPartitions)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetPartitions,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::GetPartitionsInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetPartitionsInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.GetPartitions",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_get_partitions(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::GetPartitions::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetPartitions",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`GetPartitionsInput`](crate::input::GetPartitionsInput).
pub fn builder() -> crate::input::get_partitions_input::Builder {
crate::input::get_partitions_input::Builder::default()
}
}
/// See [`GetPlanInput`](crate::input::GetPlanInput).
pub mod get_plan_input {
/// A builder for [`GetPlanInput`](crate::input::GetPlanInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) mapping: std::option::Option<std::vec::Vec<crate::model::MappingEntry>>,
pub(crate) source: std::option::Option<crate::model::CatalogEntry>,
pub(crate) sinks: std::option::Option<std::vec::Vec<crate::model::CatalogEntry>>,
pub(crate) location: std::option::Option<crate::model::Location>,
pub(crate) language: std::option::Option<crate::model::Language>,
pub(crate) additional_plan_options_map: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
}
impl Builder {
/// Appends an item to `mapping`.
///
/// To override the contents of this collection use [`set_mapping`](Self::set_mapping).
///
/// <p>The list of mappings from a source table to target tables.</p>
pub fn mapping(mut self, input: crate::model::MappingEntry) -> Self {
let mut v = self.mapping.unwrap_or_default();
v.push(input);
self.mapping = Some(v);
self
}
/// <p>The list of mappings from a source table to target tables.</p>
pub fn set_mapping(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::MappingEntry>>,
) -> Self {
self.mapping = input;
self
}
/// <p>The source table.</p>
pub fn source(mut self, input: crate::model::CatalogEntry) -> Self {
self.source = Some(input);
self
}
/// <p>The source table.</p>
pub fn set_source(
mut self,
input: std::option::Option<crate::model::CatalogEntry>,
) -> Self {
self.source = input;
self
}
/// Appends an item to `sinks`.
///
/// To override the contents of this collection use [`set_sinks`](Self::set_sinks).
///
/// <p>The target tables.</p>
pub fn sinks(mut self, input: crate::model::CatalogEntry) -> Self {
let mut v = self.sinks.unwrap_or_default();
v.push(input);
self.sinks = Some(v);
self
}
/// <p>The target tables.</p>
pub fn set_sinks(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::CatalogEntry>>,
) -> Self {
self.sinks = input;
self
}
/// <p>The parameters for the mapping.</p>
pub fn location(mut self, input: crate::model::Location) -> Self {
self.location = Some(input);
self
}
/// <p>The parameters for the mapping.</p>
pub fn set_location(mut self, input: std::option::Option<crate::model::Location>) -> Self {
self.location = input;
self
}
/// <p>The programming language of the code to perform the mapping.</p>
pub fn language(mut self, input: crate::model::Language) -> Self {
self.language = Some(input);
self
}
/// <p>The programming language of the code to perform the mapping.</p>
pub fn set_language(mut self, input: std::option::Option<crate::model::Language>) -> Self {
self.language = input;
self
}
/// Adds a key-value pair to `additional_plan_options_map`.
///
/// To override the contents of this collection use [`set_additional_plan_options_map`](Self::set_additional_plan_options_map).
///
/// <p>A map to hold additional optional key-value parameters.</p>
/// <p>Currently, these key-value pairs are supported:</p>
/// <ul>
/// <li> <p> <code>inferSchema</code> — Specifies whether to set <code>inferSchema</code> to true or false for the default script generated by an Glue job. For example, to set <code>inferSchema</code> to true, pass the following key value pair:</p> <p> <code>--additional-plan-options-map '{"inferSchema":"true"}'</code> </p> </li>
/// </ul>
pub fn additional_plan_options_map(
mut self,
k: impl Into<std::string::String>,
v: impl Into<std::string::String>,
) -> Self {
let mut hash_map = self.additional_plan_options_map.unwrap_or_default();
hash_map.insert(k.into(), v.into());
self.additional_plan_options_map = Some(hash_map);
self
}
/// <p>A map to hold additional optional key-value parameters.</p>
/// <p>Currently, these key-value pairs are supported:</p>
/// <ul>
/// <li> <p> <code>inferSchema</code> — Specifies whether to set <code>inferSchema</code> to true or false for the default script generated by an Glue job. For example, to set <code>inferSchema</code> to true, pass the following key value pair:</p> <p> <code>--additional-plan-options-map '{"inferSchema":"true"}'</code> </p> </li>
/// </ul>
pub fn set_additional_plan_options_map(
mut self,
input: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
) -> Self {
self.additional_plan_options_map = input;
self
}
/// Consumes the builder and constructs a [`GetPlanInput`](crate::input::GetPlanInput).
pub fn build(
self,
) -> Result<crate::input::GetPlanInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::GetPlanInput {
mapping: self.mapping,
source: self.source,
sinks: self.sinks,
location: self.location,
language: self.language,
additional_plan_options_map: self.additional_plan_options_map,
})
}
}
}
impl GetPlanInput {
/// Consumes the builder and constructs an Operation<[`GetPlan`](crate::operation::GetPlan)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetPlan,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::GetPlanInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetPlanInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.GetPlan",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_get_plan(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op =
aws_smithy_http::operation::Operation::new(request, crate::operation::GetPlan::new())
.with_metadata(aws_smithy_http::operation::Metadata::new("GetPlan", "glue"));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`GetPlanInput`](crate::input::GetPlanInput).
pub fn builder() -> crate::input::get_plan_input::Builder {
crate::input::get_plan_input::Builder::default()
}
}
/// See [`GetRegistryInput`](crate::input::GetRegistryInput).
pub mod get_registry_input {
/// A builder for [`GetRegistryInput`](crate::input::GetRegistryInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) registry_id: std::option::Option<crate::model::RegistryId>,
}
impl Builder {
/// <p>This is a wrapper structure that may contain the registry name and Amazon Resource Name (ARN).</p>
pub fn registry_id(mut self, input: crate::model::RegistryId) -> Self {
self.registry_id = Some(input);
self
}
/// <p>This is a wrapper structure that may contain the registry name and Amazon Resource Name (ARN).</p>
pub fn set_registry_id(
mut self,
input: std::option::Option<crate::model::RegistryId>,
) -> Self {
self.registry_id = input;
self
}
/// Consumes the builder and constructs a [`GetRegistryInput`](crate::input::GetRegistryInput).
pub fn build(
self,
) -> Result<crate::input::GetRegistryInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::GetRegistryInput {
registry_id: self.registry_id,
})
}
}
}
impl GetRegistryInput {
/// Consumes the builder and constructs an Operation<[`GetRegistry`](crate::operation::GetRegistry)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetRegistry,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::GetRegistryInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetRegistryInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.GetRegistry",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_get_registry(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::GetRegistry::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetRegistry",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`GetRegistryInput`](crate::input::GetRegistryInput).
pub fn builder() -> crate::input::get_registry_input::Builder {
crate::input::get_registry_input::Builder::default()
}
}
/// See [`GetResourcePoliciesInput`](crate::input::GetResourcePoliciesInput).
pub mod get_resource_policies_input {
/// A builder for [`GetResourcePoliciesInput`](crate::input::GetResourcePoliciesInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) next_token: std::option::Option<std::string::String>,
pub(crate) max_results: std::option::Option<i32>,
}
impl Builder {
/// <p>A continuation token, if this is a continuation request.</p>
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
/// <p>A continuation token, if this is a continuation request.</p>
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
/// <p>The maximum size of a list to return.</p>
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
/// <p>The maximum size of a list to return.</p>
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
/// Consumes the builder and constructs a [`GetResourcePoliciesInput`](crate::input::GetResourcePoliciesInput).
pub fn build(
self,
) -> Result<
crate::input::GetResourcePoliciesInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::GetResourcePoliciesInput {
next_token: self.next_token,
max_results: self.max_results,
})
}
}
}
impl GetResourcePoliciesInput {
/// Consumes the builder and constructs an Operation<[`GetResourcePolicies`](crate::operation::GetResourcePolicies)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetResourcePolicies,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::GetResourcePoliciesInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetResourcePoliciesInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.GetResourcePolicies",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_get_resource_policies(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::GetResourcePolicies::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetResourcePolicies",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`GetResourcePoliciesInput`](crate::input::GetResourcePoliciesInput).
pub fn builder() -> crate::input::get_resource_policies_input::Builder {
crate::input::get_resource_policies_input::Builder::default()
}
}
/// See [`GetResourcePolicyInput`](crate::input::GetResourcePolicyInput).
pub mod get_resource_policy_input {
/// A builder for [`GetResourcePolicyInput`](crate::input::GetResourcePolicyInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) resource_arn: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The ARN of the Glue resource for which to retrieve the resource policy. If not supplied, the Data Catalog resource policy is returned. Use <code>GetResourcePolicies</code> to view all existing resource policies. For more information see <a href="https://docs.aws.amazon.com/glue/latest/dg/glue-specifying-resource-arns.html">Specifying Glue Resource ARNs</a>. </p>
pub fn resource_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.resource_arn = Some(input.into());
self
}
/// <p>The ARN of the Glue resource for which to retrieve the resource policy. If not supplied, the Data Catalog resource policy is returned. Use <code>GetResourcePolicies</code> to view all existing resource policies. For more information see <a href="https://docs.aws.amazon.com/glue/latest/dg/glue-specifying-resource-arns.html">Specifying Glue Resource ARNs</a>. </p>
pub fn set_resource_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.resource_arn = input;
self
}
/// Consumes the builder and constructs a [`GetResourcePolicyInput`](crate::input::GetResourcePolicyInput).
pub fn build(
self,
) -> Result<
crate::input::GetResourcePolicyInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::GetResourcePolicyInput {
resource_arn: self.resource_arn,
})
}
}
}
impl GetResourcePolicyInput {
/// Consumes the builder and constructs an Operation<[`GetResourcePolicy`](crate::operation::GetResourcePolicy)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetResourcePolicy,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::GetResourcePolicyInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetResourcePolicyInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.GetResourcePolicy",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_get_resource_policy(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::GetResourcePolicy::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetResourcePolicy",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`GetResourcePolicyInput`](crate::input::GetResourcePolicyInput).
pub fn builder() -> crate::input::get_resource_policy_input::Builder {
crate::input::get_resource_policy_input::Builder::default()
}
}
/// See [`GetSchemaInput`](crate::input::GetSchemaInput).
pub mod get_schema_input {
/// A builder for [`GetSchemaInput`](crate::input::GetSchemaInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) schema_id: std::option::Option<crate::model::SchemaId>,
}
impl Builder {
/// <p>This is a wrapper structure to contain schema identity fields. The structure contains:</p>
/// <ul>
/// <li> <p>SchemaId$SchemaArn: The Amazon Resource Name (ARN) of the schema. Either <code>SchemaArn</code> or <code>SchemaName</code> and <code>RegistryName</code> has to be provided.</p> </li>
/// <li> <p>SchemaId$SchemaName: The name of the schema. Either <code>SchemaArn</code> or <code>SchemaName</code> and <code>RegistryName</code> has to be provided.</p> </li>
/// </ul>
pub fn schema_id(mut self, input: crate::model::SchemaId) -> Self {
self.schema_id = Some(input);
self
}
/// <p>This is a wrapper structure to contain schema identity fields. The structure contains:</p>
/// <ul>
/// <li> <p>SchemaId$SchemaArn: The Amazon Resource Name (ARN) of the schema. Either <code>SchemaArn</code> or <code>SchemaName</code> and <code>RegistryName</code> has to be provided.</p> </li>
/// <li> <p>SchemaId$SchemaName: The name of the schema. Either <code>SchemaArn</code> or <code>SchemaName</code> and <code>RegistryName</code> has to be provided.</p> </li>
/// </ul>
pub fn set_schema_id(mut self, input: std::option::Option<crate::model::SchemaId>) -> Self {
self.schema_id = input;
self
}
/// Consumes the builder and constructs a [`GetSchemaInput`](crate::input::GetSchemaInput).
pub fn build(
self,
) -> Result<crate::input::GetSchemaInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::GetSchemaInput {
schema_id: self.schema_id,
})
}
}
}
impl GetSchemaInput {
/// Consumes the builder and constructs an Operation<[`GetSchema`](crate::operation::GetSchema)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetSchema,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::GetSchemaInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetSchemaInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.GetSchema",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_get_schema(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op =
aws_smithy_http::operation::Operation::new(request, crate::operation::GetSchema::new())
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetSchema",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`GetSchemaInput`](crate::input::GetSchemaInput).
pub fn builder() -> crate::input::get_schema_input::Builder {
crate::input::get_schema_input::Builder::default()
}
}
/// See [`GetSchemaByDefinitionInput`](crate::input::GetSchemaByDefinitionInput).
pub mod get_schema_by_definition_input {
/// A builder for [`GetSchemaByDefinitionInput`](crate::input::GetSchemaByDefinitionInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) schema_id: std::option::Option<crate::model::SchemaId>,
pub(crate) schema_definition: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>This is a wrapper structure to contain schema identity fields. The structure contains:</p>
/// <ul>
/// <li> <p>SchemaId$SchemaArn: The Amazon Resource Name (ARN) of the schema. One of <code>SchemaArn</code> or <code>SchemaName</code> has to be provided.</p> </li>
/// <li> <p>SchemaId$SchemaName: The name of the schema. One of <code>SchemaArn</code> or <code>SchemaName</code> has to be provided.</p> </li>
/// </ul>
pub fn schema_id(mut self, input: crate::model::SchemaId) -> Self {
self.schema_id = Some(input);
self
}
/// <p>This is a wrapper structure to contain schema identity fields. The structure contains:</p>
/// <ul>
/// <li> <p>SchemaId$SchemaArn: The Amazon Resource Name (ARN) of the schema. One of <code>SchemaArn</code> or <code>SchemaName</code> has to be provided.</p> </li>
/// <li> <p>SchemaId$SchemaName: The name of the schema. One of <code>SchemaArn</code> or <code>SchemaName</code> has to be provided.</p> </li>
/// </ul>
pub fn set_schema_id(mut self, input: std::option::Option<crate::model::SchemaId>) -> Self {
self.schema_id = input;
self
}
/// <p>The definition of the schema for which schema details are required.</p>
pub fn schema_definition(mut self, input: impl Into<std::string::String>) -> Self {
self.schema_definition = Some(input.into());
self
}
/// <p>The definition of the schema for which schema details are required.</p>
pub fn set_schema_definition(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.schema_definition = input;
self
}
/// Consumes the builder and constructs a [`GetSchemaByDefinitionInput`](crate::input::GetSchemaByDefinitionInput).
pub fn build(
self,
) -> Result<
crate::input::GetSchemaByDefinitionInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::GetSchemaByDefinitionInput {
schema_id: self.schema_id,
schema_definition: self.schema_definition,
})
}
}
}
impl GetSchemaByDefinitionInput {
/// Consumes the builder and constructs an Operation<[`GetSchemaByDefinition`](crate::operation::GetSchemaByDefinition)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetSchemaByDefinition,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::GetSchemaByDefinitionInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetSchemaByDefinitionInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.GetSchemaByDefinition",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_get_schema_by_definition(
&self,
)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::GetSchemaByDefinition::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetSchemaByDefinition",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`GetSchemaByDefinitionInput`](crate::input::GetSchemaByDefinitionInput).
pub fn builder() -> crate::input::get_schema_by_definition_input::Builder {
crate::input::get_schema_by_definition_input::Builder::default()
}
}
/// See [`GetSchemaVersionInput`](crate::input::GetSchemaVersionInput).
pub mod get_schema_version_input {
/// A builder for [`GetSchemaVersionInput`](crate::input::GetSchemaVersionInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) schema_id: std::option::Option<crate::model::SchemaId>,
pub(crate) schema_version_id: std::option::Option<std::string::String>,
pub(crate) schema_version_number: std::option::Option<crate::model::SchemaVersionNumber>,
}
impl Builder {
/// <p>This is a wrapper structure to contain schema identity fields. The structure contains:</p>
/// <ul>
/// <li> <p>SchemaId$SchemaArn: The Amazon Resource Name (ARN) of the schema. Either <code>SchemaArn</code> or <code>SchemaName</code> and <code>RegistryName</code> has to be provided.</p> </li>
/// <li> <p>SchemaId$SchemaName: The name of the schema. Either <code>SchemaArn</code> or <code>SchemaName</code> and <code>RegistryName</code> has to be provided.</p> </li>
/// </ul>
pub fn schema_id(mut self, input: crate::model::SchemaId) -> Self {
self.schema_id = Some(input);
self
}
/// <p>This is a wrapper structure to contain schema identity fields. The structure contains:</p>
/// <ul>
/// <li> <p>SchemaId$SchemaArn: The Amazon Resource Name (ARN) of the schema. Either <code>SchemaArn</code> or <code>SchemaName</code> and <code>RegistryName</code> has to be provided.</p> </li>
/// <li> <p>SchemaId$SchemaName: The name of the schema. Either <code>SchemaArn</code> or <code>SchemaName</code> and <code>RegistryName</code> has to be provided.</p> </li>
/// </ul>
pub fn set_schema_id(mut self, input: std::option::Option<crate::model::SchemaId>) -> Self {
self.schema_id = input;
self
}
/// <p>The <code>SchemaVersionId</code> of the schema version. This field is required for fetching by schema ID. Either this or the <code>SchemaId</code> wrapper has to be provided.</p>
pub fn schema_version_id(mut self, input: impl Into<std::string::String>) -> Self {
self.schema_version_id = Some(input.into());
self
}
/// <p>The <code>SchemaVersionId</code> of the schema version. This field is required for fetching by schema ID. Either this or the <code>SchemaId</code> wrapper has to be provided.</p>
pub fn set_schema_version_id(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.schema_version_id = input;
self
}
/// <p>The version number of the schema.</p>
pub fn schema_version_number(mut self, input: crate::model::SchemaVersionNumber) -> Self {
self.schema_version_number = Some(input);
self
}
/// <p>The version number of the schema.</p>
pub fn set_schema_version_number(
mut self,
input: std::option::Option<crate::model::SchemaVersionNumber>,
) -> Self {
self.schema_version_number = input;
self
}
/// Consumes the builder and constructs a [`GetSchemaVersionInput`](crate::input::GetSchemaVersionInput).
pub fn build(
self,
) -> Result<
crate::input::GetSchemaVersionInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::GetSchemaVersionInput {
schema_id: self.schema_id,
schema_version_id: self.schema_version_id,
schema_version_number: self.schema_version_number,
})
}
}
}
impl GetSchemaVersionInput {
/// Consumes the builder and constructs an Operation<[`GetSchemaVersion`](crate::operation::GetSchemaVersion)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetSchemaVersion,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::GetSchemaVersionInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetSchemaVersionInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.GetSchemaVersion",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_get_schema_version(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::GetSchemaVersion::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetSchemaVersion",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`GetSchemaVersionInput`](crate::input::GetSchemaVersionInput).
pub fn builder() -> crate::input::get_schema_version_input::Builder {
crate::input::get_schema_version_input::Builder::default()
}
}
/// See [`GetSchemaVersionsDiffInput`](crate::input::GetSchemaVersionsDiffInput).
pub mod get_schema_versions_diff_input {
/// A builder for [`GetSchemaVersionsDiffInput`](crate::input::GetSchemaVersionsDiffInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) schema_id: std::option::Option<crate::model::SchemaId>,
pub(crate) first_schema_version_number:
std::option::Option<crate::model::SchemaVersionNumber>,
pub(crate) second_schema_version_number:
std::option::Option<crate::model::SchemaVersionNumber>,
pub(crate) schema_diff_type: std::option::Option<crate::model::SchemaDiffType>,
}
impl Builder {
/// <p>This is a wrapper structure to contain schema identity fields. The structure contains:</p>
/// <ul>
/// <li> <p>SchemaId$SchemaArn: The Amazon Resource Name (ARN) of the schema. One of <code>SchemaArn</code> or <code>SchemaName</code> has to be provided.</p> </li>
/// <li> <p>SchemaId$SchemaName: The name of the schema. One of <code>SchemaArn</code> or <code>SchemaName</code> has to be provided.</p> </li>
/// </ul>
pub fn schema_id(mut self, input: crate::model::SchemaId) -> Self {
self.schema_id = Some(input);
self
}
/// <p>This is a wrapper structure to contain schema identity fields. The structure contains:</p>
/// <ul>
/// <li> <p>SchemaId$SchemaArn: The Amazon Resource Name (ARN) of the schema. One of <code>SchemaArn</code> or <code>SchemaName</code> has to be provided.</p> </li>
/// <li> <p>SchemaId$SchemaName: The name of the schema. One of <code>SchemaArn</code> or <code>SchemaName</code> has to be provided.</p> </li>
/// </ul>
pub fn set_schema_id(mut self, input: std::option::Option<crate::model::SchemaId>) -> Self {
self.schema_id = input;
self
}
/// <p>The first of the two schema versions to be compared.</p>
pub fn first_schema_version_number(
mut self,
input: crate::model::SchemaVersionNumber,
) -> Self {
self.first_schema_version_number = Some(input);
self
}
/// <p>The first of the two schema versions to be compared.</p>
pub fn set_first_schema_version_number(
mut self,
input: std::option::Option<crate::model::SchemaVersionNumber>,
) -> Self {
self.first_schema_version_number = input;
self
}
/// <p>The second of the two schema versions to be compared.</p>
pub fn second_schema_version_number(
mut self,
input: crate::model::SchemaVersionNumber,
) -> Self {
self.second_schema_version_number = Some(input);
self
}
/// <p>The second of the two schema versions to be compared.</p>
pub fn set_second_schema_version_number(
mut self,
input: std::option::Option<crate::model::SchemaVersionNumber>,
) -> Self {
self.second_schema_version_number = input;
self
}
/// <p>Refers to <code>SYNTAX_DIFF</code>, which is the currently supported diff type.</p>
pub fn schema_diff_type(mut self, input: crate::model::SchemaDiffType) -> Self {
self.schema_diff_type = Some(input);
self
}
/// <p>Refers to <code>SYNTAX_DIFF</code>, which is the currently supported diff type.</p>
pub fn set_schema_diff_type(
mut self,
input: std::option::Option<crate::model::SchemaDiffType>,
) -> Self {
self.schema_diff_type = input;
self
}
/// Consumes the builder and constructs a [`GetSchemaVersionsDiffInput`](crate::input::GetSchemaVersionsDiffInput).
pub fn build(
self,
) -> Result<
crate::input::GetSchemaVersionsDiffInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::GetSchemaVersionsDiffInput {
schema_id: self.schema_id,
first_schema_version_number: self.first_schema_version_number,
second_schema_version_number: self.second_schema_version_number,
schema_diff_type: self.schema_diff_type,
})
}
}
}
impl GetSchemaVersionsDiffInput {
/// Consumes the builder and constructs an Operation<[`GetSchemaVersionsDiff`](crate::operation::GetSchemaVersionsDiff)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetSchemaVersionsDiff,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::GetSchemaVersionsDiffInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetSchemaVersionsDiffInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.GetSchemaVersionsDiff",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_get_schema_versions_diff(
&self,
)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::GetSchemaVersionsDiff::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetSchemaVersionsDiff",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`GetSchemaVersionsDiffInput`](crate::input::GetSchemaVersionsDiffInput).
pub fn builder() -> crate::input::get_schema_versions_diff_input::Builder {
crate::input::get_schema_versions_diff_input::Builder::default()
}
}
/// See [`GetSecurityConfigurationInput`](crate::input::GetSecurityConfigurationInput).
pub mod get_security_configuration_input {
/// A builder for [`GetSecurityConfigurationInput`](crate::input::GetSecurityConfigurationInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) name: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The name of the security configuration to retrieve.</p>
pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
self.name = Some(input.into());
self
}
/// <p>The name of the security configuration to retrieve.</p>
pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.name = input;
self
}
/// Consumes the builder and constructs a [`GetSecurityConfigurationInput`](crate::input::GetSecurityConfigurationInput).
pub fn build(
self,
) -> Result<
crate::input::GetSecurityConfigurationInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::GetSecurityConfigurationInput { name: self.name })
}
}
}
impl GetSecurityConfigurationInput {
/// Consumes the builder and constructs an Operation<[`GetSecurityConfiguration`](crate::operation::GetSecurityConfiguration)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetSecurityConfiguration,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::GetSecurityConfigurationInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetSecurityConfigurationInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.GetSecurityConfiguration",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_get_security_configuration(
&self,
)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::GetSecurityConfiguration::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetSecurityConfiguration",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`GetSecurityConfigurationInput`](crate::input::GetSecurityConfigurationInput).
pub fn builder() -> crate::input::get_security_configuration_input::Builder {
crate::input::get_security_configuration_input::Builder::default()
}
}
/// See [`GetSecurityConfigurationsInput`](crate::input::GetSecurityConfigurationsInput).
pub mod get_security_configurations_input {
/// A builder for [`GetSecurityConfigurationsInput`](crate::input::GetSecurityConfigurationsInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) max_results: std::option::Option<i32>,
pub(crate) next_token: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The maximum number of results to return.</p>
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
/// <p>The maximum number of results to return.</p>
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
/// <p>A continuation token, if this is a continuation call.</p>
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
/// <p>A continuation token, if this is a continuation call.</p>
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
/// Consumes the builder and constructs a [`GetSecurityConfigurationsInput`](crate::input::GetSecurityConfigurationsInput).
pub fn build(
self,
) -> Result<
crate::input::GetSecurityConfigurationsInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::GetSecurityConfigurationsInput {
max_results: self.max_results,
next_token: self.next_token,
})
}
}
}
impl GetSecurityConfigurationsInput {
/// Consumes the builder and constructs an Operation<[`GetSecurityConfigurations`](crate::operation::GetSecurityConfigurations)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetSecurityConfigurations,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::GetSecurityConfigurationsInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetSecurityConfigurationsInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.GetSecurityConfigurations",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_get_security_configurations(
&self,
)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::GetSecurityConfigurations::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetSecurityConfigurations",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`GetSecurityConfigurationsInput`](crate::input::GetSecurityConfigurationsInput).
pub fn builder() -> crate::input::get_security_configurations_input::Builder {
crate::input::get_security_configurations_input::Builder::default()
}
}
/// See [`GetSessionInput`](crate::input::GetSessionInput).
pub mod get_session_input {
/// A builder for [`GetSessionInput`](crate::input::GetSessionInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) id: std::option::Option<std::string::String>,
pub(crate) request_origin: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The ID of the session. </p>
pub fn id(mut self, input: impl Into<std::string::String>) -> Self {
self.id = Some(input.into());
self
}
/// <p>The ID of the session. </p>
pub fn set_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.id = input;
self
}
/// <p>The origin of the request. </p>
pub fn request_origin(mut self, input: impl Into<std::string::String>) -> Self {
self.request_origin = Some(input.into());
self
}
/// <p>The origin of the request. </p>
pub fn set_request_origin(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.request_origin = input;
self
}
/// Consumes the builder and constructs a [`GetSessionInput`](crate::input::GetSessionInput).
pub fn build(
self,
) -> Result<crate::input::GetSessionInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::GetSessionInput {
id: self.id,
request_origin: self.request_origin,
})
}
}
}
impl GetSessionInput {
/// Consumes the builder and constructs an Operation<[`GetSession`](crate::operation::GetSession)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetSession,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::GetSessionInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetSessionInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.GetSession",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_get_session(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::GetSession::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetSession",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`GetSessionInput`](crate::input::GetSessionInput).
pub fn builder() -> crate::input::get_session_input::Builder {
crate::input::get_session_input::Builder::default()
}
}
/// See [`GetStatementInput`](crate::input::GetStatementInput).
pub mod get_statement_input {
/// A builder for [`GetStatementInput`](crate::input::GetStatementInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) session_id: std::option::Option<std::string::String>,
pub(crate) id: std::option::Option<i32>,
pub(crate) request_origin: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The Session ID of the statement.</p>
pub fn session_id(mut self, input: impl Into<std::string::String>) -> Self {
self.session_id = Some(input.into());
self
}
/// <p>The Session ID of the statement.</p>
pub fn set_session_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.session_id = input;
self
}
/// <p>The Id of the statement.</p>
pub fn id(mut self, input: i32) -> Self {
self.id = Some(input);
self
}
/// <p>The Id of the statement.</p>
pub fn set_id(mut self, input: std::option::Option<i32>) -> Self {
self.id = input;
self
}
/// <p>The origin of the request.</p>
pub fn request_origin(mut self, input: impl Into<std::string::String>) -> Self {
self.request_origin = Some(input.into());
self
}
/// <p>The origin of the request.</p>
pub fn set_request_origin(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.request_origin = input;
self
}
/// Consumes the builder and constructs a [`GetStatementInput`](crate::input::GetStatementInput).
pub fn build(
self,
) -> Result<crate::input::GetStatementInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::GetStatementInput {
session_id: self.session_id,
id: self.id.unwrap_or_default(),
request_origin: self.request_origin,
})
}
}
}
impl GetStatementInput {
/// Consumes the builder and constructs an Operation<[`GetStatement`](crate::operation::GetStatement)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetStatement,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::GetStatementInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetStatementInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.GetStatement",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_get_statement(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::GetStatement::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetStatement",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`GetStatementInput`](crate::input::GetStatementInput).
pub fn builder() -> crate::input::get_statement_input::Builder {
crate::input::get_statement_input::Builder::default()
}
}
/// See [`GetTableInput`](crate::input::GetTableInput).
pub mod get_table_input {
/// A builder for [`GetTableInput`](crate::input::GetTableInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) catalog_id: std::option::Option<std::string::String>,
pub(crate) database_name: std::option::Option<std::string::String>,
pub(crate) name: std::option::Option<std::string::String>,
pub(crate) transaction_id: std::option::Option<std::string::String>,
pub(crate) query_as_of_time: std::option::Option<aws_smithy_types::DateTime>,
}
impl Builder {
/// <p>The ID of the Data Catalog where the table resides. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(mut self, input: impl Into<std::string::String>) -> Self {
self.catalog_id = Some(input.into());
self
}
/// <p>The ID of the Data Catalog where the table resides. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn set_catalog_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.catalog_id = input;
self
}
/// <p>The name of the database in the catalog in which the table resides. For Hive compatibility, this name is entirely lowercase.</p>
pub fn database_name(mut self, input: impl Into<std::string::String>) -> Self {
self.database_name = Some(input.into());
self
}
/// <p>The name of the database in the catalog in which the table resides. For Hive compatibility, this name is entirely lowercase.</p>
pub fn set_database_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.database_name = input;
self
}
/// <p>The name of the table for which to retrieve the definition. For Hive compatibility, this name is entirely lowercase.</p>
pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
self.name = Some(input.into());
self
}
/// <p>The name of the table for which to retrieve the definition. For Hive compatibility, this name is entirely lowercase.</p>
pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.name = input;
self
}
/// <p>The transaction ID at which to read the table contents. </p>
pub fn transaction_id(mut self, input: impl Into<std::string::String>) -> Self {
self.transaction_id = Some(input.into());
self
}
/// <p>The transaction ID at which to read the table contents. </p>
pub fn set_transaction_id(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.transaction_id = input;
self
}
/// <p>The time as of when to read the table contents. If not set, the most recent transaction commit time will be used. Cannot be specified along with <code>TransactionId</code>.</p>
pub fn query_as_of_time(mut self, input: aws_smithy_types::DateTime) -> Self {
self.query_as_of_time = Some(input);
self
}
/// <p>The time as of when to read the table contents. If not set, the most recent transaction commit time will be used. Cannot be specified along with <code>TransactionId</code>.</p>
pub fn set_query_as_of_time(
mut self,
input: std::option::Option<aws_smithy_types::DateTime>,
) -> Self {
self.query_as_of_time = input;
self
}
/// Consumes the builder and constructs a [`GetTableInput`](crate::input::GetTableInput).
pub fn build(
self,
) -> Result<crate::input::GetTableInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::GetTableInput {
catalog_id: self.catalog_id,
database_name: self.database_name,
name: self.name,
transaction_id: self.transaction_id,
query_as_of_time: self.query_as_of_time,
})
}
}
}
impl GetTableInput {
/// Consumes the builder and constructs an Operation<[`GetTable`](crate::operation::GetTable)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetTable,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::GetTableInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetTableInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.GetTable",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_get_table(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op =
aws_smithy_http::operation::Operation::new(request, crate::operation::GetTable::new())
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetTable", "glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`GetTableInput`](crate::input::GetTableInput).
pub fn builder() -> crate::input::get_table_input::Builder {
crate::input::get_table_input::Builder::default()
}
}
/// See [`GetTablesInput`](crate::input::GetTablesInput).
pub mod get_tables_input {
/// A builder for [`GetTablesInput`](crate::input::GetTablesInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) catalog_id: std::option::Option<std::string::String>,
pub(crate) database_name: std::option::Option<std::string::String>,
pub(crate) expression: std::option::Option<std::string::String>,
pub(crate) next_token: std::option::Option<std::string::String>,
pub(crate) max_results: std::option::Option<i32>,
pub(crate) transaction_id: std::option::Option<std::string::String>,
pub(crate) query_as_of_time: std::option::Option<aws_smithy_types::DateTime>,
}
impl Builder {
/// <p>The ID of the Data Catalog where the tables reside. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(mut self, input: impl Into<std::string::String>) -> Self {
self.catalog_id = Some(input.into());
self
}
/// <p>The ID of the Data Catalog where the tables reside. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn set_catalog_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.catalog_id = input;
self
}
/// <p>The database in the catalog whose tables to list. For Hive compatibility, this name is entirely lowercase.</p>
pub fn database_name(mut self, input: impl Into<std::string::String>) -> Self {
self.database_name = Some(input.into());
self
}
/// <p>The database in the catalog whose tables to list. For Hive compatibility, this name is entirely lowercase.</p>
pub fn set_database_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.database_name = input;
self
}
/// <p>A regular expression pattern. If present, only those tables whose names match the pattern are returned.</p>
pub fn expression(mut self, input: impl Into<std::string::String>) -> Self {
self.expression = Some(input.into());
self
}
/// <p>A regular expression pattern. If present, only those tables whose names match the pattern are returned.</p>
pub fn set_expression(mut self, input: std::option::Option<std::string::String>) -> Self {
self.expression = input;
self
}
/// <p>A continuation token, included if this is a continuation call.</p>
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
/// <p>A continuation token, included if this is a continuation call.</p>
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
/// <p>The maximum number of tables to return in a single response.</p>
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
/// <p>The maximum number of tables to return in a single response.</p>
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
/// <p>The transaction ID at which to read the table contents.</p>
pub fn transaction_id(mut self, input: impl Into<std::string::String>) -> Self {
self.transaction_id = Some(input.into());
self
}
/// <p>The transaction ID at which to read the table contents.</p>
pub fn set_transaction_id(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.transaction_id = input;
self
}
/// <p>The time as of when to read the table contents. If not set, the most recent transaction commit time will be used. Cannot be specified along with <code>TransactionId</code>.</p>
pub fn query_as_of_time(mut self, input: aws_smithy_types::DateTime) -> Self {
self.query_as_of_time = Some(input);
self
}
/// <p>The time as of when to read the table contents. If not set, the most recent transaction commit time will be used. Cannot be specified along with <code>TransactionId</code>.</p>
pub fn set_query_as_of_time(
mut self,
input: std::option::Option<aws_smithy_types::DateTime>,
) -> Self {
self.query_as_of_time = input;
self
}
/// Consumes the builder and constructs a [`GetTablesInput`](crate::input::GetTablesInput).
pub fn build(
self,
) -> Result<crate::input::GetTablesInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::GetTablesInput {
catalog_id: self.catalog_id,
database_name: self.database_name,
expression: self.expression,
next_token: self.next_token,
max_results: self.max_results,
transaction_id: self.transaction_id,
query_as_of_time: self.query_as_of_time,
})
}
}
}
impl GetTablesInput {
/// Consumes the builder and constructs an Operation<[`GetTables`](crate::operation::GetTables)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetTables,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::GetTablesInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetTablesInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.GetTables",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_get_tables(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op =
aws_smithy_http::operation::Operation::new(request, crate::operation::GetTables::new())
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetTables",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`GetTablesInput`](crate::input::GetTablesInput).
pub fn builder() -> crate::input::get_tables_input::Builder {
crate::input::get_tables_input::Builder::default()
}
}
/// See [`GetTableVersionInput`](crate::input::GetTableVersionInput).
pub mod get_table_version_input {
/// A builder for [`GetTableVersionInput`](crate::input::GetTableVersionInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) catalog_id: std::option::Option<std::string::String>,
pub(crate) database_name: std::option::Option<std::string::String>,
pub(crate) table_name: std::option::Option<std::string::String>,
pub(crate) version_id: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The ID of the Data Catalog where the tables reside. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(mut self, input: impl Into<std::string::String>) -> Self {
self.catalog_id = Some(input.into());
self
}
/// <p>The ID of the Data Catalog where the tables reside. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn set_catalog_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.catalog_id = input;
self
}
/// <p>The database in the catalog in which the table resides. For Hive compatibility, this name is entirely lowercase.</p>
pub fn database_name(mut self, input: impl Into<std::string::String>) -> Self {
self.database_name = Some(input.into());
self
}
/// <p>The database in the catalog in which the table resides. For Hive compatibility, this name is entirely lowercase.</p>
pub fn set_database_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.database_name = input;
self
}
/// <p>The name of the table. For Hive compatibility, this name is entirely lowercase.</p>
pub fn table_name(mut self, input: impl Into<std::string::String>) -> Self {
self.table_name = Some(input.into());
self
}
/// <p>The name of the table. For Hive compatibility, this name is entirely lowercase.</p>
pub fn set_table_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.table_name = input;
self
}
/// <p>The ID value of the table version to be retrieved. A <code>VersionID</code> is a string representation of an integer. Each version is incremented by 1. </p>
pub fn version_id(mut self, input: impl Into<std::string::String>) -> Self {
self.version_id = Some(input.into());
self
}
/// <p>The ID value of the table version to be retrieved. A <code>VersionID</code> is a string representation of an integer. Each version is incremented by 1. </p>
pub fn set_version_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.version_id = input;
self
}
/// Consumes the builder and constructs a [`GetTableVersionInput`](crate::input::GetTableVersionInput).
pub fn build(
self,
) -> Result<crate::input::GetTableVersionInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::GetTableVersionInput {
catalog_id: self.catalog_id,
database_name: self.database_name,
table_name: self.table_name,
version_id: self.version_id,
})
}
}
}
impl GetTableVersionInput {
/// Consumes the builder and constructs an Operation<[`GetTableVersion`](crate::operation::GetTableVersion)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetTableVersion,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::GetTableVersionInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetTableVersionInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.GetTableVersion",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_get_table_version(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::GetTableVersion::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetTableVersion",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`GetTableVersionInput`](crate::input::GetTableVersionInput).
pub fn builder() -> crate::input::get_table_version_input::Builder {
crate::input::get_table_version_input::Builder::default()
}
}
/// See [`GetTableVersionsInput`](crate::input::GetTableVersionsInput).
pub mod get_table_versions_input {
/// A builder for [`GetTableVersionsInput`](crate::input::GetTableVersionsInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) catalog_id: std::option::Option<std::string::String>,
pub(crate) database_name: std::option::Option<std::string::String>,
pub(crate) table_name: std::option::Option<std::string::String>,
pub(crate) next_token: std::option::Option<std::string::String>,
pub(crate) max_results: std::option::Option<i32>,
}
impl Builder {
/// <p>The ID of the Data Catalog where the tables reside. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(mut self, input: impl Into<std::string::String>) -> Self {
self.catalog_id = Some(input.into());
self
}
/// <p>The ID of the Data Catalog where the tables reside. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn set_catalog_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.catalog_id = input;
self
}
/// <p>The database in the catalog in which the table resides. For Hive compatibility, this name is entirely lowercase.</p>
pub fn database_name(mut self, input: impl Into<std::string::String>) -> Self {
self.database_name = Some(input.into());
self
}
/// <p>The database in the catalog in which the table resides. For Hive compatibility, this name is entirely lowercase.</p>
pub fn set_database_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.database_name = input;
self
}
/// <p>The name of the table. For Hive compatibility, this name is entirely lowercase.</p>
pub fn table_name(mut self, input: impl Into<std::string::String>) -> Self {
self.table_name = Some(input.into());
self
}
/// <p>The name of the table. For Hive compatibility, this name is entirely lowercase.</p>
pub fn set_table_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.table_name = input;
self
}
/// <p>A continuation token, if this is not the first call.</p>
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
/// <p>A continuation token, if this is not the first call.</p>
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
/// <p>The maximum number of table versions to return in one response.</p>
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
/// <p>The maximum number of table versions to return in one response.</p>
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
/// Consumes the builder and constructs a [`GetTableVersionsInput`](crate::input::GetTableVersionsInput).
pub fn build(
self,
) -> Result<
crate::input::GetTableVersionsInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::GetTableVersionsInput {
catalog_id: self.catalog_id,
database_name: self.database_name,
table_name: self.table_name,
next_token: self.next_token,
max_results: self.max_results,
})
}
}
}
impl GetTableVersionsInput {
/// Consumes the builder and constructs an Operation<[`GetTableVersions`](crate::operation::GetTableVersions)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetTableVersions,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::GetTableVersionsInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetTableVersionsInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.GetTableVersions",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_get_table_versions(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::GetTableVersions::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetTableVersions",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`GetTableVersionsInput`](crate::input::GetTableVersionsInput).
pub fn builder() -> crate::input::get_table_versions_input::Builder {
crate::input::get_table_versions_input::Builder::default()
}
}
/// See [`GetTagsInput`](crate::input::GetTagsInput).
pub mod get_tags_input {
/// A builder for [`GetTagsInput`](crate::input::GetTagsInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) resource_arn: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The Amazon Resource Name (ARN) of the resource for which to retrieve tags.</p>
pub fn resource_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.resource_arn = Some(input.into());
self
}
/// <p>The Amazon Resource Name (ARN) of the resource for which to retrieve tags.</p>
pub fn set_resource_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.resource_arn = input;
self
}
/// Consumes the builder and constructs a [`GetTagsInput`](crate::input::GetTagsInput).
pub fn build(
self,
) -> Result<crate::input::GetTagsInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::GetTagsInput {
resource_arn: self.resource_arn,
})
}
}
}
impl GetTagsInput {
/// Consumes the builder and constructs an Operation<[`GetTags`](crate::operation::GetTags)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetTags,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::GetTagsInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetTagsInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.GetTags",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_get_tags(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op =
aws_smithy_http::operation::Operation::new(request, crate::operation::GetTags::new())
.with_metadata(aws_smithy_http::operation::Metadata::new("GetTags", "glue"));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`GetTagsInput`](crate::input::GetTagsInput).
pub fn builder() -> crate::input::get_tags_input::Builder {
crate::input::get_tags_input::Builder::default()
}
}
/// See [`GetTriggerInput`](crate::input::GetTriggerInput).
pub mod get_trigger_input {
/// A builder for [`GetTriggerInput`](crate::input::GetTriggerInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) name: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The name of the trigger to retrieve.</p>
pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
self.name = Some(input.into());
self
}
/// <p>The name of the trigger to retrieve.</p>
pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.name = input;
self
}
/// Consumes the builder and constructs a [`GetTriggerInput`](crate::input::GetTriggerInput).
pub fn build(
self,
) -> Result<crate::input::GetTriggerInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::GetTriggerInput { name: self.name })
}
}
}
impl GetTriggerInput {
/// Consumes the builder and constructs an Operation<[`GetTrigger`](crate::operation::GetTrigger)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetTrigger,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::GetTriggerInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetTriggerInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.GetTrigger",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_get_trigger(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::GetTrigger::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetTrigger",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`GetTriggerInput`](crate::input::GetTriggerInput).
pub fn builder() -> crate::input::get_trigger_input::Builder {
crate::input::get_trigger_input::Builder::default()
}
}
/// See [`GetTriggersInput`](crate::input::GetTriggersInput).
pub mod get_triggers_input {
/// A builder for [`GetTriggersInput`](crate::input::GetTriggersInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) next_token: std::option::Option<std::string::String>,
pub(crate) dependent_job_name: std::option::Option<std::string::String>,
pub(crate) max_results: std::option::Option<i32>,
}
impl Builder {
/// <p>A continuation token, if this is a continuation call.</p>
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
/// <p>A continuation token, if this is a continuation call.</p>
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
/// <p>The name of the job to retrieve triggers for. The trigger that can start this job is returned, and if there is no such trigger, all triggers are returned.</p>
pub fn dependent_job_name(mut self, input: impl Into<std::string::String>) -> Self {
self.dependent_job_name = Some(input.into());
self
}
/// <p>The name of the job to retrieve triggers for. The trigger that can start this job is returned, and if there is no such trigger, all triggers are returned.</p>
pub fn set_dependent_job_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.dependent_job_name = input;
self
}
/// <p>The maximum size of the response.</p>
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
/// <p>The maximum size of the response.</p>
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
/// Consumes the builder and constructs a [`GetTriggersInput`](crate::input::GetTriggersInput).
pub fn build(
self,
) -> Result<crate::input::GetTriggersInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::GetTriggersInput {
next_token: self.next_token,
dependent_job_name: self.dependent_job_name,
max_results: self.max_results,
})
}
}
}
impl GetTriggersInput {
/// Consumes the builder and constructs an Operation<[`GetTriggers`](crate::operation::GetTriggers)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetTriggers,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::GetTriggersInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetTriggersInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.GetTriggers",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_get_triggers(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::GetTriggers::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetTriggers",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`GetTriggersInput`](crate::input::GetTriggersInput).
pub fn builder() -> crate::input::get_triggers_input::Builder {
crate::input::get_triggers_input::Builder::default()
}
}
/// See [`GetUnfilteredPartitionMetadataInput`](crate::input::GetUnfilteredPartitionMetadataInput).
pub mod get_unfiltered_partition_metadata_input {
/// A builder for [`GetUnfilteredPartitionMetadataInput`](crate::input::GetUnfilteredPartitionMetadataInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) catalog_id: std::option::Option<std::string::String>,
pub(crate) database_name: std::option::Option<std::string::String>,
pub(crate) table_name: std::option::Option<std::string::String>,
pub(crate) partition_values: std::option::Option<std::vec::Vec<std::string::String>>,
pub(crate) audit_context: std::option::Option<crate::model::AuditContext>,
pub(crate) supported_permission_types:
std::option::Option<std::vec::Vec<crate::model::PermissionType>>,
}
impl Builder {
#[allow(missing_docs)] // documentation missing in model
pub fn catalog_id(mut self, input: impl Into<std::string::String>) -> Self {
self.catalog_id = Some(input.into());
self
}
#[allow(missing_docs)] // documentation missing in model
pub fn set_catalog_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.catalog_id = input;
self
}
#[allow(missing_docs)] // documentation missing in model
pub fn database_name(mut self, input: impl Into<std::string::String>) -> Self {
self.database_name = Some(input.into());
self
}
#[allow(missing_docs)] // documentation missing in model
pub fn set_database_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.database_name = input;
self
}
#[allow(missing_docs)] // documentation missing in model
pub fn table_name(mut self, input: impl Into<std::string::String>) -> Self {
self.table_name = Some(input.into());
self
}
#[allow(missing_docs)] // documentation missing in model
pub fn set_table_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.table_name = input;
self
}
/// Appends an item to `partition_values`.
///
/// To override the contents of this collection use [`set_partition_values`](Self::set_partition_values).
///
pub fn partition_values(mut self, input: impl Into<std::string::String>) -> Self {
let mut v = self.partition_values.unwrap_or_default();
v.push(input.into());
self.partition_values = Some(v);
self
}
#[allow(missing_docs)] // documentation missing in model
pub fn set_partition_values(
mut self,
input: std::option::Option<std::vec::Vec<std::string::String>>,
) -> Self {
self.partition_values = input;
self
}
/// <p>A structure containing information for audit.</p>
pub fn audit_context(mut self, input: crate::model::AuditContext) -> Self {
self.audit_context = Some(input);
self
}
/// <p>A structure containing information for audit.</p>
pub fn set_audit_context(
mut self,
input: std::option::Option<crate::model::AuditContext>,
) -> Self {
self.audit_context = input;
self
}
/// Appends an item to `supported_permission_types`.
///
/// To override the contents of this collection use [`set_supported_permission_types`](Self::set_supported_permission_types).
///
pub fn supported_permission_types(mut self, input: crate::model::PermissionType) -> Self {
let mut v = self.supported_permission_types.unwrap_or_default();
v.push(input);
self.supported_permission_types = Some(v);
self
}
#[allow(missing_docs)] // documentation missing in model
pub fn set_supported_permission_types(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::PermissionType>>,
) -> Self {
self.supported_permission_types = input;
self
}
/// Consumes the builder and constructs a [`GetUnfilteredPartitionMetadataInput`](crate::input::GetUnfilteredPartitionMetadataInput).
pub fn build(
self,
) -> Result<
crate::input::GetUnfilteredPartitionMetadataInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::GetUnfilteredPartitionMetadataInput {
catalog_id: self.catalog_id,
database_name: self.database_name,
table_name: self.table_name,
partition_values: self.partition_values,
audit_context: self.audit_context,
supported_permission_types: self.supported_permission_types,
})
}
}
}
impl GetUnfilteredPartitionMetadataInput {
/// Consumes the builder and constructs an Operation<[`GetUnfilteredPartitionMetadata`](crate::operation::GetUnfilteredPartitionMetadata)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetUnfilteredPartitionMetadata,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::GetUnfilteredPartitionMetadataInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetUnfilteredPartitionMetadataInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.GetUnfilteredPartitionMetadata",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_get_unfiltered_partition_metadata(&self)?
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::GetUnfilteredPartitionMetadata::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetUnfilteredPartitionMetadata",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`GetUnfilteredPartitionMetadataInput`](crate::input::GetUnfilteredPartitionMetadataInput).
pub fn builder() -> crate::input::get_unfiltered_partition_metadata_input::Builder {
crate::input::get_unfiltered_partition_metadata_input::Builder::default()
}
}
/// See [`GetUnfilteredPartitionsMetadataInput`](crate::input::GetUnfilteredPartitionsMetadataInput).
pub mod get_unfiltered_partitions_metadata_input {
/// A builder for [`GetUnfilteredPartitionsMetadataInput`](crate::input::GetUnfilteredPartitionsMetadataInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) catalog_id: std::option::Option<std::string::String>,
pub(crate) database_name: std::option::Option<std::string::String>,
pub(crate) table_name: std::option::Option<std::string::String>,
pub(crate) expression: std::option::Option<std::string::String>,
pub(crate) audit_context: std::option::Option<crate::model::AuditContext>,
pub(crate) supported_permission_types:
std::option::Option<std::vec::Vec<crate::model::PermissionType>>,
pub(crate) next_token: std::option::Option<std::string::String>,
pub(crate) segment: std::option::Option<crate::model::Segment>,
pub(crate) max_results: std::option::Option<i32>,
}
impl Builder {
#[allow(missing_docs)] // documentation missing in model
pub fn catalog_id(mut self, input: impl Into<std::string::String>) -> Self {
self.catalog_id = Some(input.into());
self
}
#[allow(missing_docs)] // documentation missing in model
pub fn set_catalog_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.catalog_id = input;
self
}
#[allow(missing_docs)] // documentation missing in model
pub fn database_name(mut self, input: impl Into<std::string::String>) -> Self {
self.database_name = Some(input.into());
self
}
#[allow(missing_docs)] // documentation missing in model
pub fn set_database_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.database_name = input;
self
}
#[allow(missing_docs)] // documentation missing in model
pub fn table_name(mut self, input: impl Into<std::string::String>) -> Self {
self.table_name = Some(input.into());
self
}
#[allow(missing_docs)] // documentation missing in model
pub fn set_table_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.table_name = input;
self
}
#[allow(missing_docs)] // documentation missing in model
pub fn expression(mut self, input: impl Into<std::string::String>) -> Self {
self.expression = Some(input.into());
self
}
#[allow(missing_docs)] // documentation missing in model
pub fn set_expression(mut self, input: std::option::Option<std::string::String>) -> Self {
self.expression = input;
self
}
/// <p>A structure containing information for audit.</p>
pub fn audit_context(mut self, input: crate::model::AuditContext) -> Self {
self.audit_context = Some(input);
self
}
/// <p>A structure containing information for audit.</p>
pub fn set_audit_context(
mut self,
input: std::option::Option<crate::model::AuditContext>,
) -> Self {
self.audit_context = input;
self
}
/// Appends an item to `supported_permission_types`.
///
/// To override the contents of this collection use [`set_supported_permission_types`](Self::set_supported_permission_types).
///
pub fn supported_permission_types(mut self, input: crate::model::PermissionType) -> Self {
let mut v = self.supported_permission_types.unwrap_or_default();
v.push(input);
self.supported_permission_types = Some(v);
self
}
#[allow(missing_docs)] // documentation missing in model
pub fn set_supported_permission_types(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::PermissionType>>,
) -> Self {
self.supported_permission_types = input;
self
}
#[allow(missing_docs)] // documentation missing in model
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
#[allow(missing_docs)] // documentation missing in model
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
/// <p>Defines a non-overlapping region of a table's partitions, allowing multiple requests to be run in parallel.</p>
pub fn segment(mut self, input: crate::model::Segment) -> Self {
self.segment = Some(input);
self
}
/// <p>Defines a non-overlapping region of a table's partitions, allowing multiple requests to be run in parallel.</p>
pub fn set_segment(mut self, input: std::option::Option<crate::model::Segment>) -> Self {
self.segment = input;
self
}
#[allow(missing_docs)] // documentation missing in model
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
#[allow(missing_docs)] // documentation missing in model
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
/// Consumes the builder and constructs a [`GetUnfilteredPartitionsMetadataInput`](crate::input::GetUnfilteredPartitionsMetadataInput).
pub fn build(
self,
) -> Result<
crate::input::GetUnfilteredPartitionsMetadataInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::GetUnfilteredPartitionsMetadataInput {
catalog_id: self.catalog_id,
database_name: self.database_name,
table_name: self.table_name,
expression: self.expression,
audit_context: self.audit_context,
supported_permission_types: self.supported_permission_types,
next_token: self.next_token,
segment: self.segment,
max_results: self.max_results,
})
}
}
}
impl GetUnfilteredPartitionsMetadataInput {
/// Consumes the builder and constructs an Operation<[`GetUnfilteredPartitionsMetadata`](crate::operation::GetUnfilteredPartitionsMetadata)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetUnfilteredPartitionsMetadata,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::GetUnfilteredPartitionsMetadataInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetUnfilteredPartitionsMetadataInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.GetUnfilteredPartitionsMetadata",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_get_unfiltered_partitions_metadata(&self)?
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::GetUnfilteredPartitionsMetadata::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetUnfilteredPartitionsMetadata",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`GetUnfilteredPartitionsMetadataInput`](crate::input::GetUnfilteredPartitionsMetadataInput).
pub fn builder() -> crate::input::get_unfiltered_partitions_metadata_input::Builder {
crate::input::get_unfiltered_partitions_metadata_input::Builder::default()
}
}
/// See [`GetUnfilteredTableMetadataInput`](crate::input::GetUnfilteredTableMetadataInput).
pub mod get_unfiltered_table_metadata_input {
/// A builder for [`GetUnfilteredTableMetadataInput`](crate::input::GetUnfilteredTableMetadataInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) catalog_id: std::option::Option<std::string::String>,
pub(crate) database_name: std::option::Option<std::string::String>,
pub(crate) name: std::option::Option<std::string::String>,
pub(crate) audit_context: std::option::Option<crate::model::AuditContext>,
pub(crate) supported_permission_types:
std::option::Option<std::vec::Vec<crate::model::PermissionType>>,
}
impl Builder {
#[allow(missing_docs)] // documentation missing in model
pub fn catalog_id(mut self, input: impl Into<std::string::String>) -> Self {
self.catalog_id = Some(input.into());
self
}
#[allow(missing_docs)] // documentation missing in model
pub fn set_catalog_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.catalog_id = input;
self
}
#[allow(missing_docs)] // documentation missing in model
pub fn database_name(mut self, input: impl Into<std::string::String>) -> Self {
self.database_name = Some(input.into());
self
}
#[allow(missing_docs)] // documentation missing in model
pub fn set_database_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.database_name = input;
self
}
#[allow(missing_docs)] // documentation missing in model
pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
self.name = Some(input.into());
self
}
#[allow(missing_docs)] // documentation missing in model
pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.name = input;
self
}
/// <p>A structure containing information for audit.</p>
pub fn audit_context(mut self, input: crate::model::AuditContext) -> Self {
self.audit_context = Some(input);
self
}
/// <p>A structure containing information for audit.</p>
pub fn set_audit_context(
mut self,
input: std::option::Option<crate::model::AuditContext>,
) -> Self {
self.audit_context = input;
self
}
/// Appends an item to `supported_permission_types`.
///
/// To override the contents of this collection use [`set_supported_permission_types`](Self::set_supported_permission_types).
///
pub fn supported_permission_types(mut self, input: crate::model::PermissionType) -> Self {
let mut v = self.supported_permission_types.unwrap_or_default();
v.push(input);
self.supported_permission_types = Some(v);
self
}
#[allow(missing_docs)] // documentation missing in model
pub fn set_supported_permission_types(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::PermissionType>>,
) -> Self {
self.supported_permission_types = input;
self
}
/// Consumes the builder and constructs a [`GetUnfilteredTableMetadataInput`](crate::input::GetUnfilteredTableMetadataInput).
pub fn build(
self,
) -> Result<
crate::input::GetUnfilteredTableMetadataInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::GetUnfilteredTableMetadataInput {
catalog_id: self.catalog_id,
database_name: self.database_name,
name: self.name,
audit_context: self.audit_context,
supported_permission_types: self.supported_permission_types,
})
}
}
}
impl GetUnfilteredTableMetadataInput {
/// Consumes the builder and constructs an Operation<[`GetUnfilteredTableMetadata`](crate::operation::GetUnfilteredTableMetadata)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetUnfilteredTableMetadata,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::GetUnfilteredTableMetadataInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetUnfilteredTableMetadataInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.GetUnfilteredTableMetadata",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_get_unfiltered_table_metadata(&self)?
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::GetUnfilteredTableMetadata::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetUnfilteredTableMetadata",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`GetUnfilteredTableMetadataInput`](crate::input::GetUnfilteredTableMetadataInput).
pub fn builder() -> crate::input::get_unfiltered_table_metadata_input::Builder {
crate::input::get_unfiltered_table_metadata_input::Builder::default()
}
}
/// See [`GetUserDefinedFunctionInput`](crate::input::GetUserDefinedFunctionInput).
pub mod get_user_defined_function_input {
/// A builder for [`GetUserDefinedFunctionInput`](crate::input::GetUserDefinedFunctionInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) catalog_id: std::option::Option<std::string::String>,
pub(crate) database_name: std::option::Option<std::string::String>,
pub(crate) function_name: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The ID of the Data Catalog where the function to be retrieved is located. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(mut self, input: impl Into<std::string::String>) -> Self {
self.catalog_id = Some(input.into());
self
}
/// <p>The ID of the Data Catalog where the function to be retrieved is located. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn set_catalog_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.catalog_id = input;
self
}
/// <p>The name of the catalog database where the function is located.</p>
pub fn database_name(mut self, input: impl Into<std::string::String>) -> Self {
self.database_name = Some(input.into());
self
}
/// <p>The name of the catalog database where the function is located.</p>
pub fn set_database_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.database_name = input;
self
}
/// <p>The name of the function.</p>
pub fn function_name(mut self, input: impl Into<std::string::String>) -> Self {
self.function_name = Some(input.into());
self
}
/// <p>The name of the function.</p>
pub fn set_function_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.function_name = input;
self
}
/// Consumes the builder and constructs a [`GetUserDefinedFunctionInput`](crate::input::GetUserDefinedFunctionInput).
pub fn build(
self,
) -> Result<
crate::input::GetUserDefinedFunctionInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::GetUserDefinedFunctionInput {
catalog_id: self.catalog_id,
database_name: self.database_name,
function_name: self.function_name,
})
}
}
}
impl GetUserDefinedFunctionInput {
/// Consumes the builder and constructs an Operation<[`GetUserDefinedFunction`](crate::operation::GetUserDefinedFunction)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetUserDefinedFunction,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::GetUserDefinedFunctionInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetUserDefinedFunctionInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.GetUserDefinedFunction",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_get_user_defined_function(
&self,
)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::GetUserDefinedFunction::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetUserDefinedFunction",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`GetUserDefinedFunctionInput`](crate::input::GetUserDefinedFunctionInput).
pub fn builder() -> crate::input::get_user_defined_function_input::Builder {
crate::input::get_user_defined_function_input::Builder::default()
}
}
/// See [`GetUserDefinedFunctionsInput`](crate::input::GetUserDefinedFunctionsInput).
pub mod get_user_defined_functions_input {
/// A builder for [`GetUserDefinedFunctionsInput`](crate::input::GetUserDefinedFunctionsInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) catalog_id: std::option::Option<std::string::String>,
pub(crate) database_name: std::option::Option<std::string::String>,
pub(crate) pattern: std::option::Option<std::string::String>,
pub(crate) next_token: std::option::Option<std::string::String>,
pub(crate) max_results: std::option::Option<i32>,
}
impl Builder {
/// <p>The ID of the Data Catalog where the functions to be retrieved are located. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(mut self, input: impl Into<std::string::String>) -> Self {
self.catalog_id = Some(input.into());
self
}
/// <p>The ID of the Data Catalog where the functions to be retrieved are located. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn set_catalog_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.catalog_id = input;
self
}
/// <p>The name of the catalog database where the functions are located. If none is provided, functions from all the databases across the catalog will be returned.</p>
pub fn database_name(mut self, input: impl Into<std::string::String>) -> Self {
self.database_name = Some(input.into());
self
}
/// <p>The name of the catalog database where the functions are located. If none is provided, functions from all the databases across the catalog will be returned.</p>
pub fn set_database_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.database_name = input;
self
}
/// <p>An optional function-name pattern string that filters the function definitions returned.</p>
pub fn pattern(mut self, input: impl Into<std::string::String>) -> Self {
self.pattern = Some(input.into());
self
}
/// <p>An optional function-name pattern string that filters the function definitions returned.</p>
pub fn set_pattern(mut self, input: std::option::Option<std::string::String>) -> Self {
self.pattern = input;
self
}
/// <p>A continuation token, if this is a continuation call.</p>
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
/// <p>A continuation token, if this is a continuation call.</p>
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
/// <p>The maximum number of functions to return in one response.</p>
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
/// <p>The maximum number of functions to return in one response.</p>
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
/// Consumes the builder and constructs a [`GetUserDefinedFunctionsInput`](crate::input::GetUserDefinedFunctionsInput).
pub fn build(
self,
) -> Result<
crate::input::GetUserDefinedFunctionsInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::GetUserDefinedFunctionsInput {
catalog_id: self.catalog_id,
database_name: self.database_name,
pattern: self.pattern,
next_token: self.next_token,
max_results: self.max_results,
})
}
}
}
impl GetUserDefinedFunctionsInput {
/// Consumes the builder and constructs an Operation<[`GetUserDefinedFunctions`](crate::operation::GetUserDefinedFunctions)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetUserDefinedFunctions,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::GetUserDefinedFunctionsInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetUserDefinedFunctionsInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.GetUserDefinedFunctions",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_get_user_defined_functions(
&self,
)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::GetUserDefinedFunctions::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetUserDefinedFunctions",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`GetUserDefinedFunctionsInput`](crate::input::GetUserDefinedFunctionsInput).
pub fn builder() -> crate::input::get_user_defined_functions_input::Builder {
crate::input::get_user_defined_functions_input::Builder::default()
}
}
/// See [`GetWorkflowInput`](crate::input::GetWorkflowInput).
pub mod get_workflow_input {
/// A builder for [`GetWorkflowInput`](crate::input::GetWorkflowInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) name: std::option::Option<std::string::String>,
pub(crate) include_graph: std::option::Option<bool>,
}
impl Builder {
/// <p>The name of the workflow to retrieve.</p>
pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
self.name = Some(input.into());
self
}
/// <p>The name of the workflow to retrieve.</p>
pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.name = input;
self
}
/// <p>Specifies whether to include a graph when returning the workflow resource metadata.</p>
pub fn include_graph(mut self, input: bool) -> Self {
self.include_graph = Some(input);
self
}
/// <p>Specifies whether to include a graph when returning the workflow resource metadata.</p>
pub fn set_include_graph(mut self, input: std::option::Option<bool>) -> Self {
self.include_graph = input;
self
}
/// Consumes the builder and constructs a [`GetWorkflowInput`](crate::input::GetWorkflowInput).
pub fn build(
self,
) -> Result<crate::input::GetWorkflowInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::GetWorkflowInput {
name: self.name,
include_graph: self.include_graph,
})
}
}
}
impl GetWorkflowInput {
/// Consumes the builder and constructs an Operation<[`GetWorkflow`](crate::operation::GetWorkflow)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetWorkflow,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::GetWorkflowInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetWorkflowInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.GetWorkflow",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_get_workflow(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::GetWorkflow::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetWorkflow",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`GetWorkflowInput`](crate::input::GetWorkflowInput).
pub fn builder() -> crate::input::get_workflow_input::Builder {
crate::input::get_workflow_input::Builder::default()
}
}
/// See [`GetWorkflowRunInput`](crate::input::GetWorkflowRunInput).
pub mod get_workflow_run_input {
/// A builder for [`GetWorkflowRunInput`](crate::input::GetWorkflowRunInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) name: std::option::Option<std::string::String>,
pub(crate) run_id: std::option::Option<std::string::String>,
pub(crate) include_graph: std::option::Option<bool>,
}
impl Builder {
/// <p>Name of the workflow being run.</p>
pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
self.name = Some(input.into());
self
}
/// <p>Name of the workflow being run.</p>
pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.name = input;
self
}
/// <p>The ID of the workflow run.</p>
pub fn run_id(mut self, input: impl Into<std::string::String>) -> Self {
self.run_id = Some(input.into());
self
}
/// <p>The ID of the workflow run.</p>
pub fn set_run_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.run_id = input;
self
}
/// <p>Specifies whether to include the workflow graph in response or not.</p>
pub fn include_graph(mut self, input: bool) -> Self {
self.include_graph = Some(input);
self
}
/// <p>Specifies whether to include the workflow graph in response or not.</p>
pub fn set_include_graph(mut self, input: std::option::Option<bool>) -> Self {
self.include_graph = input;
self
}
/// Consumes the builder and constructs a [`GetWorkflowRunInput`](crate::input::GetWorkflowRunInput).
pub fn build(
self,
) -> Result<crate::input::GetWorkflowRunInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::GetWorkflowRunInput {
name: self.name,
run_id: self.run_id,
include_graph: self.include_graph,
})
}
}
}
impl GetWorkflowRunInput {
/// Consumes the builder and constructs an Operation<[`GetWorkflowRun`](crate::operation::GetWorkflowRun)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetWorkflowRun,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::GetWorkflowRunInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetWorkflowRunInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.GetWorkflowRun",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_get_workflow_run(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::GetWorkflowRun::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetWorkflowRun",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`GetWorkflowRunInput`](crate::input::GetWorkflowRunInput).
pub fn builder() -> crate::input::get_workflow_run_input::Builder {
crate::input::get_workflow_run_input::Builder::default()
}
}
/// See [`GetWorkflowRunPropertiesInput`](crate::input::GetWorkflowRunPropertiesInput).
pub mod get_workflow_run_properties_input {
/// A builder for [`GetWorkflowRunPropertiesInput`](crate::input::GetWorkflowRunPropertiesInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) name: std::option::Option<std::string::String>,
pub(crate) run_id: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>Name of the workflow which was run.</p>
pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
self.name = Some(input.into());
self
}
/// <p>Name of the workflow which was run.</p>
pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.name = input;
self
}
/// <p>The ID of the workflow run whose run properties should be returned.</p>
pub fn run_id(mut self, input: impl Into<std::string::String>) -> Self {
self.run_id = Some(input.into());
self
}
/// <p>The ID of the workflow run whose run properties should be returned.</p>
pub fn set_run_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.run_id = input;
self
}
/// Consumes the builder and constructs a [`GetWorkflowRunPropertiesInput`](crate::input::GetWorkflowRunPropertiesInput).
pub fn build(
self,
) -> Result<
crate::input::GetWorkflowRunPropertiesInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::GetWorkflowRunPropertiesInput {
name: self.name,
run_id: self.run_id,
})
}
}
}
impl GetWorkflowRunPropertiesInput {
/// Consumes the builder and constructs an Operation<[`GetWorkflowRunProperties`](crate::operation::GetWorkflowRunProperties)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetWorkflowRunProperties,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::GetWorkflowRunPropertiesInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetWorkflowRunPropertiesInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.GetWorkflowRunProperties",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_get_workflow_run_properties(
&self,
)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::GetWorkflowRunProperties::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetWorkflowRunProperties",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`GetWorkflowRunPropertiesInput`](crate::input::GetWorkflowRunPropertiesInput).
pub fn builder() -> crate::input::get_workflow_run_properties_input::Builder {
crate::input::get_workflow_run_properties_input::Builder::default()
}
}
/// See [`GetWorkflowRunsInput`](crate::input::GetWorkflowRunsInput).
pub mod get_workflow_runs_input {
/// A builder for [`GetWorkflowRunsInput`](crate::input::GetWorkflowRunsInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) name: std::option::Option<std::string::String>,
pub(crate) include_graph: std::option::Option<bool>,
pub(crate) next_token: std::option::Option<std::string::String>,
pub(crate) max_results: std::option::Option<i32>,
}
impl Builder {
/// <p>Name of the workflow whose metadata of runs should be returned.</p>
pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
self.name = Some(input.into());
self
}
/// <p>Name of the workflow whose metadata of runs should be returned.</p>
pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.name = input;
self
}
/// <p>Specifies whether to include the workflow graph in response or not.</p>
pub fn include_graph(mut self, input: bool) -> Self {
self.include_graph = Some(input);
self
}
/// <p>Specifies whether to include the workflow graph in response or not.</p>
pub fn set_include_graph(mut self, input: std::option::Option<bool>) -> Self {
self.include_graph = input;
self
}
/// <p>The maximum size of the response.</p>
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
/// <p>The maximum size of the response.</p>
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
/// <p>The maximum number of workflow runs to be included in the response.</p>
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
/// <p>The maximum number of workflow runs to be included in the response.</p>
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
/// Consumes the builder and constructs a [`GetWorkflowRunsInput`](crate::input::GetWorkflowRunsInput).
pub fn build(
self,
) -> Result<crate::input::GetWorkflowRunsInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::GetWorkflowRunsInput {
name: self.name,
include_graph: self.include_graph,
next_token: self.next_token,
max_results: self.max_results,
})
}
}
}
impl GetWorkflowRunsInput {
/// Consumes the builder and constructs an Operation<[`GetWorkflowRuns`](crate::operation::GetWorkflowRuns)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::GetWorkflowRuns,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::GetWorkflowRunsInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetWorkflowRunsInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.GetWorkflowRuns",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_get_workflow_runs(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::GetWorkflowRuns::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetWorkflowRuns",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`GetWorkflowRunsInput`](crate::input::GetWorkflowRunsInput).
pub fn builder() -> crate::input::get_workflow_runs_input::Builder {
crate::input::get_workflow_runs_input::Builder::default()
}
}
/// See [`ImportCatalogToGlueInput`](crate::input::ImportCatalogToGlueInput).
pub mod import_catalog_to_glue_input {
/// A builder for [`ImportCatalogToGlueInput`](crate::input::ImportCatalogToGlueInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) catalog_id: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The ID of the catalog to import. Currently, this should be the Amazon Web Services account ID.</p>
pub fn catalog_id(mut self, input: impl Into<std::string::String>) -> Self {
self.catalog_id = Some(input.into());
self
}
/// <p>The ID of the catalog to import. Currently, this should be the Amazon Web Services account ID.</p>
pub fn set_catalog_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.catalog_id = input;
self
}
/// Consumes the builder and constructs a [`ImportCatalogToGlueInput`](crate::input::ImportCatalogToGlueInput).
pub fn build(
self,
) -> Result<
crate::input::ImportCatalogToGlueInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::ImportCatalogToGlueInput {
catalog_id: self.catalog_id,
})
}
}
}
impl ImportCatalogToGlueInput {
/// Consumes the builder and constructs an Operation<[`ImportCatalogToGlue`](crate::operation::ImportCatalogToGlue)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::ImportCatalogToGlue,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::ImportCatalogToGlueInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::ImportCatalogToGlueInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.ImportCatalogToGlue",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_import_catalog_to_glue(
&self,
)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::ImportCatalogToGlue::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"ImportCatalogToGlue",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`ImportCatalogToGlueInput`](crate::input::ImportCatalogToGlueInput).
pub fn builder() -> crate::input::import_catalog_to_glue_input::Builder {
crate::input::import_catalog_to_glue_input::Builder::default()
}
}
/// See [`ListBlueprintsInput`](crate::input::ListBlueprintsInput).
pub mod list_blueprints_input {
/// A builder for [`ListBlueprintsInput`](crate::input::ListBlueprintsInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) next_token: std::option::Option<std::string::String>,
pub(crate) max_results: std::option::Option<i32>,
pub(crate) tags: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
}
impl Builder {
/// <p>A continuation token, if this is a continuation request.</p>
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
/// <p>A continuation token, if this is a continuation request.</p>
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
/// <p>The maximum size of a list to return.</p>
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
/// <p>The maximum size of a list to return.</p>
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
/// Adds a key-value pair to `tags`.
///
/// To override the contents of this collection use [`set_tags`](Self::set_tags).
///
/// <p>Filters the list by an Amazon Web Services resource tag.</p>
pub fn tags(
mut self,
k: impl Into<std::string::String>,
v: impl Into<std::string::String>,
) -> Self {
let mut hash_map = self.tags.unwrap_or_default();
hash_map.insert(k.into(), v.into());
self.tags = Some(hash_map);
self
}
/// <p>Filters the list by an Amazon Web Services resource tag.</p>
pub fn set_tags(
mut self,
input: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
) -> Self {
self.tags = input;
self
}
/// Consumes the builder and constructs a [`ListBlueprintsInput`](crate::input::ListBlueprintsInput).
pub fn build(
self,
) -> Result<crate::input::ListBlueprintsInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::ListBlueprintsInput {
next_token: self.next_token,
max_results: self.max_results,
tags: self.tags,
})
}
}
}
impl ListBlueprintsInput {
/// Consumes the builder and constructs an Operation<[`ListBlueprints`](crate::operation::ListBlueprints)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::ListBlueprints,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::ListBlueprintsInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::ListBlueprintsInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.ListBlueprints",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_list_blueprints(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::ListBlueprints::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"ListBlueprints",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`ListBlueprintsInput`](crate::input::ListBlueprintsInput).
pub fn builder() -> crate::input::list_blueprints_input::Builder {
crate::input::list_blueprints_input::Builder::default()
}
}
/// See [`ListCrawlersInput`](crate::input::ListCrawlersInput).
pub mod list_crawlers_input {
/// A builder for [`ListCrawlersInput`](crate::input::ListCrawlersInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) max_results: std::option::Option<i32>,
pub(crate) next_token: std::option::Option<std::string::String>,
pub(crate) tags: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
}
impl Builder {
/// <p>The maximum size of a list to return.</p>
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
/// <p>The maximum size of a list to return.</p>
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
/// <p>A continuation token, if this is a continuation request.</p>
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
/// <p>A continuation token, if this is a continuation request.</p>
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
/// Adds a key-value pair to `tags`.
///
/// To override the contents of this collection use [`set_tags`](Self::set_tags).
///
/// <p>Specifies to return only these tagged resources.</p>
pub fn tags(
mut self,
k: impl Into<std::string::String>,
v: impl Into<std::string::String>,
) -> Self {
let mut hash_map = self.tags.unwrap_or_default();
hash_map.insert(k.into(), v.into());
self.tags = Some(hash_map);
self
}
/// <p>Specifies to return only these tagged resources.</p>
pub fn set_tags(
mut self,
input: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
) -> Self {
self.tags = input;
self
}
/// Consumes the builder and constructs a [`ListCrawlersInput`](crate::input::ListCrawlersInput).
pub fn build(
self,
) -> Result<crate::input::ListCrawlersInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::ListCrawlersInput {
max_results: self.max_results,
next_token: self.next_token,
tags: self.tags,
})
}
}
}
impl ListCrawlersInput {
/// Consumes the builder and constructs an Operation<[`ListCrawlers`](crate::operation::ListCrawlers)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::ListCrawlers,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::ListCrawlersInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::ListCrawlersInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.ListCrawlers",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_list_crawlers(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::ListCrawlers::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"ListCrawlers",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`ListCrawlersInput`](crate::input::ListCrawlersInput).
pub fn builder() -> crate::input::list_crawlers_input::Builder {
crate::input::list_crawlers_input::Builder::default()
}
}
/// See [`ListCrawlsInput`](crate::input::ListCrawlsInput).
pub mod list_crawls_input {
/// A builder for [`ListCrawlsInput`](crate::input::ListCrawlsInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) crawler_name: std::option::Option<std::string::String>,
pub(crate) max_results: std::option::Option<i32>,
pub(crate) filters: std::option::Option<std::vec::Vec<crate::model::CrawlsFilter>>,
pub(crate) next_token: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The name of the crawler whose runs you want to retrieve.</p>
pub fn crawler_name(mut self, input: impl Into<std::string::String>) -> Self {
self.crawler_name = Some(input.into());
self
}
/// <p>The name of the crawler whose runs you want to retrieve.</p>
pub fn set_crawler_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.crawler_name = input;
self
}
/// <p>The maximum number of results to return. The default is 20, and maximum is 100.</p>
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
/// <p>The maximum number of results to return. The default is 20, and maximum is 100.</p>
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
/// Appends an item to `filters`.
///
/// To override the contents of this collection use [`set_filters`](Self::set_filters).
///
/// <p>Filters the crawls by the criteria you specify in a list of <code>CrawlsFilter</code> objects.</p>
pub fn filters(mut self, input: crate::model::CrawlsFilter) -> Self {
let mut v = self.filters.unwrap_or_default();
v.push(input);
self.filters = Some(v);
self
}
/// <p>Filters the crawls by the criteria you specify in a list of <code>CrawlsFilter</code> objects.</p>
pub fn set_filters(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::CrawlsFilter>>,
) -> Self {
self.filters = input;
self
}
/// <p>A continuation token, if this is a continuation call.</p>
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
/// <p>A continuation token, if this is a continuation call.</p>
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
/// Consumes the builder and constructs a [`ListCrawlsInput`](crate::input::ListCrawlsInput).
pub fn build(
self,
) -> Result<crate::input::ListCrawlsInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::ListCrawlsInput {
crawler_name: self.crawler_name,
max_results: self.max_results,
filters: self.filters,
next_token: self.next_token,
})
}
}
}
impl ListCrawlsInput {
/// Consumes the builder and constructs an Operation<[`ListCrawls`](crate::operation::ListCrawls)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::ListCrawls,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::ListCrawlsInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::ListCrawlsInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.ListCrawls",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_list_crawls(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::ListCrawls::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"ListCrawls",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`ListCrawlsInput`](crate::input::ListCrawlsInput).
pub fn builder() -> crate::input::list_crawls_input::Builder {
crate::input::list_crawls_input::Builder::default()
}
}
/// See [`ListCustomEntityTypesInput`](crate::input::ListCustomEntityTypesInput).
pub mod list_custom_entity_types_input {
/// A builder for [`ListCustomEntityTypesInput`](crate::input::ListCustomEntityTypesInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) next_token: std::option::Option<std::string::String>,
pub(crate) max_results: std::option::Option<i32>,
}
impl Builder {
/// <p>A paginated token to offset the results.</p>
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
/// <p>A paginated token to offset the results.</p>
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
/// <p>The maximum number of results to return.</p>
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
/// <p>The maximum number of results to return.</p>
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
/// Consumes the builder and constructs a [`ListCustomEntityTypesInput`](crate::input::ListCustomEntityTypesInput).
pub fn build(
self,
) -> Result<
crate::input::ListCustomEntityTypesInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::ListCustomEntityTypesInput {
next_token: self.next_token,
max_results: self.max_results,
})
}
}
}
impl ListCustomEntityTypesInput {
/// Consumes the builder and constructs an Operation<[`ListCustomEntityTypes`](crate::operation::ListCustomEntityTypes)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::ListCustomEntityTypes,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::ListCustomEntityTypesInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::ListCustomEntityTypesInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.ListCustomEntityTypes",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_list_custom_entity_types(
&self,
)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::ListCustomEntityTypes::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"ListCustomEntityTypes",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`ListCustomEntityTypesInput`](crate::input::ListCustomEntityTypesInput).
pub fn builder() -> crate::input::list_custom_entity_types_input::Builder {
crate::input::list_custom_entity_types_input::Builder::default()
}
}
/// See [`ListDataQualityResultsInput`](crate::input::ListDataQualityResultsInput).
pub mod list_data_quality_results_input {
/// A builder for [`ListDataQualityResultsInput`](crate::input::ListDataQualityResultsInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) filter: std::option::Option<crate::model::DataQualityResultFilterCriteria>,
pub(crate) next_token: std::option::Option<std::string::String>,
pub(crate) max_results: std::option::Option<i32>,
}
impl Builder {
/// <p>The filter criteria.</p>
pub fn filter(mut self, input: crate::model::DataQualityResultFilterCriteria) -> Self {
self.filter = Some(input);
self
}
/// <p>The filter criteria.</p>
pub fn set_filter(
mut self,
input: std::option::Option<crate::model::DataQualityResultFilterCriteria>,
) -> Self {
self.filter = input;
self
}
/// <p>A paginated token to offset the results.</p>
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
/// <p>A paginated token to offset the results.</p>
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
/// <p>The maximum number of results to return.</p>
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
/// <p>The maximum number of results to return.</p>
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
/// Consumes the builder and constructs a [`ListDataQualityResultsInput`](crate::input::ListDataQualityResultsInput).
pub fn build(
self,
) -> Result<
crate::input::ListDataQualityResultsInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::ListDataQualityResultsInput {
filter: self.filter,
next_token: self.next_token,
max_results: self.max_results,
})
}
}
}
impl ListDataQualityResultsInput {
/// Consumes the builder and constructs an Operation<[`ListDataQualityResults`](crate::operation::ListDataQualityResults)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::ListDataQualityResults,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::ListDataQualityResultsInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::ListDataQualityResultsInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.ListDataQualityResults",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_list_data_quality_results(
&self,
)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::ListDataQualityResults::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"ListDataQualityResults",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`ListDataQualityResultsInput`](crate::input::ListDataQualityResultsInput).
pub fn builder() -> crate::input::list_data_quality_results_input::Builder {
crate::input::list_data_quality_results_input::Builder::default()
}
}
/// See [`ListDataQualityRuleRecommendationRunsInput`](crate::input::ListDataQualityRuleRecommendationRunsInput).
pub mod list_data_quality_rule_recommendation_runs_input {
/// A builder for [`ListDataQualityRuleRecommendationRunsInput`](crate::input::ListDataQualityRuleRecommendationRunsInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) filter:
std::option::Option<crate::model::DataQualityRuleRecommendationRunFilter>,
pub(crate) next_token: std::option::Option<std::string::String>,
pub(crate) max_results: std::option::Option<i32>,
}
impl Builder {
/// <p>The filter criteria.</p>
pub fn filter(
mut self,
input: crate::model::DataQualityRuleRecommendationRunFilter,
) -> Self {
self.filter = Some(input);
self
}
/// <p>The filter criteria.</p>
pub fn set_filter(
mut self,
input: std::option::Option<crate::model::DataQualityRuleRecommendationRunFilter>,
) -> Self {
self.filter = input;
self
}
/// <p>A paginated token to offset the results.</p>
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
/// <p>A paginated token to offset the results.</p>
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
/// <p>The maximum number of results to return.</p>
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
/// <p>The maximum number of results to return.</p>
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
/// Consumes the builder and constructs a [`ListDataQualityRuleRecommendationRunsInput`](crate::input::ListDataQualityRuleRecommendationRunsInput).
pub fn build(
self,
) -> Result<
crate::input::ListDataQualityRuleRecommendationRunsInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::ListDataQualityRuleRecommendationRunsInput {
filter: self.filter,
next_token: self.next_token,
max_results: self.max_results,
})
}
}
}
impl ListDataQualityRuleRecommendationRunsInput {
/// Consumes the builder and constructs an Operation<[`ListDataQualityRuleRecommendationRuns`](crate::operation::ListDataQualityRuleRecommendationRuns)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::ListDataQualityRuleRecommendationRuns,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::ListDataQualityRuleRecommendationRunsInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::ListDataQualityRuleRecommendationRunsInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.ListDataQualityRuleRecommendationRuns",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_list_data_quality_rule_recommendation_runs(&self)?
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::ListDataQualityRuleRecommendationRuns::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"ListDataQualityRuleRecommendationRuns",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`ListDataQualityRuleRecommendationRunsInput`](crate::input::ListDataQualityRuleRecommendationRunsInput).
pub fn builder() -> crate::input::list_data_quality_rule_recommendation_runs_input::Builder {
crate::input::list_data_quality_rule_recommendation_runs_input::Builder::default()
}
}
/// See [`ListDataQualityRulesetEvaluationRunsInput`](crate::input::ListDataQualityRulesetEvaluationRunsInput).
pub mod list_data_quality_ruleset_evaluation_runs_input {
/// A builder for [`ListDataQualityRulesetEvaluationRunsInput`](crate::input::ListDataQualityRulesetEvaluationRunsInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) filter: std::option::Option<crate::model::DataQualityRulesetEvaluationRunFilter>,
pub(crate) next_token: std::option::Option<std::string::String>,
pub(crate) max_results: std::option::Option<i32>,
}
impl Builder {
/// <p>The filter criteria.</p>
pub fn filter(
mut self,
input: crate::model::DataQualityRulesetEvaluationRunFilter,
) -> Self {
self.filter = Some(input);
self
}
/// <p>The filter criteria.</p>
pub fn set_filter(
mut self,
input: std::option::Option<crate::model::DataQualityRulesetEvaluationRunFilter>,
) -> Self {
self.filter = input;
self
}
/// <p>A paginated token to offset the results.</p>
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
/// <p>A paginated token to offset the results.</p>
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
/// <p>The maximum number of results to return.</p>
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
/// <p>The maximum number of results to return.</p>
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
/// Consumes the builder and constructs a [`ListDataQualityRulesetEvaluationRunsInput`](crate::input::ListDataQualityRulesetEvaluationRunsInput).
pub fn build(
self,
) -> Result<
crate::input::ListDataQualityRulesetEvaluationRunsInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::ListDataQualityRulesetEvaluationRunsInput {
filter: self.filter,
next_token: self.next_token,
max_results: self.max_results,
})
}
}
}
impl ListDataQualityRulesetEvaluationRunsInput {
/// Consumes the builder and constructs an Operation<[`ListDataQualityRulesetEvaluationRuns`](crate::operation::ListDataQualityRulesetEvaluationRuns)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::ListDataQualityRulesetEvaluationRuns,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::ListDataQualityRulesetEvaluationRunsInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::ListDataQualityRulesetEvaluationRunsInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.ListDataQualityRulesetEvaluationRuns",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_list_data_quality_ruleset_evaluation_runs(&self)?
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::ListDataQualityRulesetEvaluationRuns::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"ListDataQualityRulesetEvaluationRuns",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`ListDataQualityRulesetEvaluationRunsInput`](crate::input::ListDataQualityRulesetEvaluationRunsInput).
pub fn builder() -> crate::input::list_data_quality_ruleset_evaluation_runs_input::Builder {
crate::input::list_data_quality_ruleset_evaluation_runs_input::Builder::default()
}
}
/// See [`ListDataQualityRulesetsInput`](crate::input::ListDataQualityRulesetsInput).
pub mod list_data_quality_rulesets_input {
/// A builder for [`ListDataQualityRulesetsInput`](crate::input::ListDataQualityRulesetsInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) next_token: std::option::Option<std::string::String>,
pub(crate) max_results: std::option::Option<i32>,
pub(crate) filter: std::option::Option<crate::model::DataQualityRulesetFilterCriteria>,
pub(crate) tags: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
}
impl Builder {
/// <p>A paginated token to offset the results.</p>
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
/// <p>A paginated token to offset the results.</p>
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
/// <p>The maximum number of results to return.</p>
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
/// <p>The maximum number of results to return.</p>
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
/// <p>The filter criteria. </p>
pub fn filter(mut self, input: crate::model::DataQualityRulesetFilterCriteria) -> Self {
self.filter = Some(input);
self
}
/// <p>The filter criteria. </p>
pub fn set_filter(
mut self,
input: std::option::Option<crate::model::DataQualityRulesetFilterCriteria>,
) -> Self {
self.filter = input;
self
}
/// Adds a key-value pair to `tags`.
///
/// To override the contents of this collection use [`set_tags`](Self::set_tags).
///
/// <p>A list of key-value pair tags.</p>
pub fn tags(
mut self,
k: impl Into<std::string::String>,
v: impl Into<std::string::String>,
) -> Self {
let mut hash_map = self.tags.unwrap_or_default();
hash_map.insert(k.into(), v.into());
self.tags = Some(hash_map);
self
}
/// <p>A list of key-value pair tags.</p>
pub fn set_tags(
mut self,
input: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
) -> Self {
self.tags = input;
self
}
/// Consumes the builder and constructs a [`ListDataQualityRulesetsInput`](crate::input::ListDataQualityRulesetsInput).
pub fn build(
self,
) -> Result<
crate::input::ListDataQualityRulesetsInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::ListDataQualityRulesetsInput {
next_token: self.next_token,
max_results: self.max_results,
filter: self.filter,
tags: self.tags,
})
}
}
}
impl ListDataQualityRulesetsInput {
/// Consumes the builder and constructs an Operation<[`ListDataQualityRulesets`](crate::operation::ListDataQualityRulesets)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::ListDataQualityRulesets,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::ListDataQualityRulesetsInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::ListDataQualityRulesetsInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.ListDataQualityRulesets",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_list_data_quality_rulesets(
&self,
)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::ListDataQualityRulesets::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"ListDataQualityRulesets",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`ListDataQualityRulesetsInput`](crate::input::ListDataQualityRulesetsInput).
pub fn builder() -> crate::input::list_data_quality_rulesets_input::Builder {
crate::input::list_data_quality_rulesets_input::Builder::default()
}
}
/// See [`ListDevEndpointsInput`](crate::input::ListDevEndpointsInput).
pub mod list_dev_endpoints_input {
/// A builder for [`ListDevEndpointsInput`](crate::input::ListDevEndpointsInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) next_token: std::option::Option<std::string::String>,
pub(crate) max_results: std::option::Option<i32>,
pub(crate) tags: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
}
impl Builder {
/// <p>A continuation token, if this is a continuation request.</p>
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
/// <p>A continuation token, if this is a continuation request.</p>
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
/// <p>The maximum size of a list to return.</p>
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
/// <p>The maximum size of a list to return.</p>
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
/// Adds a key-value pair to `tags`.
///
/// To override the contents of this collection use [`set_tags`](Self::set_tags).
///
/// <p>Specifies to return only these tagged resources.</p>
pub fn tags(
mut self,
k: impl Into<std::string::String>,
v: impl Into<std::string::String>,
) -> Self {
let mut hash_map = self.tags.unwrap_or_default();
hash_map.insert(k.into(), v.into());
self.tags = Some(hash_map);
self
}
/// <p>Specifies to return only these tagged resources.</p>
pub fn set_tags(
mut self,
input: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
) -> Self {
self.tags = input;
self
}
/// Consumes the builder and constructs a [`ListDevEndpointsInput`](crate::input::ListDevEndpointsInput).
pub fn build(
self,
) -> Result<
crate::input::ListDevEndpointsInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::ListDevEndpointsInput {
next_token: self.next_token,
max_results: self.max_results,
tags: self.tags,
})
}
}
}
impl ListDevEndpointsInput {
/// Consumes the builder and constructs an Operation<[`ListDevEndpoints`](crate::operation::ListDevEndpoints)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::ListDevEndpoints,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::ListDevEndpointsInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::ListDevEndpointsInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.ListDevEndpoints",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_list_dev_endpoints(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::ListDevEndpoints::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"ListDevEndpoints",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`ListDevEndpointsInput`](crate::input::ListDevEndpointsInput).
pub fn builder() -> crate::input::list_dev_endpoints_input::Builder {
crate::input::list_dev_endpoints_input::Builder::default()
}
}
/// See [`ListJobsInput`](crate::input::ListJobsInput).
pub mod list_jobs_input {
/// A builder for [`ListJobsInput`](crate::input::ListJobsInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) next_token: std::option::Option<std::string::String>,
pub(crate) max_results: std::option::Option<i32>,
pub(crate) tags: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
}
impl Builder {
/// <p>A continuation token, if this is a continuation request.</p>
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
/// <p>A continuation token, if this is a continuation request.</p>
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
/// <p>The maximum size of a list to return.</p>
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
/// <p>The maximum size of a list to return.</p>
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
/// Adds a key-value pair to `tags`.
///
/// To override the contents of this collection use [`set_tags`](Self::set_tags).
///
/// <p>Specifies to return only these tagged resources.</p>
pub fn tags(
mut self,
k: impl Into<std::string::String>,
v: impl Into<std::string::String>,
) -> Self {
let mut hash_map = self.tags.unwrap_or_default();
hash_map.insert(k.into(), v.into());
self.tags = Some(hash_map);
self
}
/// <p>Specifies to return only these tagged resources.</p>
pub fn set_tags(
mut self,
input: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
) -> Self {
self.tags = input;
self
}
/// Consumes the builder and constructs a [`ListJobsInput`](crate::input::ListJobsInput).
pub fn build(
self,
) -> Result<crate::input::ListJobsInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::ListJobsInput {
next_token: self.next_token,
max_results: self.max_results,
tags: self.tags,
})
}
}
}
impl ListJobsInput {
/// Consumes the builder and constructs an Operation<[`ListJobs`](crate::operation::ListJobs)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::ListJobs,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::ListJobsInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::ListJobsInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.ListJobs",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_list_jobs(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op =
aws_smithy_http::operation::Operation::new(request, crate::operation::ListJobs::new())
.with_metadata(aws_smithy_http::operation::Metadata::new(
"ListJobs", "glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`ListJobsInput`](crate::input::ListJobsInput).
pub fn builder() -> crate::input::list_jobs_input::Builder {
crate::input::list_jobs_input::Builder::default()
}
}
/// See [`ListMlTransformsInput`](crate::input::ListMlTransformsInput).
pub mod list_ml_transforms_input {
/// A builder for [`ListMlTransformsInput`](crate::input::ListMlTransformsInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) next_token: std::option::Option<std::string::String>,
pub(crate) max_results: std::option::Option<i32>,
pub(crate) filter: std::option::Option<crate::model::TransformFilterCriteria>,
pub(crate) sort: std::option::Option<crate::model::TransformSortCriteria>,
pub(crate) tags: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
}
impl Builder {
/// <p>A continuation token, if this is a continuation request.</p>
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
/// <p>A continuation token, if this is a continuation request.</p>
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
/// <p>The maximum size of a list to return.</p>
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
/// <p>The maximum size of a list to return.</p>
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
/// <p>A <code>TransformFilterCriteria</code> used to filter the machine learning transforms.</p>
pub fn filter(mut self, input: crate::model::TransformFilterCriteria) -> Self {
self.filter = Some(input);
self
}
/// <p>A <code>TransformFilterCriteria</code> used to filter the machine learning transforms.</p>
pub fn set_filter(
mut self,
input: std::option::Option<crate::model::TransformFilterCriteria>,
) -> Self {
self.filter = input;
self
}
/// <p>A <code>TransformSortCriteria</code> used to sort the machine learning transforms.</p>
pub fn sort(mut self, input: crate::model::TransformSortCriteria) -> Self {
self.sort = Some(input);
self
}
/// <p>A <code>TransformSortCriteria</code> used to sort the machine learning transforms.</p>
pub fn set_sort(
mut self,
input: std::option::Option<crate::model::TransformSortCriteria>,
) -> Self {
self.sort = input;
self
}
/// Adds a key-value pair to `tags`.
///
/// To override the contents of this collection use [`set_tags`](Self::set_tags).
///
/// <p>Specifies to return only these tagged resources.</p>
pub fn tags(
mut self,
k: impl Into<std::string::String>,
v: impl Into<std::string::String>,
) -> Self {
let mut hash_map = self.tags.unwrap_or_default();
hash_map.insert(k.into(), v.into());
self.tags = Some(hash_map);
self
}
/// <p>Specifies to return only these tagged resources.</p>
pub fn set_tags(
mut self,
input: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
) -> Self {
self.tags = input;
self
}
/// Consumes the builder and constructs a [`ListMlTransformsInput`](crate::input::ListMlTransformsInput).
pub fn build(
self,
) -> Result<
crate::input::ListMlTransformsInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::ListMlTransformsInput {
next_token: self.next_token,
max_results: self.max_results,
filter: self.filter,
sort: self.sort,
tags: self.tags,
})
}
}
}
impl ListMlTransformsInput {
/// Consumes the builder and constructs an Operation<[`ListMLTransforms`](crate::operation::ListMLTransforms)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::ListMLTransforms,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::ListMlTransformsInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::ListMlTransformsInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.ListMLTransforms",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_list_ml_transforms(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::ListMLTransforms::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"ListMLTransforms",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`ListMlTransformsInput`](crate::input::ListMlTransformsInput).
pub fn builder() -> crate::input::list_ml_transforms_input::Builder {
crate::input::list_ml_transforms_input::Builder::default()
}
}
/// See [`ListRegistriesInput`](crate::input::ListRegistriesInput).
pub mod list_registries_input {
/// A builder for [`ListRegistriesInput`](crate::input::ListRegistriesInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) max_results: std::option::Option<i32>,
pub(crate) next_token: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>Maximum number of results required per page. If the value is not supplied, this will be defaulted to 25 per page.</p>
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
/// <p>Maximum number of results required per page. If the value is not supplied, this will be defaulted to 25 per page.</p>
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
/// <p>A continuation token, if this is a continuation call.</p>
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
/// <p>A continuation token, if this is a continuation call.</p>
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
/// Consumes the builder and constructs a [`ListRegistriesInput`](crate::input::ListRegistriesInput).
pub fn build(
self,
) -> Result<crate::input::ListRegistriesInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::ListRegistriesInput {
max_results: self.max_results,
next_token: self.next_token,
})
}
}
}
impl ListRegistriesInput {
/// Consumes the builder and constructs an Operation<[`ListRegistries`](crate::operation::ListRegistries)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::ListRegistries,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::ListRegistriesInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::ListRegistriesInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.ListRegistries",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_list_registries(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::ListRegistries::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"ListRegistries",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`ListRegistriesInput`](crate::input::ListRegistriesInput).
pub fn builder() -> crate::input::list_registries_input::Builder {
crate::input::list_registries_input::Builder::default()
}
}
/// See [`ListSchemasInput`](crate::input::ListSchemasInput).
pub mod list_schemas_input {
/// A builder for [`ListSchemasInput`](crate::input::ListSchemasInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) registry_id: std::option::Option<crate::model::RegistryId>,
pub(crate) max_results: std::option::Option<i32>,
pub(crate) next_token: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>A wrapper structure that may contain the registry name and Amazon Resource Name (ARN).</p>
pub fn registry_id(mut self, input: crate::model::RegistryId) -> Self {
self.registry_id = Some(input);
self
}
/// <p>A wrapper structure that may contain the registry name and Amazon Resource Name (ARN).</p>
pub fn set_registry_id(
mut self,
input: std::option::Option<crate::model::RegistryId>,
) -> Self {
self.registry_id = input;
self
}
/// <p>Maximum number of results required per page. If the value is not supplied, this will be defaulted to 25 per page.</p>
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
/// <p>Maximum number of results required per page. If the value is not supplied, this will be defaulted to 25 per page.</p>
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
/// <p>A continuation token, if this is a continuation call.</p>
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
/// <p>A continuation token, if this is a continuation call.</p>
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
/// Consumes the builder and constructs a [`ListSchemasInput`](crate::input::ListSchemasInput).
pub fn build(
self,
) -> Result<crate::input::ListSchemasInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::ListSchemasInput {
registry_id: self.registry_id,
max_results: self.max_results,
next_token: self.next_token,
})
}
}
}
impl ListSchemasInput {
/// Consumes the builder and constructs an Operation<[`ListSchemas`](crate::operation::ListSchemas)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::ListSchemas,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::ListSchemasInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::ListSchemasInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.ListSchemas",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_list_schemas(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::ListSchemas::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"ListSchemas",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`ListSchemasInput`](crate::input::ListSchemasInput).
pub fn builder() -> crate::input::list_schemas_input::Builder {
crate::input::list_schemas_input::Builder::default()
}
}
/// See [`ListSchemaVersionsInput`](crate::input::ListSchemaVersionsInput).
pub mod list_schema_versions_input {
/// A builder for [`ListSchemaVersionsInput`](crate::input::ListSchemaVersionsInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) schema_id: std::option::Option<crate::model::SchemaId>,
pub(crate) max_results: std::option::Option<i32>,
pub(crate) next_token: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>This is a wrapper structure to contain schema identity fields. The structure contains:</p>
/// <ul>
/// <li> <p>SchemaId$SchemaArn: The Amazon Resource Name (ARN) of the schema. Either <code>SchemaArn</code> or <code>SchemaName</code> and <code>RegistryName</code> has to be provided.</p> </li>
/// <li> <p>SchemaId$SchemaName: The name of the schema. Either <code>SchemaArn</code> or <code>SchemaName</code> and <code>RegistryName</code> has to be provided.</p> </li>
/// </ul>
pub fn schema_id(mut self, input: crate::model::SchemaId) -> Self {
self.schema_id = Some(input);
self
}
/// <p>This is a wrapper structure to contain schema identity fields. The structure contains:</p>
/// <ul>
/// <li> <p>SchemaId$SchemaArn: The Amazon Resource Name (ARN) of the schema. Either <code>SchemaArn</code> or <code>SchemaName</code> and <code>RegistryName</code> has to be provided.</p> </li>
/// <li> <p>SchemaId$SchemaName: The name of the schema. Either <code>SchemaArn</code> or <code>SchemaName</code> and <code>RegistryName</code> has to be provided.</p> </li>
/// </ul>
pub fn set_schema_id(mut self, input: std::option::Option<crate::model::SchemaId>) -> Self {
self.schema_id = input;
self
}
/// <p>Maximum number of results required per page. If the value is not supplied, this will be defaulted to 25 per page.</p>
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
/// <p>Maximum number of results required per page. If the value is not supplied, this will be defaulted to 25 per page.</p>
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
/// <p>A continuation token, if this is a continuation call.</p>
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
/// <p>A continuation token, if this is a continuation call.</p>
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
/// Consumes the builder and constructs a [`ListSchemaVersionsInput`](crate::input::ListSchemaVersionsInput).
pub fn build(
self,
) -> Result<
crate::input::ListSchemaVersionsInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::ListSchemaVersionsInput {
schema_id: self.schema_id,
max_results: self.max_results,
next_token: self.next_token,
})
}
}
}
impl ListSchemaVersionsInput {
/// Consumes the builder and constructs an Operation<[`ListSchemaVersions`](crate::operation::ListSchemaVersions)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::ListSchemaVersions,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::ListSchemaVersionsInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::ListSchemaVersionsInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.ListSchemaVersions",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_list_schema_versions(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::ListSchemaVersions::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"ListSchemaVersions",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`ListSchemaVersionsInput`](crate::input::ListSchemaVersionsInput).
pub fn builder() -> crate::input::list_schema_versions_input::Builder {
crate::input::list_schema_versions_input::Builder::default()
}
}
/// See [`ListSessionsInput`](crate::input::ListSessionsInput).
pub mod list_sessions_input {
/// A builder for [`ListSessionsInput`](crate::input::ListSessionsInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) next_token: std::option::Option<std::string::String>,
pub(crate) max_results: std::option::Option<i32>,
pub(crate) tags: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
pub(crate) request_origin: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The token for the next set of results, or null if there are no more result. </p>
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
/// <p>The token for the next set of results, or null if there are no more result. </p>
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
/// <p>The maximum number of results. </p>
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
/// <p>The maximum number of results. </p>
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
/// Adds a key-value pair to `tags`.
///
/// To override the contents of this collection use [`set_tags`](Self::set_tags).
///
/// <p>Tags belonging to the session. </p>
pub fn tags(
mut self,
k: impl Into<std::string::String>,
v: impl Into<std::string::String>,
) -> Self {
let mut hash_map = self.tags.unwrap_or_default();
hash_map.insert(k.into(), v.into());
self.tags = Some(hash_map);
self
}
/// <p>Tags belonging to the session. </p>
pub fn set_tags(
mut self,
input: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
) -> Self {
self.tags = input;
self
}
/// <p>The origin of the request. </p>
pub fn request_origin(mut self, input: impl Into<std::string::String>) -> Self {
self.request_origin = Some(input.into());
self
}
/// <p>The origin of the request. </p>
pub fn set_request_origin(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.request_origin = input;
self
}
/// Consumes the builder and constructs a [`ListSessionsInput`](crate::input::ListSessionsInput).
pub fn build(
self,
) -> Result<crate::input::ListSessionsInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::ListSessionsInput {
next_token: self.next_token,
max_results: self.max_results,
tags: self.tags,
request_origin: self.request_origin,
})
}
}
}
impl ListSessionsInput {
/// Consumes the builder and constructs an Operation<[`ListSessions`](crate::operation::ListSessions)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::ListSessions,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::ListSessionsInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::ListSessionsInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.ListSessions",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_list_sessions(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::ListSessions::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"ListSessions",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`ListSessionsInput`](crate::input::ListSessionsInput).
pub fn builder() -> crate::input::list_sessions_input::Builder {
crate::input::list_sessions_input::Builder::default()
}
}
/// See [`ListStatementsInput`](crate::input::ListStatementsInput).
pub mod list_statements_input {
/// A builder for [`ListStatementsInput`](crate::input::ListStatementsInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) session_id: std::option::Option<std::string::String>,
pub(crate) request_origin: std::option::Option<std::string::String>,
pub(crate) next_token: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The Session ID of the statements.</p>
pub fn session_id(mut self, input: impl Into<std::string::String>) -> Self {
self.session_id = Some(input.into());
self
}
/// <p>The Session ID of the statements.</p>
pub fn set_session_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.session_id = input;
self
}
/// <p>The origin of the request to list statements.</p>
pub fn request_origin(mut self, input: impl Into<std::string::String>) -> Self {
self.request_origin = Some(input.into());
self
}
/// <p>The origin of the request to list statements.</p>
pub fn set_request_origin(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.request_origin = input;
self
}
/// <p>A continuation token, if this is a continuation call.</p>
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
/// <p>A continuation token, if this is a continuation call.</p>
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
/// Consumes the builder and constructs a [`ListStatementsInput`](crate::input::ListStatementsInput).
pub fn build(
self,
) -> Result<crate::input::ListStatementsInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::ListStatementsInput {
session_id: self.session_id,
request_origin: self.request_origin,
next_token: self.next_token,
})
}
}
}
impl ListStatementsInput {
/// Consumes the builder and constructs an Operation<[`ListStatements`](crate::operation::ListStatements)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::ListStatements,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::ListStatementsInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::ListStatementsInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.ListStatements",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_list_statements(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::ListStatements::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"ListStatements",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`ListStatementsInput`](crate::input::ListStatementsInput).
pub fn builder() -> crate::input::list_statements_input::Builder {
crate::input::list_statements_input::Builder::default()
}
}
/// See [`ListTriggersInput`](crate::input::ListTriggersInput).
pub mod list_triggers_input {
/// A builder for [`ListTriggersInput`](crate::input::ListTriggersInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) next_token: std::option::Option<std::string::String>,
pub(crate) dependent_job_name: std::option::Option<std::string::String>,
pub(crate) max_results: std::option::Option<i32>,
pub(crate) tags: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
}
impl Builder {
/// <p>A continuation token, if this is a continuation request.</p>
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
/// <p>A continuation token, if this is a continuation request.</p>
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
/// <p> The name of the job for which to retrieve triggers. The trigger that can start this job is returned. If there is no such trigger, all triggers are returned.</p>
pub fn dependent_job_name(mut self, input: impl Into<std::string::String>) -> Self {
self.dependent_job_name = Some(input.into());
self
}
/// <p> The name of the job for which to retrieve triggers. The trigger that can start this job is returned. If there is no such trigger, all triggers are returned.</p>
pub fn set_dependent_job_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.dependent_job_name = input;
self
}
/// <p>The maximum size of a list to return.</p>
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
/// <p>The maximum size of a list to return.</p>
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
/// Adds a key-value pair to `tags`.
///
/// To override the contents of this collection use [`set_tags`](Self::set_tags).
///
/// <p>Specifies to return only these tagged resources.</p>
pub fn tags(
mut self,
k: impl Into<std::string::String>,
v: impl Into<std::string::String>,
) -> Self {
let mut hash_map = self.tags.unwrap_or_default();
hash_map.insert(k.into(), v.into());
self.tags = Some(hash_map);
self
}
/// <p>Specifies to return only these tagged resources.</p>
pub fn set_tags(
mut self,
input: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
) -> Self {
self.tags = input;
self
}
/// Consumes the builder and constructs a [`ListTriggersInput`](crate::input::ListTriggersInput).
pub fn build(
self,
) -> Result<crate::input::ListTriggersInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::ListTriggersInput {
next_token: self.next_token,
dependent_job_name: self.dependent_job_name,
max_results: self.max_results,
tags: self.tags,
})
}
}
}
impl ListTriggersInput {
/// Consumes the builder and constructs an Operation<[`ListTriggers`](crate::operation::ListTriggers)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::ListTriggers,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::ListTriggersInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::ListTriggersInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.ListTriggers",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_list_triggers(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::ListTriggers::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"ListTriggers",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`ListTriggersInput`](crate::input::ListTriggersInput).
pub fn builder() -> crate::input::list_triggers_input::Builder {
crate::input::list_triggers_input::Builder::default()
}
}
/// See [`ListWorkflowsInput`](crate::input::ListWorkflowsInput).
pub mod list_workflows_input {
/// A builder for [`ListWorkflowsInput`](crate::input::ListWorkflowsInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) next_token: std::option::Option<std::string::String>,
pub(crate) max_results: std::option::Option<i32>,
}
impl Builder {
/// <p>A continuation token, if this is a continuation request.</p>
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
/// <p>A continuation token, if this is a continuation request.</p>
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
/// <p>The maximum size of a list to return.</p>
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
/// <p>The maximum size of a list to return.</p>
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
/// Consumes the builder and constructs a [`ListWorkflowsInput`](crate::input::ListWorkflowsInput).
pub fn build(
self,
) -> Result<crate::input::ListWorkflowsInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::ListWorkflowsInput {
next_token: self.next_token,
max_results: self.max_results,
})
}
}
}
impl ListWorkflowsInput {
/// Consumes the builder and constructs an Operation<[`ListWorkflows`](crate::operation::ListWorkflows)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::ListWorkflows,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::ListWorkflowsInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::ListWorkflowsInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.ListWorkflows",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_list_workflows(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::ListWorkflows::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"ListWorkflows",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`ListWorkflowsInput`](crate::input::ListWorkflowsInput).
pub fn builder() -> crate::input::list_workflows_input::Builder {
crate::input::list_workflows_input::Builder::default()
}
}
/// See [`PutDataCatalogEncryptionSettingsInput`](crate::input::PutDataCatalogEncryptionSettingsInput).
pub mod put_data_catalog_encryption_settings_input {
/// A builder for [`PutDataCatalogEncryptionSettingsInput`](crate::input::PutDataCatalogEncryptionSettingsInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) catalog_id: std::option::Option<std::string::String>,
pub(crate) data_catalog_encryption_settings:
std::option::Option<crate::model::DataCatalogEncryptionSettings>,
}
impl Builder {
/// <p>The ID of the Data Catalog to set the security configuration for. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(mut self, input: impl Into<std::string::String>) -> Self {
self.catalog_id = Some(input.into());
self
}
/// <p>The ID of the Data Catalog to set the security configuration for. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn set_catalog_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.catalog_id = input;
self
}
/// <p>The security configuration to set.</p>
pub fn data_catalog_encryption_settings(
mut self,
input: crate::model::DataCatalogEncryptionSettings,
) -> Self {
self.data_catalog_encryption_settings = Some(input);
self
}
/// <p>The security configuration to set.</p>
pub fn set_data_catalog_encryption_settings(
mut self,
input: std::option::Option<crate::model::DataCatalogEncryptionSettings>,
) -> Self {
self.data_catalog_encryption_settings = input;
self
}
/// Consumes the builder and constructs a [`PutDataCatalogEncryptionSettingsInput`](crate::input::PutDataCatalogEncryptionSettingsInput).
pub fn build(
self,
) -> Result<
crate::input::PutDataCatalogEncryptionSettingsInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::PutDataCatalogEncryptionSettingsInput {
catalog_id: self.catalog_id,
data_catalog_encryption_settings: self.data_catalog_encryption_settings,
})
}
}
}
impl PutDataCatalogEncryptionSettingsInput {
/// Consumes the builder and constructs an Operation<[`PutDataCatalogEncryptionSettings`](crate::operation::PutDataCatalogEncryptionSettings)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::PutDataCatalogEncryptionSettings,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::PutDataCatalogEncryptionSettingsInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::PutDataCatalogEncryptionSettingsInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.PutDataCatalogEncryptionSettings",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_put_data_catalog_encryption_settings(&self)?
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::PutDataCatalogEncryptionSettings::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"PutDataCatalogEncryptionSettings",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`PutDataCatalogEncryptionSettingsInput`](crate::input::PutDataCatalogEncryptionSettingsInput).
pub fn builder() -> crate::input::put_data_catalog_encryption_settings_input::Builder {
crate::input::put_data_catalog_encryption_settings_input::Builder::default()
}
}
/// See [`PutResourcePolicyInput`](crate::input::PutResourcePolicyInput).
pub mod put_resource_policy_input {
/// A builder for [`PutResourcePolicyInput`](crate::input::PutResourcePolicyInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) policy_in_json: std::option::Option<std::string::String>,
pub(crate) resource_arn: std::option::Option<std::string::String>,
pub(crate) policy_hash_condition: std::option::Option<std::string::String>,
pub(crate) policy_exists_condition: std::option::Option<crate::model::ExistCondition>,
pub(crate) enable_hybrid: std::option::Option<crate::model::EnableHybridValues>,
}
impl Builder {
/// <p>Contains the policy document to set, in JSON format.</p>
pub fn policy_in_json(mut self, input: impl Into<std::string::String>) -> Self {
self.policy_in_json = Some(input.into());
self
}
/// <p>Contains the policy document to set, in JSON format.</p>
pub fn set_policy_in_json(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.policy_in_json = input;
self
}
/// <p>Do not use. For internal use only.</p>
pub fn resource_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.resource_arn = Some(input.into());
self
}
/// <p>Do not use. For internal use only.</p>
pub fn set_resource_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.resource_arn = input;
self
}
/// <p>The hash value returned when the previous policy was set using <code>PutResourcePolicy</code>. Its purpose is to prevent concurrent modifications of a policy. Do not use this parameter if no previous policy has been set.</p>
pub fn policy_hash_condition(mut self, input: impl Into<std::string::String>) -> Self {
self.policy_hash_condition = Some(input.into());
self
}
/// <p>The hash value returned when the previous policy was set using <code>PutResourcePolicy</code>. Its purpose is to prevent concurrent modifications of a policy. Do not use this parameter if no previous policy has been set.</p>
pub fn set_policy_hash_condition(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.policy_hash_condition = input;
self
}
/// <p>A value of <code>MUST_EXIST</code> is used to update a policy. A value of <code>NOT_EXIST</code> is used to create a new policy. If a value of <code>NONE</code> or a null value is used, the call does not depend on the existence of a policy.</p>
pub fn policy_exists_condition(mut self, input: crate::model::ExistCondition) -> Self {
self.policy_exists_condition = Some(input);
self
}
/// <p>A value of <code>MUST_EXIST</code> is used to update a policy. A value of <code>NOT_EXIST</code> is used to create a new policy. If a value of <code>NONE</code> or a null value is used, the call does not depend on the existence of a policy.</p>
pub fn set_policy_exists_condition(
mut self,
input: std::option::Option<crate::model::ExistCondition>,
) -> Self {
self.policy_exists_condition = input;
self
}
/// <p>If <code>'TRUE'</code>, indicates that you are using both methods to grant cross-account access to Data Catalog resources:</p>
/// <ul>
/// <li> <p>By directly updating the resource policy with <code>PutResourePolicy</code> </p> </li>
/// <li> <p>By using the <b>Grant permissions</b> command on the Amazon Web Services Management Console.</p> </li>
/// </ul>
/// <p>Must be set to <code>'TRUE'</code> if you have already used the Management Console to grant cross-account access, otherwise the call fails. Default is 'FALSE'.</p>
pub fn enable_hybrid(mut self, input: crate::model::EnableHybridValues) -> Self {
self.enable_hybrid = Some(input);
self
}
/// <p>If <code>'TRUE'</code>, indicates that you are using both methods to grant cross-account access to Data Catalog resources:</p>
/// <ul>
/// <li> <p>By directly updating the resource policy with <code>PutResourePolicy</code> </p> </li>
/// <li> <p>By using the <b>Grant permissions</b> command on the Amazon Web Services Management Console.</p> </li>
/// </ul>
/// <p>Must be set to <code>'TRUE'</code> if you have already used the Management Console to grant cross-account access, otherwise the call fails. Default is 'FALSE'.</p>
pub fn set_enable_hybrid(
mut self,
input: std::option::Option<crate::model::EnableHybridValues>,
) -> Self {
self.enable_hybrid = input;
self
}
/// Consumes the builder and constructs a [`PutResourcePolicyInput`](crate::input::PutResourcePolicyInput).
pub fn build(
self,
) -> Result<
crate::input::PutResourcePolicyInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::PutResourcePolicyInput {
policy_in_json: self.policy_in_json,
resource_arn: self.resource_arn,
policy_hash_condition: self.policy_hash_condition,
policy_exists_condition: self.policy_exists_condition,
enable_hybrid: self.enable_hybrid,
})
}
}
}
impl PutResourcePolicyInput {
/// Consumes the builder and constructs an Operation<[`PutResourcePolicy`](crate::operation::PutResourcePolicy)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::PutResourcePolicy,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::PutResourcePolicyInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::PutResourcePolicyInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.PutResourcePolicy",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_put_resource_policy(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::PutResourcePolicy::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"PutResourcePolicy",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`PutResourcePolicyInput`](crate::input::PutResourcePolicyInput).
pub fn builder() -> crate::input::put_resource_policy_input::Builder {
crate::input::put_resource_policy_input::Builder::default()
}
}
/// See [`PutSchemaVersionMetadataInput`](crate::input::PutSchemaVersionMetadataInput).
pub mod put_schema_version_metadata_input {
/// A builder for [`PutSchemaVersionMetadataInput`](crate::input::PutSchemaVersionMetadataInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) schema_id: std::option::Option<crate::model::SchemaId>,
pub(crate) schema_version_number: std::option::Option<crate::model::SchemaVersionNumber>,
pub(crate) schema_version_id: std::option::Option<std::string::String>,
pub(crate) metadata_key_value: std::option::Option<crate::model::MetadataKeyValuePair>,
}
impl Builder {
/// <p>The unique ID for the schema.</p>
pub fn schema_id(mut self, input: crate::model::SchemaId) -> Self {
self.schema_id = Some(input);
self
}
/// <p>The unique ID for the schema.</p>
pub fn set_schema_id(mut self, input: std::option::Option<crate::model::SchemaId>) -> Self {
self.schema_id = input;
self
}
/// <p>The version number of the schema.</p>
pub fn schema_version_number(mut self, input: crate::model::SchemaVersionNumber) -> Self {
self.schema_version_number = Some(input);
self
}
/// <p>The version number of the schema.</p>
pub fn set_schema_version_number(
mut self,
input: std::option::Option<crate::model::SchemaVersionNumber>,
) -> Self {
self.schema_version_number = input;
self
}
/// <p>The unique version ID of the schema version.</p>
pub fn schema_version_id(mut self, input: impl Into<std::string::String>) -> Self {
self.schema_version_id = Some(input.into());
self
}
/// <p>The unique version ID of the schema version.</p>
pub fn set_schema_version_id(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.schema_version_id = input;
self
}
/// <p>The metadata key's corresponding value.</p>
pub fn metadata_key_value(mut self, input: crate::model::MetadataKeyValuePair) -> Self {
self.metadata_key_value = Some(input);
self
}
/// <p>The metadata key's corresponding value.</p>
pub fn set_metadata_key_value(
mut self,
input: std::option::Option<crate::model::MetadataKeyValuePair>,
) -> Self {
self.metadata_key_value = input;
self
}
/// Consumes the builder and constructs a [`PutSchemaVersionMetadataInput`](crate::input::PutSchemaVersionMetadataInput).
pub fn build(
self,
) -> Result<
crate::input::PutSchemaVersionMetadataInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::PutSchemaVersionMetadataInput {
schema_id: self.schema_id,
schema_version_number: self.schema_version_number,
schema_version_id: self.schema_version_id,
metadata_key_value: self.metadata_key_value,
})
}
}
}
impl PutSchemaVersionMetadataInput {
/// Consumes the builder and constructs an Operation<[`PutSchemaVersionMetadata`](crate::operation::PutSchemaVersionMetadata)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::PutSchemaVersionMetadata,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::PutSchemaVersionMetadataInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::PutSchemaVersionMetadataInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.PutSchemaVersionMetadata",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_put_schema_version_metadata(
&self,
)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::PutSchemaVersionMetadata::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"PutSchemaVersionMetadata",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`PutSchemaVersionMetadataInput`](crate::input::PutSchemaVersionMetadataInput).
pub fn builder() -> crate::input::put_schema_version_metadata_input::Builder {
crate::input::put_schema_version_metadata_input::Builder::default()
}
}
/// See [`PutWorkflowRunPropertiesInput`](crate::input::PutWorkflowRunPropertiesInput).
pub mod put_workflow_run_properties_input {
/// A builder for [`PutWorkflowRunPropertiesInput`](crate::input::PutWorkflowRunPropertiesInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) name: std::option::Option<std::string::String>,
pub(crate) run_id: std::option::Option<std::string::String>,
pub(crate) run_properties: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
}
impl Builder {
/// <p>Name of the workflow which was run.</p>
pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
self.name = Some(input.into());
self
}
/// <p>Name of the workflow which was run.</p>
pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.name = input;
self
}
/// <p>The ID of the workflow run for which the run properties should be updated.</p>
pub fn run_id(mut self, input: impl Into<std::string::String>) -> Self {
self.run_id = Some(input.into());
self
}
/// <p>The ID of the workflow run for which the run properties should be updated.</p>
pub fn set_run_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.run_id = input;
self
}
/// Adds a key-value pair to `run_properties`.
///
/// To override the contents of this collection use [`set_run_properties`](Self::set_run_properties).
///
/// <p>The properties to put for the specified run.</p>
pub fn run_properties(
mut self,
k: impl Into<std::string::String>,
v: impl Into<std::string::String>,
) -> Self {
let mut hash_map = self.run_properties.unwrap_or_default();
hash_map.insert(k.into(), v.into());
self.run_properties = Some(hash_map);
self
}
/// <p>The properties to put for the specified run.</p>
pub fn set_run_properties(
mut self,
input: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
) -> Self {
self.run_properties = input;
self
}
/// Consumes the builder and constructs a [`PutWorkflowRunPropertiesInput`](crate::input::PutWorkflowRunPropertiesInput).
pub fn build(
self,
) -> Result<
crate::input::PutWorkflowRunPropertiesInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::PutWorkflowRunPropertiesInput {
name: self.name,
run_id: self.run_id,
run_properties: self.run_properties,
})
}
}
}
impl PutWorkflowRunPropertiesInput {
/// Consumes the builder and constructs an Operation<[`PutWorkflowRunProperties`](crate::operation::PutWorkflowRunProperties)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::PutWorkflowRunProperties,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::PutWorkflowRunPropertiesInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::PutWorkflowRunPropertiesInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.PutWorkflowRunProperties",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_put_workflow_run_properties(
&self,
)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::PutWorkflowRunProperties::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"PutWorkflowRunProperties",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`PutWorkflowRunPropertiesInput`](crate::input::PutWorkflowRunPropertiesInput).
pub fn builder() -> crate::input::put_workflow_run_properties_input::Builder {
crate::input::put_workflow_run_properties_input::Builder::default()
}
}
/// See [`QuerySchemaVersionMetadataInput`](crate::input::QuerySchemaVersionMetadataInput).
pub mod query_schema_version_metadata_input {
/// A builder for [`QuerySchemaVersionMetadataInput`](crate::input::QuerySchemaVersionMetadataInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) schema_id: std::option::Option<crate::model::SchemaId>,
pub(crate) schema_version_number: std::option::Option<crate::model::SchemaVersionNumber>,
pub(crate) schema_version_id: std::option::Option<std::string::String>,
pub(crate) metadata_list:
std::option::Option<std::vec::Vec<crate::model::MetadataKeyValuePair>>,
pub(crate) max_results: std::option::Option<i32>,
pub(crate) next_token: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>A wrapper structure that may contain the schema name and Amazon Resource Name (ARN).</p>
pub fn schema_id(mut self, input: crate::model::SchemaId) -> Self {
self.schema_id = Some(input);
self
}
/// <p>A wrapper structure that may contain the schema name and Amazon Resource Name (ARN).</p>
pub fn set_schema_id(mut self, input: std::option::Option<crate::model::SchemaId>) -> Self {
self.schema_id = input;
self
}
/// <p>The version number of the schema.</p>
pub fn schema_version_number(mut self, input: crate::model::SchemaVersionNumber) -> Self {
self.schema_version_number = Some(input);
self
}
/// <p>The version number of the schema.</p>
pub fn set_schema_version_number(
mut self,
input: std::option::Option<crate::model::SchemaVersionNumber>,
) -> Self {
self.schema_version_number = input;
self
}
/// <p>The unique version ID of the schema version.</p>
pub fn schema_version_id(mut self, input: impl Into<std::string::String>) -> Self {
self.schema_version_id = Some(input.into());
self
}
/// <p>The unique version ID of the schema version.</p>
pub fn set_schema_version_id(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.schema_version_id = input;
self
}
/// Appends an item to `metadata_list`.
///
/// To override the contents of this collection use [`set_metadata_list`](Self::set_metadata_list).
///
/// <p>Search key-value pairs for metadata, if they are not provided all the metadata information will be fetched.</p>
pub fn metadata_list(mut self, input: crate::model::MetadataKeyValuePair) -> Self {
let mut v = self.metadata_list.unwrap_or_default();
v.push(input);
self.metadata_list = Some(v);
self
}
/// <p>Search key-value pairs for metadata, if they are not provided all the metadata information will be fetched.</p>
pub fn set_metadata_list(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::MetadataKeyValuePair>>,
) -> Self {
self.metadata_list = input;
self
}
/// <p>Maximum number of results required per page. If the value is not supplied, this will be defaulted to 25 per page.</p>
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
/// <p>Maximum number of results required per page. If the value is not supplied, this will be defaulted to 25 per page.</p>
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
/// <p>A continuation token, if this is a continuation call.</p>
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
/// <p>A continuation token, if this is a continuation call.</p>
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
/// Consumes the builder and constructs a [`QuerySchemaVersionMetadataInput`](crate::input::QuerySchemaVersionMetadataInput).
pub fn build(
self,
) -> Result<
crate::input::QuerySchemaVersionMetadataInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::QuerySchemaVersionMetadataInput {
schema_id: self.schema_id,
schema_version_number: self.schema_version_number,
schema_version_id: self.schema_version_id,
metadata_list: self.metadata_list,
max_results: self.max_results.unwrap_or_default(),
next_token: self.next_token,
})
}
}
}
impl QuerySchemaVersionMetadataInput {
/// Consumes the builder and constructs an Operation<[`QuerySchemaVersionMetadata`](crate::operation::QuerySchemaVersionMetadata)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::QuerySchemaVersionMetadata,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::QuerySchemaVersionMetadataInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::QuerySchemaVersionMetadataInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.QuerySchemaVersionMetadata",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_query_schema_version_metadata(&self)?
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::QuerySchemaVersionMetadata::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"QuerySchemaVersionMetadata",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`QuerySchemaVersionMetadataInput`](crate::input::QuerySchemaVersionMetadataInput).
pub fn builder() -> crate::input::query_schema_version_metadata_input::Builder {
crate::input::query_schema_version_metadata_input::Builder::default()
}
}
/// See [`RegisterSchemaVersionInput`](crate::input::RegisterSchemaVersionInput).
pub mod register_schema_version_input {
/// A builder for [`RegisterSchemaVersionInput`](crate::input::RegisterSchemaVersionInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) schema_id: std::option::Option<crate::model::SchemaId>,
pub(crate) schema_definition: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>This is a wrapper structure to contain schema identity fields. The structure contains:</p>
/// <ul>
/// <li> <p>SchemaId$SchemaArn: The Amazon Resource Name (ARN) of the schema. Either <code>SchemaArn</code> or <code>SchemaName</code> and <code>RegistryName</code> has to be provided.</p> </li>
/// <li> <p>SchemaId$SchemaName: The name of the schema. Either <code>SchemaArn</code> or <code>SchemaName</code> and <code>RegistryName</code> has to be provided.</p> </li>
/// </ul>
pub fn schema_id(mut self, input: crate::model::SchemaId) -> Self {
self.schema_id = Some(input);
self
}
/// <p>This is a wrapper structure to contain schema identity fields. The structure contains:</p>
/// <ul>
/// <li> <p>SchemaId$SchemaArn: The Amazon Resource Name (ARN) of the schema. Either <code>SchemaArn</code> or <code>SchemaName</code> and <code>RegistryName</code> has to be provided.</p> </li>
/// <li> <p>SchemaId$SchemaName: The name of the schema. Either <code>SchemaArn</code> or <code>SchemaName</code> and <code>RegistryName</code> has to be provided.</p> </li>
/// </ul>
pub fn set_schema_id(mut self, input: std::option::Option<crate::model::SchemaId>) -> Self {
self.schema_id = input;
self
}
/// <p>The schema definition using the <code>DataFormat</code> setting for the <code>SchemaName</code>.</p>
pub fn schema_definition(mut self, input: impl Into<std::string::String>) -> Self {
self.schema_definition = Some(input.into());
self
}
/// <p>The schema definition using the <code>DataFormat</code> setting for the <code>SchemaName</code>.</p>
pub fn set_schema_definition(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.schema_definition = input;
self
}
/// Consumes the builder and constructs a [`RegisterSchemaVersionInput`](crate::input::RegisterSchemaVersionInput).
pub fn build(
self,
) -> Result<
crate::input::RegisterSchemaVersionInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::RegisterSchemaVersionInput {
schema_id: self.schema_id,
schema_definition: self.schema_definition,
})
}
}
}
impl RegisterSchemaVersionInput {
/// Consumes the builder and constructs an Operation<[`RegisterSchemaVersion`](crate::operation::RegisterSchemaVersion)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::RegisterSchemaVersion,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::RegisterSchemaVersionInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::RegisterSchemaVersionInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.RegisterSchemaVersion",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_register_schema_version(
&self,
)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::RegisterSchemaVersion::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"RegisterSchemaVersion",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`RegisterSchemaVersionInput`](crate::input::RegisterSchemaVersionInput).
pub fn builder() -> crate::input::register_schema_version_input::Builder {
crate::input::register_schema_version_input::Builder::default()
}
}
/// See [`RemoveSchemaVersionMetadataInput`](crate::input::RemoveSchemaVersionMetadataInput).
pub mod remove_schema_version_metadata_input {
/// A builder for [`RemoveSchemaVersionMetadataInput`](crate::input::RemoveSchemaVersionMetadataInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) schema_id: std::option::Option<crate::model::SchemaId>,
pub(crate) schema_version_number: std::option::Option<crate::model::SchemaVersionNumber>,
pub(crate) schema_version_id: std::option::Option<std::string::String>,
pub(crate) metadata_key_value: std::option::Option<crate::model::MetadataKeyValuePair>,
}
impl Builder {
/// <p>A wrapper structure that may contain the schema name and Amazon Resource Name (ARN).</p>
pub fn schema_id(mut self, input: crate::model::SchemaId) -> Self {
self.schema_id = Some(input);
self
}
/// <p>A wrapper structure that may contain the schema name and Amazon Resource Name (ARN).</p>
pub fn set_schema_id(mut self, input: std::option::Option<crate::model::SchemaId>) -> Self {
self.schema_id = input;
self
}
/// <p>The version number of the schema.</p>
pub fn schema_version_number(mut self, input: crate::model::SchemaVersionNumber) -> Self {
self.schema_version_number = Some(input);
self
}
/// <p>The version number of the schema.</p>
pub fn set_schema_version_number(
mut self,
input: std::option::Option<crate::model::SchemaVersionNumber>,
) -> Self {
self.schema_version_number = input;
self
}
/// <p>The unique version ID of the schema version.</p>
pub fn schema_version_id(mut self, input: impl Into<std::string::String>) -> Self {
self.schema_version_id = Some(input.into());
self
}
/// <p>The unique version ID of the schema version.</p>
pub fn set_schema_version_id(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.schema_version_id = input;
self
}
/// <p>The value of the metadata key.</p>
pub fn metadata_key_value(mut self, input: crate::model::MetadataKeyValuePair) -> Self {
self.metadata_key_value = Some(input);
self
}
/// <p>The value of the metadata key.</p>
pub fn set_metadata_key_value(
mut self,
input: std::option::Option<crate::model::MetadataKeyValuePair>,
) -> Self {
self.metadata_key_value = input;
self
}
/// Consumes the builder and constructs a [`RemoveSchemaVersionMetadataInput`](crate::input::RemoveSchemaVersionMetadataInput).
pub fn build(
self,
) -> Result<
crate::input::RemoveSchemaVersionMetadataInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::RemoveSchemaVersionMetadataInput {
schema_id: self.schema_id,
schema_version_number: self.schema_version_number,
schema_version_id: self.schema_version_id,
metadata_key_value: self.metadata_key_value,
})
}
}
}
impl RemoveSchemaVersionMetadataInput {
/// Consumes the builder and constructs an Operation<[`RemoveSchemaVersionMetadata`](crate::operation::RemoveSchemaVersionMetadata)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::RemoveSchemaVersionMetadata,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::RemoveSchemaVersionMetadataInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::RemoveSchemaVersionMetadataInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.RemoveSchemaVersionMetadata",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_remove_schema_version_metadata(&self)?
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::RemoveSchemaVersionMetadata::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"RemoveSchemaVersionMetadata",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`RemoveSchemaVersionMetadataInput`](crate::input::RemoveSchemaVersionMetadataInput).
pub fn builder() -> crate::input::remove_schema_version_metadata_input::Builder {
crate::input::remove_schema_version_metadata_input::Builder::default()
}
}
/// See [`ResetJobBookmarkInput`](crate::input::ResetJobBookmarkInput).
pub mod reset_job_bookmark_input {
/// A builder for [`ResetJobBookmarkInput`](crate::input::ResetJobBookmarkInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) job_name: std::option::Option<std::string::String>,
pub(crate) run_id: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The name of the job in question.</p>
pub fn job_name(mut self, input: impl Into<std::string::String>) -> Self {
self.job_name = Some(input.into());
self
}
/// <p>The name of the job in question.</p>
pub fn set_job_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.job_name = input;
self
}
/// <p>The unique run identifier associated with this job run.</p>
pub fn run_id(mut self, input: impl Into<std::string::String>) -> Self {
self.run_id = Some(input.into());
self
}
/// <p>The unique run identifier associated with this job run.</p>
pub fn set_run_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.run_id = input;
self
}
/// Consumes the builder and constructs a [`ResetJobBookmarkInput`](crate::input::ResetJobBookmarkInput).
pub fn build(
self,
) -> Result<
crate::input::ResetJobBookmarkInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::ResetJobBookmarkInput {
job_name: self.job_name,
run_id: self.run_id,
})
}
}
}
impl ResetJobBookmarkInput {
/// Consumes the builder and constructs an Operation<[`ResetJobBookmark`](crate::operation::ResetJobBookmark)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::ResetJobBookmark,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::ResetJobBookmarkInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::ResetJobBookmarkInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.ResetJobBookmark",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_reset_job_bookmark(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::ResetJobBookmark::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"ResetJobBookmark",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`ResetJobBookmarkInput`](crate::input::ResetJobBookmarkInput).
pub fn builder() -> crate::input::reset_job_bookmark_input::Builder {
crate::input::reset_job_bookmark_input::Builder::default()
}
}
/// See [`ResumeWorkflowRunInput`](crate::input::ResumeWorkflowRunInput).
pub mod resume_workflow_run_input {
/// A builder for [`ResumeWorkflowRunInput`](crate::input::ResumeWorkflowRunInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) name: std::option::Option<std::string::String>,
pub(crate) run_id: std::option::Option<std::string::String>,
pub(crate) node_ids: std::option::Option<std::vec::Vec<std::string::String>>,
}
impl Builder {
/// <p>The name of the workflow to resume.</p>
pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
self.name = Some(input.into());
self
}
/// <p>The name of the workflow to resume.</p>
pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.name = input;
self
}
/// <p>The ID of the workflow run to resume.</p>
pub fn run_id(mut self, input: impl Into<std::string::String>) -> Self {
self.run_id = Some(input.into());
self
}
/// <p>The ID of the workflow run to resume.</p>
pub fn set_run_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.run_id = input;
self
}
/// Appends an item to `node_ids`.
///
/// To override the contents of this collection use [`set_node_ids`](Self::set_node_ids).
///
/// <p>A list of the node IDs for the nodes you want to restart. The nodes that are to be restarted must have a run attempt in the original run.</p>
pub fn node_ids(mut self, input: impl Into<std::string::String>) -> Self {
let mut v = self.node_ids.unwrap_or_default();
v.push(input.into());
self.node_ids = Some(v);
self
}
/// <p>A list of the node IDs for the nodes you want to restart. The nodes that are to be restarted must have a run attempt in the original run.</p>
pub fn set_node_ids(
mut self,
input: std::option::Option<std::vec::Vec<std::string::String>>,
) -> Self {
self.node_ids = input;
self
}
/// Consumes the builder and constructs a [`ResumeWorkflowRunInput`](crate::input::ResumeWorkflowRunInput).
pub fn build(
self,
) -> Result<
crate::input::ResumeWorkflowRunInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::ResumeWorkflowRunInput {
name: self.name,
run_id: self.run_id,
node_ids: self.node_ids,
})
}
}
}
impl ResumeWorkflowRunInput {
/// Consumes the builder and constructs an Operation<[`ResumeWorkflowRun`](crate::operation::ResumeWorkflowRun)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::ResumeWorkflowRun,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::ResumeWorkflowRunInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::ResumeWorkflowRunInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.ResumeWorkflowRun",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_resume_workflow_run(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::ResumeWorkflowRun::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"ResumeWorkflowRun",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`ResumeWorkflowRunInput`](crate::input::ResumeWorkflowRunInput).
pub fn builder() -> crate::input::resume_workflow_run_input::Builder {
crate::input::resume_workflow_run_input::Builder::default()
}
}
/// See [`RunStatementInput`](crate::input::RunStatementInput).
pub mod run_statement_input {
/// A builder for [`RunStatementInput`](crate::input::RunStatementInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) session_id: std::option::Option<std::string::String>,
pub(crate) code: std::option::Option<std::string::String>,
pub(crate) request_origin: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The Session Id of the statement to be run.</p>
pub fn session_id(mut self, input: impl Into<std::string::String>) -> Self {
self.session_id = Some(input.into());
self
}
/// <p>The Session Id of the statement to be run.</p>
pub fn set_session_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.session_id = input;
self
}
/// <p>The statement code to be run.</p>
pub fn code(mut self, input: impl Into<std::string::String>) -> Self {
self.code = Some(input.into());
self
}
/// <p>The statement code to be run.</p>
pub fn set_code(mut self, input: std::option::Option<std::string::String>) -> Self {
self.code = input;
self
}
/// <p>The origin of the request.</p>
pub fn request_origin(mut self, input: impl Into<std::string::String>) -> Self {
self.request_origin = Some(input.into());
self
}
/// <p>The origin of the request.</p>
pub fn set_request_origin(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.request_origin = input;
self
}
/// Consumes the builder and constructs a [`RunStatementInput`](crate::input::RunStatementInput).
pub fn build(
self,
) -> Result<crate::input::RunStatementInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::RunStatementInput {
session_id: self.session_id,
code: self.code,
request_origin: self.request_origin,
})
}
}
}
impl RunStatementInput {
/// Consumes the builder and constructs an Operation<[`RunStatement`](crate::operation::RunStatement)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::RunStatement,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::RunStatementInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::RunStatementInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.RunStatement",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_run_statement(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::RunStatement::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"RunStatement",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`RunStatementInput`](crate::input::RunStatementInput).
pub fn builder() -> crate::input::run_statement_input::Builder {
crate::input::run_statement_input::Builder::default()
}
}
/// See [`SearchTablesInput`](crate::input::SearchTablesInput).
pub mod search_tables_input {
/// A builder for [`SearchTablesInput`](crate::input::SearchTablesInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) catalog_id: std::option::Option<std::string::String>,
pub(crate) next_token: std::option::Option<std::string::String>,
pub(crate) filters: std::option::Option<std::vec::Vec<crate::model::PropertyPredicate>>,
pub(crate) search_text: std::option::Option<std::string::String>,
pub(crate) sort_criteria: std::option::Option<std::vec::Vec<crate::model::SortCriterion>>,
pub(crate) max_results: std::option::Option<i32>,
pub(crate) resource_share_type: std::option::Option<crate::model::ResourceShareType>,
}
impl Builder {
/// <p>A unique identifier, consisting of <code> <i>account_id</i> </code>.</p>
pub fn catalog_id(mut self, input: impl Into<std::string::String>) -> Self {
self.catalog_id = Some(input.into());
self
}
/// <p>A unique identifier, consisting of <code> <i>account_id</i> </code>.</p>
pub fn set_catalog_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.catalog_id = input;
self
}
/// <p>A continuation token, included if this is a continuation call.</p>
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
/// <p>A continuation token, included if this is a continuation call.</p>
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
/// Appends an item to `filters`.
///
/// To override the contents of this collection use [`set_filters`](Self::set_filters).
///
/// <p>A list of key-value pairs, and a comparator used to filter the search results. Returns all entities matching the predicate.</p>
/// <p>The <code>Comparator</code> member of the <code>PropertyPredicate</code> struct is used only for time fields, and can be omitted for other field types. Also, when comparing string values, such as when <code>Key=Name</code>, a fuzzy match algorithm is used. The <code>Key</code> field (for example, the value of the <code>Name</code> field) is split on certain punctuation characters, for example, -, :, #, etc. into tokens. Then each token is exact-match compared with the <code>Value</code> member of <code>PropertyPredicate</code>. For example, if <code>Key=Name</code> and <code>Value=link</code>, tables named <code>customer-link</code> and <code>xx-link-yy</code> are returned, but <code>xxlinkyy</code> is not returned.</p>
pub fn filters(mut self, input: crate::model::PropertyPredicate) -> Self {
let mut v = self.filters.unwrap_or_default();
v.push(input);
self.filters = Some(v);
self
}
/// <p>A list of key-value pairs, and a comparator used to filter the search results. Returns all entities matching the predicate.</p>
/// <p>The <code>Comparator</code> member of the <code>PropertyPredicate</code> struct is used only for time fields, and can be omitted for other field types. Also, when comparing string values, such as when <code>Key=Name</code>, a fuzzy match algorithm is used. The <code>Key</code> field (for example, the value of the <code>Name</code> field) is split on certain punctuation characters, for example, -, :, #, etc. into tokens. Then each token is exact-match compared with the <code>Value</code> member of <code>PropertyPredicate</code>. For example, if <code>Key=Name</code> and <code>Value=link</code>, tables named <code>customer-link</code> and <code>xx-link-yy</code> are returned, but <code>xxlinkyy</code> is not returned.</p>
pub fn set_filters(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::PropertyPredicate>>,
) -> Self {
self.filters = input;
self
}
/// <p>A string used for a text search.</p>
/// <p>Specifying a value in quotes filters based on an exact match to the value.</p>
pub fn search_text(mut self, input: impl Into<std::string::String>) -> Self {
self.search_text = Some(input.into());
self
}
/// <p>A string used for a text search.</p>
/// <p>Specifying a value in quotes filters based on an exact match to the value.</p>
pub fn set_search_text(mut self, input: std::option::Option<std::string::String>) -> Self {
self.search_text = input;
self
}
/// Appends an item to `sort_criteria`.
///
/// To override the contents of this collection use [`set_sort_criteria`](Self::set_sort_criteria).
///
/// <p>A list of criteria for sorting the results by a field name, in an ascending or descending order.</p>
pub fn sort_criteria(mut self, input: crate::model::SortCriterion) -> Self {
let mut v = self.sort_criteria.unwrap_or_default();
v.push(input);
self.sort_criteria = Some(v);
self
}
/// <p>A list of criteria for sorting the results by a field name, in an ascending or descending order.</p>
pub fn set_sort_criteria(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::SortCriterion>>,
) -> Self {
self.sort_criteria = input;
self
}
/// <p>The maximum number of tables to return in a single response.</p>
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
/// <p>The maximum number of tables to return in a single response.</p>
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
/// <p>Allows you to specify that you want to search the tables shared with your account. The allowable values are <code>FOREIGN</code> or <code>ALL</code>. </p>
/// <ul>
/// <li> <p>If set to <code>FOREIGN</code>, will search the tables shared with your account. </p> </li>
/// <li> <p>If set to <code>ALL</code>, will search the tables shared with your account, as well as the tables in yor local account. </p> </li>
/// </ul>
pub fn resource_share_type(mut self, input: crate::model::ResourceShareType) -> Self {
self.resource_share_type = Some(input);
self
}
/// <p>Allows you to specify that you want to search the tables shared with your account. The allowable values are <code>FOREIGN</code> or <code>ALL</code>. </p>
/// <ul>
/// <li> <p>If set to <code>FOREIGN</code>, will search the tables shared with your account. </p> </li>
/// <li> <p>If set to <code>ALL</code>, will search the tables shared with your account, as well as the tables in yor local account. </p> </li>
/// </ul>
pub fn set_resource_share_type(
mut self,
input: std::option::Option<crate::model::ResourceShareType>,
) -> Self {
self.resource_share_type = input;
self
}
/// Consumes the builder and constructs a [`SearchTablesInput`](crate::input::SearchTablesInput).
pub fn build(
self,
) -> Result<crate::input::SearchTablesInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::SearchTablesInput {
catalog_id: self.catalog_id,
next_token: self.next_token,
filters: self.filters,
search_text: self.search_text,
sort_criteria: self.sort_criteria,
max_results: self.max_results,
resource_share_type: self.resource_share_type,
})
}
}
}
impl SearchTablesInput {
/// Consumes the builder and constructs an Operation<[`SearchTables`](crate::operation::SearchTables)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::SearchTables,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::SearchTablesInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::SearchTablesInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.SearchTables",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_search_tables(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::SearchTables::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"SearchTables",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`SearchTablesInput`](crate::input::SearchTablesInput).
pub fn builder() -> crate::input::search_tables_input::Builder {
crate::input::search_tables_input::Builder::default()
}
}
/// See [`StartBlueprintRunInput`](crate::input::StartBlueprintRunInput).
pub mod start_blueprint_run_input {
/// A builder for [`StartBlueprintRunInput`](crate::input::StartBlueprintRunInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) blueprint_name: std::option::Option<std::string::String>,
pub(crate) parameters: std::option::Option<std::string::String>,
pub(crate) role_arn: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The name of the blueprint.</p>
pub fn blueprint_name(mut self, input: impl Into<std::string::String>) -> Self {
self.blueprint_name = Some(input.into());
self
}
/// <p>The name of the blueprint.</p>
pub fn set_blueprint_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.blueprint_name = input;
self
}
/// <p>Specifies the parameters as a <code>BlueprintParameters</code> object.</p>
pub fn parameters(mut self, input: impl Into<std::string::String>) -> Self {
self.parameters = Some(input.into());
self
}
/// <p>Specifies the parameters as a <code>BlueprintParameters</code> object.</p>
pub fn set_parameters(mut self, input: std::option::Option<std::string::String>) -> Self {
self.parameters = input;
self
}
/// <p>Specifies the IAM role used to create the workflow.</p>
pub fn role_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.role_arn = Some(input.into());
self
}
/// <p>Specifies the IAM role used to create the workflow.</p>
pub fn set_role_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.role_arn = input;
self
}
/// Consumes the builder and constructs a [`StartBlueprintRunInput`](crate::input::StartBlueprintRunInput).
pub fn build(
self,
) -> Result<
crate::input::StartBlueprintRunInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::StartBlueprintRunInput {
blueprint_name: self.blueprint_name,
parameters: self.parameters,
role_arn: self.role_arn,
})
}
}
}
impl StartBlueprintRunInput {
/// Consumes the builder and constructs an Operation<[`StartBlueprintRun`](crate::operation::StartBlueprintRun)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::StartBlueprintRun,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::StartBlueprintRunInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::StartBlueprintRunInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.StartBlueprintRun",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_start_blueprint_run(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::StartBlueprintRun::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"StartBlueprintRun",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`StartBlueprintRunInput`](crate::input::StartBlueprintRunInput).
pub fn builder() -> crate::input::start_blueprint_run_input::Builder {
crate::input::start_blueprint_run_input::Builder::default()
}
}
/// See [`StartCrawlerInput`](crate::input::StartCrawlerInput).
pub mod start_crawler_input {
/// A builder for [`StartCrawlerInput`](crate::input::StartCrawlerInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) name: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>Name of the crawler to start.</p>
pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
self.name = Some(input.into());
self
}
/// <p>Name of the crawler to start.</p>
pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.name = input;
self
}
/// Consumes the builder and constructs a [`StartCrawlerInput`](crate::input::StartCrawlerInput).
pub fn build(
self,
) -> Result<crate::input::StartCrawlerInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::StartCrawlerInput { name: self.name })
}
}
}
impl StartCrawlerInput {
/// Consumes the builder and constructs an Operation<[`StartCrawler`](crate::operation::StartCrawler)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::StartCrawler,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::StartCrawlerInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::StartCrawlerInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.StartCrawler",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_start_crawler(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::StartCrawler::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"StartCrawler",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`StartCrawlerInput`](crate::input::StartCrawlerInput).
pub fn builder() -> crate::input::start_crawler_input::Builder {
crate::input::start_crawler_input::Builder::default()
}
}
/// See [`StartCrawlerScheduleInput`](crate::input::StartCrawlerScheduleInput).
pub mod start_crawler_schedule_input {
/// A builder for [`StartCrawlerScheduleInput`](crate::input::StartCrawlerScheduleInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) crawler_name: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>Name of the crawler to schedule.</p>
pub fn crawler_name(mut self, input: impl Into<std::string::String>) -> Self {
self.crawler_name = Some(input.into());
self
}
/// <p>Name of the crawler to schedule.</p>
pub fn set_crawler_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.crawler_name = input;
self
}
/// Consumes the builder and constructs a [`StartCrawlerScheduleInput`](crate::input::StartCrawlerScheduleInput).
pub fn build(
self,
) -> Result<
crate::input::StartCrawlerScheduleInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::StartCrawlerScheduleInput {
crawler_name: self.crawler_name,
})
}
}
}
impl StartCrawlerScheduleInput {
/// Consumes the builder and constructs an Operation<[`StartCrawlerSchedule`](crate::operation::StartCrawlerSchedule)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::StartCrawlerSchedule,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::StartCrawlerScheduleInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::StartCrawlerScheduleInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.StartCrawlerSchedule",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_start_crawler_schedule(
&self,
)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::StartCrawlerSchedule::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"StartCrawlerSchedule",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`StartCrawlerScheduleInput`](crate::input::StartCrawlerScheduleInput).
pub fn builder() -> crate::input::start_crawler_schedule_input::Builder {
crate::input::start_crawler_schedule_input::Builder::default()
}
}
/// See [`StartDataQualityRuleRecommendationRunInput`](crate::input::StartDataQualityRuleRecommendationRunInput).
pub mod start_data_quality_rule_recommendation_run_input {
/// A builder for [`StartDataQualityRuleRecommendationRunInput`](crate::input::StartDataQualityRuleRecommendationRunInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) data_source: std::option::Option<crate::model::DataSource>,
pub(crate) role: std::option::Option<std::string::String>,
pub(crate) number_of_workers: std::option::Option<i32>,
pub(crate) timeout: std::option::Option<i32>,
pub(crate) created_ruleset_name: std::option::Option<std::string::String>,
pub(crate) client_token: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The data source (Glue table) associated with this run.</p>
pub fn data_source(mut self, input: crate::model::DataSource) -> Self {
self.data_source = Some(input);
self
}
/// <p>The data source (Glue table) associated with this run.</p>
pub fn set_data_source(
mut self,
input: std::option::Option<crate::model::DataSource>,
) -> Self {
self.data_source = input;
self
}
/// <p>An IAM role supplied to encrypt the results of the run.</p>
pub fn role(mut self, input: impl Into<std::string::String>) -> Self {
self.role = Some(input.into());
self
}
/// <p>An IAM role supplied to encrypt the results of the run.</p>
pub fn set_role(mut self, input: std::option::Option<std::string::String>) -> Self {
self.role = input;
self
}
/// <p>The number of <code>G.1X</code> workers to be used in the run. The default is 5.</p>
pub fn number_of_workers(mut self, input: i32) -> Self {
self.number_of_workers = Some(input);
self
}
/// <p>The number of <code>G.1X</code> workers to be used in the run. The default is 5.</p>
pub fn set_number_of_workers(mut self, input: std::option::Option<i32>) -> Self {
self.number_of_workers = input;
self
}
/// <p>The timeout for a run in minutes. This is the maximum time that a run can consume resources before it is terminated and enters <code>TIMEOUT</code> status. The default is 2,880 minutes (48 hours).</p>
pub fn timeout(mut self, input: i32) -> Self {
self.timeout = Some(input);
self
}
/// <p>The timeout for a run in minutes. This is the maximum time that a run can consume resources before it is terminated and enters <code>TIMEOUT</code> status. The default is 2,880 minutes (48 hours).</p>
pub fn set_timeout(mut self, input: std::option::Option<i32>) -> Self {
self.timeout = input;
self
}
/// <p>A name for the ruleset.</p>
pub fn created_ruleset_name(mut self, input: impl Into<std::string::String>) -> Self {
self.created_ruleset_name = Some(input.into());
self
}
/// <p>A name for the ruleset.</p>
pub fn set_created_ruleset_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.created_ruleset_name = input;
self
}
/// <p>Used for idempotency and is recommended to be set to a random ID (such as a UUID) to avoid creating or starting multiple instances of the same resource.</p>
pub fn client_token(mut self, input: impl Into<std::string::String>) -> Self {
self.client_token = Some(input.into());
self
}
/// <p>Used for idempotency and is recommended to be set to a random ID (such as a UUID) to avoid creating or starting multiple instances of the same resource.</p>
pub fn set_client_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.client_token = input;
self
}
/// Consumes the builder and constructs a [`StartDataQualityRuleRecommendationRunInput`](crate::input::StartDataQualityRuleRecommendationRunInput).
pub fn build(
self,
) -> Result<
crate::input::StartDataQualityRuleRecommendationRunInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::StartDataQualityRuleRecommendationRunInput {
data_source: self.data_source,
role: self.role,
number_of_workers: self.number_of_workers,
timeout: self.timeout,
created_ruleset_name: self.created_ruleset_name,
client_token: self.client_token,
})
}
}
}
impl StartDataQualityRuleRecommendationRunInput {
/// Consumes the builder and constructs an Operation<[`StartDataQualityRuleRecommendationRun`](crate::operation::StartDataQualityRuleRecommendationRun)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::StartDataQualityRuleRecommendationRun,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::StartDataQualityRuleRecommendationRunInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::StartDataQualityRuleRecommendationRunInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.StartDataQualityRuleRecommendationRun",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_start_data_quality_rule_recommendation_run(&self)?
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::StartDataQualityRuleRecommendationRun::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"StartDataQualityRuleRecommendationRun",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`StartDataQualityRuleRecommendationRunInput`](crate::input::StartDataQualityRuleRecommendationRunInput).
pub fn builder() -> crate::input::start_data_quality_rule_recommendation_run_input::Builder {
crate::input::start_data_quality_rule_recommendation_run_input::Builder::default()
}
}
/// See [`StartDataQualityRulesetEvaluationRunInput`](crate::input::StartDataQualityRulesetEvaluationRunInput).
pub mod start_data_quality_ruleset_evaluation_run_input {
/// A builder for [`StartDataQualityRulesetEvaluationRunInput`](crate::input::StartDataQualityRulesetEvaluationRunInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) data_source: std::option::Option<crate::model::DataSource>,
pub(crate) role: std::option::Option<std::string::String>,
pub(crate) number_of_workers: std::option::Option<i32>,
pub(crate) timeout: std::option::Option<i32>,
pub(crate) client_token: std::option::Option<std::string::String>,
pub(crate) additional_run_options:
std::option::Option<crate::model::DataQualityEvaluationRunAdditionalRunOptions>,
pub(crate) ruleset_names: std::option::Option<std::vec::Vec<std::string::String>>,
}
impl Builder {
/// <p>The data source (Glue table) associated with this run.</p>
pub fn data_source(mut self, input: crate::model::DataSource) -> Self {
self.data_source = Some(input);
self
}
/// <p>The data source (Glue table) associated with this run.</p>
pub fn set_data_source(
mut self,
input: std::option::Option<crate::model::DataSource>,
) -> Self {
self.data_source = input;
self
}
/// <p>An IAM role supplied to encrypt the results of the run.</p>
pub fn role(mut self, input: impl Into<std::string::String>) -> Self {
self.role = Some(input.into());
self
}
/// <p>An IAM role supplied to encrypt the results of the run.</p>
pub fn set_role(mut self, input: std::option::Option<std::string::String>) -> Self {
self.role = input;
self
}
/// <p>The number of <code>G.1X</code> workers to be used in the run. The default is 5.</p>
pub fn number_of_workers(mut self, input: i32) -> Self {
self.number_of_workers = Some(input);
self
}
/// <p>The number of <code>G.1X</code> workers to be used in the run. The default is 5.</p>
pub fn set_number_of_workers(mut self, input: std::option::Option<i32>) -> Self {
self.number_of_workers = input;
self
}
/// <p>The timeout for a run in minutes. This is the maximum time that a run can consume resources before it is terminated and enters <code>TIMEOUT</code> status. The default is 2,880 minutes (48 hours).</p>
pub fn timeout(mut self, input: i32) -> Self {
self.timeout = Some(input);
self
}
/// <p>The timeout for a run in minutes. This is the maximum time that a run can consume resources before it is terminated and enters <code>TIMEOUT</code> status. The default is 2,880 minutes (48 hours).</p>
pub fn set_timeout(mut self, input: std::option::Option<i32>) -> Self {
self.timeout = input;
self
}
/// <p>Used for idempotency and is recommended to be set to a random ID (such as a UUID) to avoid creating or starting multiple instances of the same resource.</p>
pub fn client_token(mut self, input: impl Into<std::string::String>) -> Self {
self.client_token = Some(input.into());
self
}
/// <p>Used for idempotency and is recommended to be set to a random ID (such as a UUID) to avoid creating or starting multiple instances of the same resource.</p>
pub fn set_client_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.client_token = input;
self
}
/// <p>Additional run options you can specify for an evaluation run.</p>
pub fn additional_run_options(
mut self,
input: crate::model::DataQualityEvaluationRunAdditionalRunOptions,
) -> Self {
self.additional_run_options = Some(input);
self
}
/// <p>Additional run options you can specify for an evaluation run.</p>
pub fn set_additional_run_options(
mut self,
input: std::option::Option<crate::model::DataQualityEvaluationRunAdditionalRunOptions>,
) -> Self {
self.additional_run_options = input;
self
}
/// Appends an item to `ruleset_names`.
///
/// To override the contents of this collection use [`set_ruleset_names`](Self::set_ruleset_names).
///
/// <p>A list of ruleset names.</p>
pub fn ruleset_names(mut self, input: impl Into<std::string::String>) -> Self {
let mut v = self.ruleset_names.unwrap_or_default();
v.push(input.into());
self.ruleset_names = Some(v);
self
}
/// <p>A list of ruleset names.</p>
pub fn set_ruleset_names(
mut self,
input: std::option::Option<std::vec::Vec<std::string::String>>,
) -> Self {
self.ruleset_names = input;
self
}
/// Consumes the builder and constructs a [`StartDataQualityRulesetEvaluationRunInput`](crate::input::StartDataQualityRulesetEvaluationRunInput).
pub fn build(
self,
) -> Result<
crate::input::StartDataQualityRulesetEvaluationRunInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::StartDataQualityRulesetEvaluationRunInput {
data_source: self.data_source,
role: self.role,
number_of_workers: self.number_of_workers,
timeout: self.timeout,
client_token: self.client_token,
additional_run_options: self.additional_run_options,
ruleset_names: self.ruleset_names,
})
}
}
}
impl StartDataQualityRulesetEvaluationRunInput {
/// Consumes the builder and constructs an Operation<[`StartDataQualityRulesetEvaluationRun`](crate::operation::StartDataQualityRulesetEvaluationRun)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::StartDataQualityRulesetEvaluationRun,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::StartDataQualityRulesetEvaluationRunInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::StartDataQualityRulesetEvaluationRunInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.StartDataQualityRulesetEvaluationRun",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_start_data_quality_ruleset_evaluation_run(&self)?
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::StartDataQualityRulesetEvaluationRun::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"StartDataQualityRulesetEvaluationRun",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`StartDataQualityRulesetEvaluationRunInput`](crate::input::StartDataQualityRulesetEvaluationRunInput).
pub fn builder() -> crate::input::start_data_quality_ruleset_evaluation_run_input::Builder {
crate::input::start_data_quality_ruleset_evaluation_run_input::Builder::default()
}
}
/// See [`StartExportLabelsTaskRunInput`](crate::input::StartExportLabelsTaskRunInput).
pub mod start_export_labels_task_run_input {
/// A builder for [`StartExportLabelsTaskRunInput`](crate::input::StartExportLabelsTaskRunInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) transform_id: std::option::Option<std::string::String>,
pub(crate) output_s3_path: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The unique identifier of the machine learning transform.</p>
pub fn transform_id(mut self, input: impl Into<std::string::String>) -> Self {
self.transform_id = Some(input.into());
self
}
/// <p>The unique identifier of the machine learning transform.</p>
pub fn set_transform_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.transform_id = input;
self
}
/// <p>The Amazon S3 path where you export the labels.</p>
pub fn output_s3_path(mut self, input: impl Into<std::string::String>) -> Self {
self.output_s3_path = Some(input.into());
self
}
/// <p>The Amazon S3 path where you export the labels.</p>
pub fn set_output_s3_path(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.output_s3_path = input;
self
}
/// Consumes the builder and constructs a [`StartExportLabelsTaskRunInput`](crate::input::StartExportLabelsTaskRunInput).
pub fn build(
self,
) -> Result<
crate::input::StartExportLabelsTaskRunInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::StartExportLabelsTaskRunInput {
transform_id: self.transform_id,
output_s3_path: self.output_s3_path,
})
}
}
}
impl StartExportLabelsTaskRunInput {
/// Consumes the builder and constructs an Operation<[`StartExportLabelsTaskRun`](crate::operation::StartExportLabelsTaskRun)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::StartExportLabelsTaskRun,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::StartExportLabelsTaskRunInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::StartExportLabelsTaskRunInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.StartExportLabelsTaskRun",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_start_export_labels_task_run(
&self,
)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::StartExportLabelsTaskRun::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"StartExportLabelsTaskRun",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`StartExportLabelsTaskRunInput`](crate::input::StartExportLabelsTaskRunInput).
pub fn builder() -> crate::input::start_export_labels_task_run_input::Builder {
crate::input::start_export_labels_task_run_input::Builder::default()
}
}
/// See [`StartImportLabelsTaskRunInput`](crate::input::StartImportLabelsTaskRunInput).
pub mod start_import_labels_task_run_input {
/// A builder for [`StartImportLabelsTaskRunInput`](crate::input::StartImportLabelsTaskRunInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) transform_id: std::option::Option<std::string::String>,
pub(crate) input_s3_path: std::option::Option<std::string::String>,
pub(crate) replace_all_labels: std::option::Option<bool>,
}
impl Builder {
/// <p>The unique identifier of the machine learning transform.</p>
pub fn transform_id(mut self, input: impl Into<std::string::String>) -> Self {
self.transform_id = Some(input.into());
self
}
/// <p>The unique identifier of the machine learning transform.</p>
pub fn set_transform_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.transform_id = input;
self
}
/// <p>The Amazon Simple Storage Service (Amazon S3) path from where you import the labels.</p>
pub fn input_s3_path(mut self, input: impl Into<std::string::String>) -> Self {
self.input_s3_path = Some(input.into());
self
}
/// <p>The Amazon Simple Storage Service (Amazon S3) path from where you import the labels.</p>
pub fn set_input_s3_path(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.input_s3_path = input;
self
}
/// <p>Indicates whether to overwrite your existing labels.</p>
pub fn replace_all_labels(mut self, input: bool) -> Self {
self.replace_all_labels = Some(input);
self
}
/// <p>Indicates whether to overwrite your existing labels.</p>
pub fn set_replace_all_labels(mut self, input: std::option::Option<bool>) -> Self {
self.replace_all_labels = input;
self
}
/// Consumes the builder and constructs a [`StartImportLabelsTaskRunInput`](crate::input::StartImportLabelsTaskRunInput).
pub fn build(
self,
) -> Result<
crate::input::StartImportLabelsTaskRunInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::StartImportLabelsTaskRunInput {
transform_id: self.transform_id,
input_s3_path: self.input_s3_path,
replace_all_labels: self.replace_all_labels.unwrap_or_default(),
})
}
}
}
impl StartImportLabelsTaskRunInput {
/// Consumes the builder and constructs an Operation<[`StartImportLabelsTaskRun`](crate::operation::StartImportLabelsTaskRun)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::StartImportLabelsTaskRun,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::StartImportLabelsTaskRunInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::StartImportLabelsTaskRunInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.StartImportLabelsTaskRun",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_start_import_labels_task_run(
&self,
)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::StartImportLabelsTaskRun::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"StartImportLabelsTaskRun",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`StartImportLabelsTaskRunInput`](crate::input::StartImportLabelsTaskRunInput).
pub fn builder() -> crate::input::start_import_labels_task_run_input::Builder {
crate::input::start_import_labels_task_run_input::Builder::default()
}
}
/// See [`StartJobRunInput`](crate::input::StartJobRunInput).
pub mod start_job_run_input {
/// A builder for [`StartJobRunInput`](crate::input::StartJobRunInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) job_name: std::option::Option<std::string::String>,
pub(crate) job_run_id: std::option::Option<std::string::String>,
pub(crate) arguments: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
pub(crate) allocated_capacity: std::option::Option<i32>,
pub(crate) timeout: std::option::Option<i32>,
pub(crate) max_capacity: std::option::Option<f64>,
pub(crate) security_configuration: std::option::Option<std::string::String>,
pub(crate) notification_property: std::option::Option<crate::model::NotificationProperty>,
pub(crate) worker_type: std::option::Option<crate::model::WorkerType>,
pub(crate) number_of_workers: std::option::Option<i32>,
pub(crate) execution_class: std::option::Option<crate::model::ExecutionClass>,
}
impl Builder {
/// <p>The name of the job definition to use.</p>
pub fn job_name(mut self, input: impl Into<std::string::String>) -> Self {
self.job_name = Some(input.into());
self
}
/// <p>The name of the job definition to use.</p>
pub fn set_job_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.job_name = input;
self
}
/// <p>The ID of a previous <code>JobRun</code> to retry.</p>
pub fn job_run_id(mut self, input: impl Into<std::string::String>) -> Self {
self.job_run_id = Some(input.into());
self
}
/// <p>The ID of a previous <code>JobRun</code> to retry.</p>
pub fn set_job_run_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.job_run_id = input;
self
}
/// Adds a key-value pair to `arguments`.
///
/// To override the contents of this collection use [`set_arguments`](Self::set_arguments).
///
/// <p>The job arguments specifically for this run. For this job run, they replace the default arguments set in the job definition itself.</p>
/// <p>You can specify arguments here that your own job-execution script consumes, as well as arguments that Glue itself consumes.</p>
/// <p>Job arguments may be logged. Do not pass plaintext secrets as arguments. Retrieve secrets from a Glue Connection, Secrets Manager or other secret management mechanism if you intend to keep them within the Job. </p>
/// <p>For information about how to specify and consume your own Job arguments, see the <a href="https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-python-calling.html">Calling Glue APIs in Python</a> topic in the developer guide.</p>
/// <p>For information about the key-value pairs that Glue consumes to set up your job, see the <a href="https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html">Special Parameters Used by Glue</a> topic in the developer guide.</p>
pub fn arguments(
mut self,
k: impl Into<std::string::String>,
v: impl Into<std::string::String>,
) -> Self {
let mut hash_map = self.arguments.unwrap_or_default();
hash_map.insert(k.into(), v.into());
self.arguments = Some(hash_map);
self
}
/// <p>The job arguments specifically for this run. For this job run, they replace the default arguments set in the job definition itself.</p>
/// <p>You can specify arguments here that your own job-execution script consumes, as well as arguments that Glue itself consumes.</p>
/// <p>Job arguments may be logged. Do not pass plaintext secrets as arguments. Retrieve secrets from a Glue Connection, Secrets Manager or other secret management mechanism if you intend to keep them within the Job. </p>
/// <p>For information about how to specify and consume your own Job arguments, see the <a href="https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-python-calling.html">Calling Glue APIs in Python</a> topic in the developer guide.</p>
/// <p>For information about the key-value pairs that Glue consumes to set up your job, see the <a href="https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html">Special Parameters Used by Glue</a> topic in the developer guide.</p>
pub fn set_arguments(
mut self,
input: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
) -> Self {
self.arguments = input;
self
}
/// <p>This field is deprecated. Use <code>MaxCapacity</code> instead.</p>
/// <p>The number of Glue data processing units (DPUs) to allocate to this JobRun. You can allocate a minimum of 2 DPUs; the default is 10. A DPU is a relative measure of processing power that consists of 4 vCPUs of compute capacity and 16 GB of memory. For more information, see the <a href="https://aws.amazon.com/glue/pricing/">Glue pricing page</a>.</p>
#[deprecated(note = "This property is deprecated, use MaxCapacity instead.")]
pub fn allocated_capacity(mut self, input: i32) -> Self {
self.allocated_capacity = Some(input);
self
}
/// <p>This field is deprecated. Use <code>MaxCapacity</code> instead.</p>
/// <p>The number of Glue data processing units (DPUs) to allocate to this JobRun. You can allocate a minimum of 2 DPUs; the default is 10. A DPU is a relative measure of processing power that consists of 4 vCPUs of compute capacity and 16 GB of memory. For more information, see the <a href="https://aws.amazon.com/glue/pricing/">Glue pricing page</a>.</p>
#[deprecated(note = "This property is deprecated, use MaxCapacity instead.")]
pub fn set_allocated_capacity(mut self, input: std::option::Option<i32>) -> Self {
self.allocated_capacity = input;
self
}
/// <p>The <code>JobRun</code> timeout in minutes. This is the maximum time that a job run can consume resources before it is terminated and enters <code>TIMEOUT</code> status. This value overrides the timeout value set in the parent job.</p>
/// <p>Streaming jobs do not have a timeout. The default for non-streaming jobs is 2,880 minutes (48 hours).</p>
pub fn timeout(mut self, input: i32) -> Self {
self.timeout = Some(input);
self
}
/// <p>The <code>JobRun</code> timeout in minutes. This is the maximum time that a job run can consume resources before it is terminated and enters <code>TIMEOUT</code> status. This value overrides the timeout value set in the parent job.</p>
/// <p>Streaming jobs do not have a timeout. The default for non-streaming jobs is 2,880 minutes (48 hours).</p>
pub fn set_timeout(mut self, input: std::option::Option<i32>) -> Self {
self.timeout = input;
self
}
/// <p>The number of Glue data processing units (DPUs) that can be allocated when this job runs. A DPU is a relative measure of processing power that consists of 4 vCPUs of compute capacity and 16 GB of memory. For more information, see the <a href="https://aws.amazon.com/glue/pricing/">Glue pricing page</a>.</p>
/// <p>Do not set <code>Max Capacity</code> if using <code>WorkerType</code> and <code>NumberOfWorkers</code>.</p>
/// <p>The value that can be allocated for <code>MaxCapacity</code> depends on whether you are running a Python shell job, or an Apache Spark ETL job:</p>
/// <ul>
/// <li> <p>When you specify a Python shell job (<code>JobCommand.Name</code>="pythonshell"), you can allocate either 0.0625 or 1 DPU. The default is 0.0625 DPU.</p> </li>
/// <li> <p>When you specify an Apache Spark ETL job (<code>JobCommand.Name</code>="glueetl"), you can allocate a minimum of 2 DPUs. The default is 10 DPUs. This job type cannot have a fractional DPU allocation.</p> </li>
/// </ul>
pub fn max_capacity(mut self, input: f64) -> Self {
self.max_capacity = Some(input);
self
}
/// <p>The number of Glue data processing units (DPUs) that can be allocated when this job runs. A DPU is a relative measure of processing power that consists of 4 vCPUs of compute capacity and 16 GB of memory. For more information, see the <a href="https://aws.amazon.com/glue/pricing/">Glue pricing page</a>.</p>
/// <p>Do not set <code>Max Capacity</code> if using <code>WorkerType</code> and <code>NumberOfWorkers</code>.</p>
/// <p>The value that can be allocated for <code>MaxCapacity</code> depends on whether you are running a Python shell job, or an Apache Spark ETL job:</p>
/// <ul>
/// <li> <p>When you specify a Python shell job (<code>JobCommand.Name</code>="pythonshell"), you can allocate either 0.0625 or 1 DPU. The default is 0.0625 DPU.</p> </li>
/// <li> <p>When you specify an Apache Spark ETL job (<code>JobCommand.Name</code>="glueetl"), you can allocate a minimum of 2 DPUs. The default is 10 DPUs. This job type cannot have a fractional DPU allocation.</p> </li>
/// </ul>
pub fn set_max_capacity(mut self, input: std::option::Option<f64>) -> Self {
self.max_capacity = input;
self
}
/// <p>The name of the <code>SecurityConfiguration</code> structure to be used with this job run.</p>
pub fn security_configuration(mut self, input: impl Into<std::string::String>) -> Self {
self.security_configuration = Some(input.into());
self
}
/// <p>The name of the <code>SecurityConfiguration</code> structure to be used with this job run.</p>
pub fn set_security_configuration(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.security_configuration = input;
self
}
/// <p>Specifies configuration properties of a job run notification.</p>
pub fn notification_property(mut self, input: crate::model::NotificationProperty) -> Self {
self.notification_property = Some(input);
self
}
/// <p>Specifies configuration properties of a job run notification.</p>
pub fn set_notification_property(
mut self,
input: std::option::Option<crate::model::NotificationProperty>,
) -> Self {
self.notification_property = input;
self
}
/// <p>The type of predefined worker that is allocated when a job runs. Accepts a value of Standard, G.1X, G.2X, or G.025X.</p>
/// <ul>
/// <li> <p>For the <code>Standard</code> worker type, each worker provides 4 vCPU, 16 GB of memory and a 50GB disk, and 2 executors per worker.</p> </li>
/// <li> <p>For the <code>G.1X</code> worker type, each worker provides 4 vCPU, 16 GB of memory and a 64GB disk, and 1 executor per worker.</p> </li>
/// <li> <p>For the <code>G.2X</code> worker type, each worker provides 8 vCPU, 32 GB of memory and a 128GB disk, and 1 executor per worker.</p> </li>
/// <li> <p>For the <code>G.025X</code> worker type, each worker maps to 0.25 DPU (2 vCPU, 4 GB of memory, 64 GB disk), and provides 1 executor per worker. We recommend this worker type for low volume streaming jobs. This worker type is only available for Glue version 3.0 streaming jobs.</p> </li>
/// </ul>
pub fn worker_type(mut self, input: crate::model::WorkerType) -> Self {
self.worker_type = Some(input);
self
}
/// <p>The type of predefined worker that is allocated when a job runs. Accepts a value of Standard, G.1X, G.2X, or G.025X.</p>
/// <ul>
/// <li> <p>For the <code>Standard</code> worker type, each worker provides 4 vCPU, 16 GB of memory and a 50GB disk, and 2 executors per worker.</p> </li>
/// <li> <p>For the <code>G.1X</code> worker type, each worker provides 4 vCPU, 16 GB of memory and a 64GB disk, and 1 executor per worker.</p> </li>
/// <li> <p>For the <code>G.2X</code> worker type, each worker provides 8 vCPU, 32 GB of memory and a 128GB disk, and 1 executor per worker.</p> </li>
/// <li> <p>For the <code>G.025X</code> worker type, each worker maps to 0.25 DPU (2 vCPU, 4 GB of memory, 64 GB disk), and provides 1 executor per worker. We recommend this worker type for low volume streaming jobs. This worker type is only available for Glue version 3.0 streaming jobs.</p> </li>
/// </ul>
pub fn set_worker_type(
mut self,
input: std::option::Option<crate::model::WorkerType>,
) -> Self {
self.worker_type = input;
self
}
/// <p>The number of workers of a defined <code>workerType</code> that are allocated when a job runs.</p>
pub fn number_of_workers(mut self, input: i32) -> Self {
self.number_of_workers = Some(input);
self
}
/// <p>The number of workers of a defined <code>workerType</code> that are allocated when a job runs.</p>
pub fn set_number_of_workers(mut self, input: std::option::Option<i32>) -> Self {
self.number_of_workers = input;
self
}
/// <p>Indicates whether the job is run with a standard or flexible execution class. The standard execution-class is ideal for time-sensitive workloads that require fast job startup and dedicated resources.</p>
/// <p>The flexible execution class is appropriate for time-insensitive jobs whose start and completion times may vary. </p>
/// <p>Only jobs with Glue version 3.0 and above and command type <code>glueetl</code> will be allowed to set <code>ExecutionClass</code> to <code>FLEX</code>. The flexible execution class is available for Spark jobs.</p>
pub fn execution_class(mut self, input: crate::model::ExecutionClass) -> Self {
self.execution_class = Some(input);
self
}
/// <p>Indicates whether the job is run with a standard or flexible execution class. The standard execution-class is ideal for time-sensitive workloads that require fast job startup and dedicated resources.</p>
/// <p>The flexible execution class is appropriate for time-insensitive jobs whose start and completion times may vary. </p>
/// <p>Only jobs with Glue version 3.0 and above and command type <code>glueetl</code> will be allowed to set <code>ExecutionClass</code> to <code>FLEX</code>. The flexible execution class is available for Spark jobs.</p>
pub fn set_execution_class(
mut self,
input: std::option::Option<crate::model::ExecutionClass>,
) -> Self {
self.execution_class = input;
self
}
/// Consumes the builder and constructs a [`StartJobRunInput`](crate::input::StartJobRunInput).
pub fn build(
self,
) -> Result<crate::input::StartJobRunInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::StartJobRunInput {
job_name: self.job_name,
job_run_id: self.job_run_id,
arguments: self.arguments,
allocated_capacity: self.allocated_capacity.unwrap_or_default(),
timeout: self.timeout,
max_capacity: self.max_capacity,
security_configuration: self.security_configuration,
notification_property: self.notification_property,
worker_type: self.worker_type,
number_of_workers: self.number_of_workers,
execution_class: self.execution_class,
})
}
}
}
impl StartJobRunInput {
/// Consumes the builder and constructs an Operation<[`StartJobRun`](crate::operation::StartJobRun)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::StartJobRun,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::StartJobRunInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::StartJobRunInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.StartJobRun",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_start_job_run(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::StartJobRun::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"StartJobRun",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`StartJobRunInput`](crate::input::StartJobRunInput).
pub fn builder() -> crate::input::start_job_run_input::Builder {
crate::input::start_job_run_input::Builder::default()
}
}
/// See [`StartMlEvaluationTaskRunInput`](crate::input::StartMlEvaluationTaskRunInput).
pub mod start_ml_evaluation_task_run_input {
/// A builder for [`StartMlEvaluationTaskRunInput`](crate::input::StartMlEvaluationTaskRunInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) transform_id: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The unique identifier of the machine learning transform.</p>
pub fn transform_id(mut self, input: impl Into<std::string::String>) -> Self {
self.transform_id = Some(input.into());
self
}
/// <p>The unique identifier of the machine learning transform.</p>
pub fn set_transform_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.transform_id = input;
self
}
/// Consumes the builder and constructs a [`StartMlEvaluationTaskRunInput`](crate::input::StartMlEvaluationTaskRunInput).
pub fn build(
self,
) -> Result<
crate::input::StartMlEvaluationTaskRunInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::StartMlEvaluationTaskRunInput {
transform_id: self.transform_id,
})
}
}
}
impl StartMlEvaluationTaskRunInput {
/// Consumes the builder and constructs an Operation<[`StartMLEvaluationTaskRun`](crate::operation::StartMLEvaluationTaskRun)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::StartMLEvaluationTaskRun,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::StartMlEvaluationTaskRunInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::StartMlEvaluationTaskRunInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.StartMLEvaluationTaskRun",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_start_ml_evaluation_task_run(
&self,
)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::StartMLEvaluationTaskRun::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"StartMLEvaluationTaskRun",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`StartMlEvaluationTaskRunInput`](crate::input::StartMlEvaluationTaskRunInput).
pub fn builder() -> crate::input::start_ml_evaluation_task_run_input::Builder {
crate::input::start_ml_evaluation_task_run_input::Builder::default()
}
}
/// See [`StartMlLabelingSetGenerationTaskRunInput`](crate::input::StartMlLabelingSetGenerationTaskRunInput).
pub mod start_ml_labeling_set_generation_task_run_input {
/// A builder for [`StartMlLabelingSetGenerationTaskRunInput`](crate::input::StartMlLabelingSetGenerationTaskRunInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) transform_id: std::option::Option<std::string::String>,
pub(crate) output_s3_path: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The unique identifier of the machine learning transform.</p>
pub fn transform_id(mut self, input: impl Into<std::string::String>) -> Self {
self.transform_id = Some(input.into());
self
}
/// <p>The unique identifier of the machine learning transform.</p>
pub fn set_transform_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.transform_id = input;
self
}
/// <p>The Amazon Simple Storage Service (Amazon S3) path where you generate the labeling set.</p>
pub fn output_s3_path(mut self, input: impl Into<std::string::String>) -> Self {
self.output_s3_path = Some(input.into());
self
}
/// <p>The Amazon Simple Storage Service (Amazon S3) path where you generate the labeling set.</p>
pub fn set_output_s3_path(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.output_s3_path = input;
self
}
/// Consumes the builder and constructs a [`StartMlLabelingSetGenerationTaskRunInput`](crate::input::StartMlLabelingSetGenerationTaskRunInput).
pub fn build(
self,
) -> Result<
crate::input::StartMlLabelingSetGenerationTaskRunInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::StartMlLabelingSetGenerationTaskRunInput {
transform_id: self.transform_id,
output_s3_path: self.output_s3_path,
})
}
}
}
impl StartMlLabelingSetGenerationTaskRunInput {
/// Consumes the builder and constructs an Operation<[`StartMLLabelingSetGenerationTaskRun`](crate::operation::StartMLLabelingSetGenerationTaskRun)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::StartMLLabelingSetGenerationTaskRun,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::StartMlLabelingSetGenerationTaskRunInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::StartMlLabelingSetGenerationTaskRunInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.StartMLLabelingSetGenerationTaskRun",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_start_ml_labeling_set_generation_task_run(&self)?
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::StartMLLabelingSetGenerationTaskRun::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"StartMLLabelingSetGenerationTaskRun",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`StartMlLabelingSetGenerationTaskRunInput`](crate::input::StartMlLabelingSetGenerationTaskRunInput).
pub fn builder() -> crate::input::start_ml_labeling_set_generation_task_run_input::Builder {
crate::input::start_ml_labeling_set_generation_task_run_input::Builder::default()
}
}
/// See [`StartTriggerInput`](crate::input::StartTriggerInput).
pub mod start_trigger_input {
/// A builder for [`StartTriggerInput`](crate::input::StartTriggerInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) name: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The name of the trigger to start.</p>
pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
self.name = Some(input.into());
self
}
/// <p>The name of the trigger to start.</p>
pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.name = input;
self
}
/// Consumes the builder and constructs a [`StartTriggerInput`](crate::input::StartTriggerInput).
pub fn build(
self,
) -> Result<crate::input::StartTriggerInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::StartTriggerInput { name: self.name })
}
}
}
impl StartTriggerInput {
/// Consumes the builder and constructs an Operation<[`StartTrigger`](crate::operation::StartTrigger)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::StartTrigger,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::StartTriggerInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::StartTriggerInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.StartTrigger",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_start_trigger(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::StartTrigger::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"StartTrigger",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`StartTriggerInput`](crate::input::StartTriggerInput).
pub fn builder() -> crate::input::start_trigger_input::Builder {
crate::input::start_trigger_input::Builder::default()
}
}
/// See [`StartWorkflowRunInput`](crate::input::StartWorkflowRunInput).
pub mod start_workflow_run_input {
/// A builder for [`StartWorkflowRunInput`](crate::input::StartWorkflowRunInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) name: std::option::Option<std::string::String>,
pub(crate) run_properties: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
}
impl Builder {
/// <p>The name of the workflow to start.</p>
pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
self.name = Some(input.into());
self
}
/// <p>The name of the workflow to start.</p>
pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.name = input;
self
}
/// Adds a key-value pair to `run_properties`.
///
/// To override the contents of this collection use [`set_run_properties`](Self::set_run_properties).
///
/// <p>The workflow run properties for the new workflow run.</p>
pub fn run_properties(
mut self,
k: impl Into<std::string::String>,
v: impl Into<std::string::String>,
) -> Self {
let mut hash_map = self.run_properties.unwrap_or_default();
hash_map.insert(k.into(), v.into());
self.run_properties = Some(hash_map);
self
}
/// <p>The workflow run properties for the new workflow run.</p>
pub fn set_run_properties(
mut self,
input: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
) -> Self {
self.run_properties = input;
self
}
/// Consumes the builder and constructs a [`StartWorkflowRunInput`](crate::input::StartWorkflowRunInput).
pub fn build(
self,
) -> Result<
crate::input::StartWorkflowRunInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::StartWorkflowRunInput {
name: self.name,
run_properties: self.run_properties,
})
}
}
}
impl StartWorkflowRunInput {
/// Consumes the builder and constructs an Operation<[`StartWorkflowRun`](crate::operation::StartWorkflowRun)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::StartWorkflowRun,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::StartWorkflowRunInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::StartWorkflowRunInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.StartWorkflowRun",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_start_workflow_run(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::StartWorkflowRun::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"StartWorkflowRun",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`StartWorkflowRunInput`](crate::input::StartWorkflowRunInput).
pub fn builder() -> crate::input::start_workflow_run_input::Builder {
crate::input::start_workflow_run_input::Builder::default()
}
}
/// See [`StopCrawlerInput`](crate::input::StopCrawlerInput).
pub mod stop_crawler_input {
/// A builder for [`StopCrawlerInput`](crate::input::StopCrawlerInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) name: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>Name of the crawler to stop.</p>
pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
self.name = Some(input.into());
self
}
/// <p>Name of the crawler to stop.</p>
pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.name = input;
self
}
/// Consumes the builder and constructs a [`StopCrawlerInput`](crate::input::StopCrawlerInput).
pub fn build(
self,
) -> Result<crate::input::StopCrawlerInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::StopCrawlerInput { name: self.name })
}
}
}
impl StopCrawlerInput {
/// Consumes the builder and constructs an Operation<[`StopCrawler`](crate::operation::StopCrawler)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::StopCrawler,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::StopCrawlerInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::StopCrawlerInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.StopCrawler",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_stop_crawler(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::StopCrawler::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"StopCrawler",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`StopCrawlerInput`](crate::input::StopCrawlerInput).
pub fn builder() -> crate::input::stop_crawler_input::Builder {
crate::input::stop_crawler_input::Builder::default()
}
}
/// See [`StopCrawlerScheduleInput`](crate::input::StopCrawlerScheduleInput).
pub mod stop_crawler_schedule_input {
/// A builder for [`StopCrawlerScheduleInput`](crate::input::StopCrawlerScheduleInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) crawler_name: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>Name of the crawler whose schedule state to set.</p>
pub fn crawler_name(mut self, input: impl Into<std::string::String>) -> Self {
self.crawler_name = Some(input.into());
self
}
/// <p>Name of the crawler whose schedule state to set.</p>
pub fn set_crawler_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.crawler_name = input;
self
}
/// Consumes the builder and constructs a [`StopCrawlerScheduleInput`](crate::input::StopCrawlerScheduleInput).
pub fn build(
self,
) -> Result<
crate::input::StopCrawlerScheduleInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::StopCrawlerScheduleInput {
crawler_name: self.crawler_name,
})
}
}
}
impl StopCrawlerScheduleInput {
/// Consumes the builder and constructs an Operation<[`StopCrawlerSchedule`](crate::operation::StopCrawlerSchedule)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::StopCrawlerSchedule,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::StopCrawlerScheduleInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::StopCrawlerScheduleInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.StopCrawlerSchedule",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_stop_crawler_schedule(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::StopCrawlerSchedule::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"StopCrawlerSchedule",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`StopCrawlerScheduleInput`](crate::input::StopCrawlerScheduleInput).
pub fn builder() -> crate::input::stop_crawler_schedule_input::Builder {
crate::input::stop_crawler_schedule_input::Builder::default()
}
}
/// See [`StopSessionInput`](crate::input::StopSessionInput).
pub mod stop_session_input {
/// A builder for [`StopSessionInput`](crate::input::StopSessionInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) id: std::option::Option<std::string::String>,
pub(crate) request_origin: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The ID of the session to be stopped.</p>
pub fn id(mut self, input: impl Into<std::string::String>) -> Self {
self.id = Some(input.into());
self
}
/// <p>The ID of the session to be stopped.</p>
pub fn set_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.id = input;
self
}
/// <p>The origin of the request.</p>
pub fn request_origin(mut self, input: impl Into<std::string::String>) -> Self {
self.request_origin = Some(input.into());
self
}
/// <p>The origin of the request.</p>
pub fn set_request_origin(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.request_origin = input;
self
}
/// Consumes the builder and constructs a [`StopSessionInput`](crate::input::StopSessionInput).
pub fn build(
self,
) -> Result<crate::input::StopSessionInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::StopSessionInput {
id: self.id,
request_origin: self.request_origin,
})
}
}
}
impl StopSessionInput {
/// Consumes the builder and constructs an Operation<[`StopSession`](crate::operation::StopSession)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::StopSession,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::StopSessionInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::StopSessionInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.StopSession",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_stop_session(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::StopSession::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"StopSession",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`StopSessionInput`](crate::input::StopSessionInput).
pub fn builder() -> crate::input::stop_session_input::Builder {
crate::input::stop_session_input::Builder::default()
}
}
/// See [`StopTriggerInput`](crate::input::StopTriggerInput).
pub mod stop_trigger_input {
/// A builder for [`StopTriggerInput`](crate::input::StopTriggerInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) name: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The name of the trigger to stop.</p>
pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
self.name = Some(input.into());
self
}
/// <p>The name of the trigger to stop.</p>
pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.name = input;
self
}
/// Consumes the builder and constructs a [`StopTriggerInput`](crate::input::StopTriggerInput).
pub fn build(
self,
) -> Result<crate::input::StopTriggerInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::StopTriggerInput { name: self.name })
}
}
}
impl StopTriggerInput {
/// Consumes the builder and constructs an Operation<[`StopTrigger`](crate::operation::StopTrigger)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::StopTrigger,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::StopTriggerInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::StopTriggerInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.StopTrigger",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_stop_trigger(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::StopTrigger::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"StopTrigger",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`StopTriggerInput`](crate::input::StopTriggerInput).
pub fn builder() -> crate::input::stop_trigger_input::Builder {
crate::input::stop_trigger_input::Builder::default()
}
}
/// See [`StopWorkflowRunInput`](crate::input::StopWorkflowRunInput).
pub mod stop_workflow_run_input {
/// A builder for [`StopWorkflowRunInput`](crate::input::StopWorkflowRunInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) name: std::option::Option<std::string::String>,
pub(crate) run_id: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The name of the workflow to stop.</p>
pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
self.name = Some(input.into());
self
}
/// <p>The name of the workflow to stop.</p>
pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.name = input;
self
}
/// <p>The ID of the workflow run to stop.</p>
pub fn run_id(mut self, input: impl Into<std::string::String>) -> Self {
self.run_id = Some(input.into());
self
}
/// <p>The ID of the workflow run to stop.</p>
pub fn set_run_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.run_id = input;
self
}
/// Consumes the builder and constructs a [`StopWorkflowRunInput`](crate::input::StopWorkflowRunInput).
pub fn build(
self,
) -> Result<crate::input::StopWorkflowRunInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::StopWorkflowRunInput {
name: self.name,
run_id: self.run_id,
})
}
}
}
impl StopWorkflowRunInput {
/// Consumes the builder and constructs an Operation<[`StopWorkflowRun`](crate::operation::StopWorkflowRun)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::StopWorkflowRun,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::StopWorkflowRunInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::StopWorkflowRunInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.StopWorkflowRun",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_stop_workflow_run(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::StopWorkflowRun::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"StopWorkflowRun",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`StopWorkflowRunInput`](crate::input::StopWorkflowRunInput).
pub fn builder() -> crate::input::stop_workflow_run_input::Builder {
crate::input::stop_workflow_run_input::Builder::default()
}
}
/// See [`TagResourceInput`](crate::input::TagResourceInput).
pub mod tag_resource_input {
/// A builder for [`TagResourceInput`](crate::input::TagResourceInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) resource_arn: std::option::Option<std::string::String>,
pub(crate) tags_to_add: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
}
impl Builder {
/// <p>The ARN of the Glue resource to which to add the tags. For more information about Glue resource ARNs, see the <a href="https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-common.html#aws-glue-api-regex-aws-glue-arn-id">Glue ARN string pattern</a>.</p>
pub fn resource_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.resource_arn = Some(input.into());
self
}
/// <p>The ARN of the Glue resource to which to add the tags. For more information about Glue resource ARNs, see the <a href="https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-common.html#aws-glue-api-regex-aws-glue-arn-id">Glue ARN string pattern</a>.</p>
pub fn set_resource_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.resource_arn = input;
self
}
/// Adds a key-value pair to `tags_to_add`.
///
/// To override the contents of this collection use [`set_tags_to_add`](Self::set_tags_to_add).
///
/// <p>Tags to add to this resource.</p>
pub fn tags_to_add(
mut self,
k: impl Into<std::string::String>,
v: impl Into<std::string::String>,
) -> Self {
let mut hash_map = self.tags_to_add.unwrap_or_default();
hash_map.insert(k.into(), v.into());
self.tags_to_add = Some(hash_map);
self
}
/// <p>Tags to add to this resource.</p>
pub fn set_tags_to_add(
mut self,
input: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
) -> Self {
self.tags_to_add = input;
self
}
/// Consumes the builder and constructs a [`TagResourceInput`](crate::input::TagResourceInput).
pub fn build(
self,
) -> Result<crate::input::TagResourceInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::TagResourceInput {
resource_arn: self.resource_arn,
tags_to_add: self.tags_to_add,
})
}
}
}
impl TagResourceInput {
/// Consumes the builder and constructs an Operation<[`TagResource`](crate::operation::TagResource)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::TagResource,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::TagResourceInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::TagResourceInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.TagResource",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_tag_resource(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::TagResource::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"TagResource",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`TagResourceInput`](crate::input::TagResourceInput).
pub fn builder() -> crate::input::tag_resource_input::Builder {
crate::input::tag_resource_input::Builder::default()
}
}
/// See [`UntagResourceInput`](crate::input::UntagResourceInput).
pub mod untag_resource_input {
/// A builder for [`UntagResourceInput`](crate::input::UntagResourceInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) resource_arn: std::option::Option<std::string::String>,
pub(crate) tags_to_remove: std::option::Option<std::vec::Vec<std::string::String>>,
}
impl Builder {
/// <p>The Amazon Resource Name (ARN) of the resource from which to remove the tags.</p>
pub fn resource_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.resource_arn = Some(input.into());
self
}
/// <p>The Amazon Resource Name (ARN) of the resource from which to remove the tags.</p>
pub fn set_resource_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.resource_arn = input;
self
}
/// Appends an item to `tags_to_remove`.
///
/// To override the contents of this collection use [`set_tags_to_remove`](Self::set_tags_to_remove).
///
/// <p>Tags to remove from this resource.</p>
pub fn tags_to_remove(mut self, input: impl Into<std::string::String>) -> Self {
let mut v = self.tags_to_remove.unwrap_or_default();
v.push(input.into());
self.tags_to_remove = Some(v);
self
}
/// <p>Tags to remove from this resource.</p>
pub fn set_tags_to_remove(
mut self,
input: std::option::Option<std::vec::Vec<std::string::String>>,
) -> Self {
self.tags_to_remove = input;
self
}
/// Consumes the builder and constructs a [`UntagResourceInput`](crate::input::UntagResourceInput).
pub fn build(
self,
) -> Result<crate::input::UntagResourceInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::UntagResourceInput {
resource_arn: self.resource_arn,
tags_to_remove: self.tags_to_remove,
})
}
}
}
impl UntagResourceInput {
/// Consumes the builder and constructs an Operation<[`UntagResource`](crate::operation::UntagResource)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::UntagResource,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::UntagResourceInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::UntagResourceInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.UntagResource",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_untag_resource(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::UntagResource::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"UntagResource",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`UntagResourceInput`](crate::input::UntagResourceInput).
pub fn builder() -> crate::input::untag_resource_input::Builder {
crate::input::untag_resource_input::Builder::default()
}
}
/// See [`UpdateBlueprintInput`](crate::input::UpdateBlueprintInput).
pub mod update_blueprint_input {
/// A builder for [`UpdateBlueprintInput`](crate::input::UpdateBlueprintInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) name: std::option::Option<std::string::String>,
pub(crate) description: std::option::Option<std::string::String>,
pub(crate) blueprint_location: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The name of the blueprint.</p>
pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
self.name = Some(input.into());
self
}
/// <p>The name of the blueprint.</p>
pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.name = input;
self
}
/// <p>A description of the blueprint.</p>
pub fn description(mut self, input: impl Into<std::string::String>) -> Self {
self.description = Some(input.into());
self
}
/// <p>A description of the blueprint.</p>
pub fn set_description(mut self, input: std::option::Option<std::string::String>) -> Self {
self.description = input;
self
}
/// <p>Specifies a path in Amazon S3 where the blueprint is published.</p>
pub fn blueprint_location(mut self, input: impl Into<std::string::String>) -> Self {
self.blueprint_location = Some(input.into());
self
}
/// <p>Specifies a path in Amazon S3 where the blueprint is published.</p>
pub fn set_blueprint_location(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.blueprint_location = input;
self
}
/// Consumes the builder and constructs a [`UpdateBlueprintInput`](crate::input::UpdateBlueprintInput).
pub fn build(
self,
) -> Result<crate::input::UpdateBlueprintInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::UpdateBlueprintInput {
name: self.name,
description: self.description,
blueprint_location: self.blueprint_location,
})
}
}
}
impl UpdateBlueprintInput {
/// Consumes the builder and constructs an Operation<[`UpdateBlueprint`](crate::operation::UpdateBlueprint)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::UpdateBlueprint,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::UpdateBlueprintInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::UpdateBlueprintInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.UpdateBlueprint",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_update_blueprint(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::UpdateBlueprint::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"UpdateBlueprint",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`UpdateBlueprintInput`](crate::input::UpdateBlueprintInput).
pub fn builder() -> crate::input::update_blueprint_input::Builder {
crate::input::update_blueprint_input::Builder::default()
}
}
/// See [`UpdateClassifierInput`](crate::input::UpdateClassifierInput).
pub mod update_classifier_input {
/// A builder for [`UpdateClassifierInput`](crate::input::UpdateClassifierInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) grok_classifier: std::option::Option<crate::model::UpdateGrokClassifierRequest>,
pub(crate) xml_classifier: std::option::Option<crate::model::UpdateXmlClassifierRequest>,
pub(crate) json_classifier: std::option::Option<crate::model::UpdateJsonClassifierRequest>,
pub(crate) csv_classifier: std::option::Option<crate::model::UpdateCsvClassifierRequest>,
}
impl Builder {
/// <p>A <code>GrokClassifier</code> object with updated fields.</p>
pub fn grok_classifier(mut self, input: crate::model::UpdateGrokClassifierRequest) -> Self {
self.grok_classifier = Some(input);
self
}
/// <p>A <code>GrokClassifier</code> object with updated fields.</p>
pub fn set_grok_classifier(
mut self,
input: std::option::Option<crate::model::UpdateGrokClassifierRequest>,
) -> Self {
self.grok_classifier = input;
self
}
/// <p>An <code>XMLClassifier</code> object with updated fields.</p>
pub fn xml_classifier(mut self, input: crate::model::UpdateXmlClassifierRequest) -> Self {
self.xml_classifier = Some(input);
self
}
/// <p>An <code>XMLClassifier</code> object with updated fields.</p>
pub fn set_xml_classifier(
mut self,
input: std::option::Option<crate::model::UpdateXmlClassifierRequest>,
) -> Self {
self.xml_classifier = input;
self
}
/// <p>A <code>JsonClassifier</code> object with updated fields.</p>
pub fn json_classifier(mut self, input: crate::model::UpdateJsonClassifierRequest) -> Self {
self.json_classifier = Some(input);
self
}
/// <p>A <code>JsonClassifier</code> object with updated fields.</p>
pub fn set_json_classifier(
mut self,
input: std::option::Option<crate::model::UpdateJsonClassifierRequest>,
) -> Self {
self.json_classifier = input;
self
}
/// <p>A <code>CsvClassifier</code> object with updated fields.</p>
pub fn csv_classifier(mut self, input: crate::model::UpdateCsvClassifierRequest) -> Self {
self.csv_classifier = Some(input);
self
}
/// <p>A <code>CsvClassifier</code> object with updated fields.</p>
pub fn set_csv_classifier(
mut self,
input: std::option::Option<crate::model::UpdateCsvClassifierRequest>,
) -> Self {
self.csv_classifier = input;
self
}
/// Consumes the builder and constructs a [`UpdateClassifierInput`](crate::input::UpdateClassifierInput).
pub fn build(
self,
) -> Result<
crate::input::UpdateClassifierInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::UpdateClassifierInput {
grok_classifier: self.grok_classifier,
xml_classifier: self.xml_classifier,
json_classifier: self.json_classifier,
csv_classifier: self.csv_classifier,
})
}
}
}
impl UpdateClassifierInput {
/// Consumes the builder and constructs an Operation<[`UpdateClassifier`](crate::operation::UpdateClassifier)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::UpdateClassifier,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::UpdateClassifierInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::UpdateClassifierInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.UpdateClassifier",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_update_classifier(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::UpdateClassifier::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"UpdateClassifier",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`UpdateClassifierInput`](crate::input::UpdateClassifierInput).
pub fn builder() -> crate::input::update_classifier_input::Builder {
crate::input::update_classifier_input::Builder::default()
}
}
/// See [`UpdateColumnStatisticsForPartitionInput`](crate::input::UpdateColumnStatisticsForPartitionInput).
pub mod update_column_statistics_for_partition_input {
/// A builder for [`UpdateColumnStatisticsForPartitionInput`](crate::input::UpdateColumnStatisticsForPartitionInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) catalog_id: std::option::Option<std::string::String>,
pub(crate) database_name: std::option::Option<std::string::String>,
pub(crate) table_name: std::option::Option<std::string::String>,
pub(crate) partition_values: std::option::Option<std::vec::Vec<std::string::String>>,
pub(crate) column_statistics_list:
std::option::Option<std::vec::Vec<crate::model::ColumnStatistics>>,
}
impl Builder {
/// <p>The ID of the Data Catalog where the partitions in question reside. If none is supplied, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(mut self, input: impl Into<std::string::String>) -> Self {
self.catalog_id = Some(input.into());
self
}
/// <p>The ID of the Data Catalog where the partitions in question reside. If none is supplied, the Amazon Web Services account ID is used by default.</p>
pub fn set_catalog_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.catalog_id = input;
self
}
/// <p>The name of the catalog database where the partitions reside.</p>
pub fn database_name(mut self, input: impl Into<std::string::String>) -> Self {
self.database_name = Some(input.into());
self
}
/// <p>The name of the catalog database where the partitions reside.</p>
pub fn set_database_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.database_name = input;
self
}
/// <p>The name of the partitions' table.</p>
pub fn table_name(mut self, input: impl Into<std::string::String>) -> Self {
self.table_name = Some(input.into());
self
}
/// <p>The name of the partitions' table.</p>
pub fn set_table_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.table_name = input;
self
}
/// Appends an item to `partition_values`.
///
/// To override the contents of this collection use [`set_partition_values`](Self::set_partition_values).
///
/// <p>A list of partition values identifying the partition.</p>
pub fn partition_values(mut self, input: impl Into<std::string::String>) -> Self {
let mut v = self.partition_values.unwrap_or_default();
v.push(input.into());
self.partition_values = Some(v);
self
}
/// <p>A list of partition values identifying the partition.</p>
pub fn set_partition_values(
mut self,
input: std::option::Option<std::vec::Vec<std::string::String>>,
) -> Self {
self.partition_values = input;
self
}
/// Appends an item to `column_statistics_list`.
///
/// To override the contents of this collection use [`set_column_statistics_list`](Self::set_column_statistics_list).
///
/// <p>A list of the column statistics.</p>
pub fn column_statistics_list(mut self, input: crate::model::ColumnStatistics) -> Self {
let mut v = self.column_statistics_list.unwrap_or_default();
v.push(input);
self.column_statistics_list = Some(v);
self
}
/// <p>A list of the column statistics.</p>
pub fn set_column_statistics_list(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::ColumnStatistics>>,
) -> Self {
self.column_statistics_list = input;
self
}
/// Consumes the builder and constructs a [`UpdateColumnStatisticsForPartitionInput`](crate::input::UpdateColumnStatisticsForPartitionInput).
pub fn build(
self,
) -> Result<
crate::input::UpdateColumnStatisticsForPartitionInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::UpdateColumnStatisticsForPartitionInput {
catalog_id: self.catalog_id,
database_name: self.database_name,
table_name: self.table_name,
partition_values: self.partition_values,
column_statistics_list: self.column_statistics_list,
})
}
}
}
impl UpdateColumnStatisticsForPartitionInput {
/// Consumes the builder and constructs an Operation<[`UpdateColumnStatisticsForPartition`](crate::operation::UpdateColumnStatisticsForPartition)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::UpdateColumnStatisticsForPartition,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::UpdateColumnStatisticsForPartitionInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::UpdateColumnStatisticsForPartitionInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.UpdateColumnStatisticsForPartition",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_update_column_statistics_for_partition(&self)?
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::UpdateColumnStatisticsForPartition::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"UpdateColumnStatisticsForPartition",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`UpdateColumnStatisticsForPartitionInput`](crate::input::UpdateColumnStatisticsForPartitionInput).
pub fn builder() -> crate::input::update_column_statistics_for_partition_input::Builder {
crate::input::update_column_statistics_for_partition_input::Builder::default()
}
}
/// See [`UpdateColumnStatisticsForTableInput`](crate::input::UpdateColumnStatisticsForTableInput).
pub mod update_column_statistics_for_table_input {
/// A builder for [`UpdateColumnStatisticsForTableInput`](crate::input::UpdateColumnStatisticsForTableInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) catalog_id: std::option::Option<std::string::String>,
pub(crate) database_name: std::option::Option<std::string::String>,
pub(crate) table_name: std::option::Option<std::string::String>,
pub(crate) column_statistics_list:
std::option::Option<std::vec::Vec<crate::model::ColumnStatistics>>,
}
impl Builder {
/// <p>The ID of the Data Catalog where the partitions in question reside. If none is supplied, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(mut self, input: impl Into<std::string::String>) -> Self {
self.catalog_id = Some(input.into());
self
}
/// <p>The ID of the Data Catalog where the partitions in question reside. If none is supplied, the Amazon Web Services account ID is used by default.</p>
pub fn set_catalog_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.catalog_id = input;
self
}
/// <p>The name of the catalog database where the partitions reside.</p>
pub fn database_name(mut self, input: impl Into<std::string::String>) -> Self {
self.database_name = Some(input.into());
self
}
/// <p>The name of the catalog database where the partitions reside.</p>
pub fn set_database_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.database_name = input;
self
}
/// <p>The name of the partitions' table.</p>
pub fn table_name(mut self, input: impl Into<std::string::String>) -> Self {
self.table_name = Some(input.into());
self
}
/// <p>The name of the partitions' table.</p>
pub fn set_table_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.table_name = input;
self
}
/// Appends an item to `column_statistics_list`.
///
/// To override the contents of this collection use [`set_column_statistics_list`](Self::set_column_statistics_list).
///
/// <p>A list of the column statistics.</p>
pub fn column_statistics_list(mut self, input: crate::model::ColumnStatistics) -> Self {
let mut v = self.column_statistics_list.unwrap_or_default();
v.push(input);
self.column_statistics_list = Some(v);
self
}
/// <p>A list of the column statistics.</p>
pub fn set_column_statistics_list(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::ColumnStatistics>>,
) -> Self {
self.column_statistics_list = input;
self
}
/// Consumes the builder and constructs a [`UpdateColumnStatisticsForTableInput`](crate::input::UpdateColumnStatisticsForTableInput).
pub fn build(
self,
) -> Result<
crate::input::UpdateColumnStatisticsForTableInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::UpdateColumnStatisticsForTableInput {
catalog_id: self.catalog_id,
database_name: self.database_name,
table_name: self.table_name,
column_statistics_list: self.column_statistics_list,
})
}
}
}
impl UpdateColumnStatisticsForTableInput {
/// Consumes the builder and constructs an Operation<[`UpdateColumnStatisticsForTable`](crate::operation::UpdateColumnStatisticsForTable)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::UpdateColumnStatisticsForTable,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::UpdateColumnStatisticsForTableInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::UpdateColumnStatisticsForTableInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.UpdateColumnStatisticsForTable",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_update_column_statistics_for_table(&self)?
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::UpdateColumnStatisticsForTable::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"UpdateColumnStatisticsForTable",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`UpdateColumnStatisticsForTableInput`](crate::input::UpdateColumnStatisticsForTableInput).
pub fn builder() -> crate::input::update_column_statistics_for_table_input::Builder {
crate::input::update_column_statistics_for_table_input::Builder::default()
}
}
/// See [`UpdateConnectionInput`](crate::input::UpdateConnectionInput).
pub mod update_connection_input {
/// A builder for [`UpdateConnectionInput`](crate::input::UpdateConnectionInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) catalog_id: std::option::Option<std::string::String>,
pub(crate) name: std::option::Option<std::string::String>,
pub(crate) connection_input: std::option::Option<crate::model::ConnectionInput>,
}
impl Builder {
/// <p>The ID of the Data Catalog in which the connection resides. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(mut self, input: impl Into<std::string::String>) -> Self {
self.catalog_id = Some(input.into());
self
}
/// <p>The ID of the Data Catalog in which the connection resides. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn set_catalog_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.catalog_id = input;
self
}
/// <p>The name of the connection definition to update.</p>
pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
self.name = Some(input.into());
self
}
/// <p>The name of the connection definition to update.</p>
pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.name = input;
self
}
/// <p>A <code>ConnectionInput</code> object that redefines the connection in question.</p>
pub fn connection_input(mut self, input: crate::model::ConnectionInput) -> Self {
self.connection_input = Some(input);
self
}
/// <p>A <code>ConnectionInput</code> object that redefines the connection in question.</p>
pub fn set_connection_input(
mut self,
input: std::option::Option<crate::model::ConnectionInput>,
) -> Self {
self.connection_input = input;
self
}
/// Consumes the builder and constructs a [`UpdateConnectionInput`](crate::input::UpdateConnectionInput).
pub fn build(
self,
) -> Result<
crate::input::UpdateConnectionInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::UpdateConnectionInput {
catalog_id: self.catalog_id,
name: self.name,
connection_input: self.connection_input,
})
}
}
}
impl UpdateConnectionInput {
/// Consumes the builder and constructs an Operation<[`UpdateConnection`](crate::operation::UpdateConnection)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::UpdateConnection,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::UpdateConnectionInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::UpdateConnectionInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.UpdateConnection",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_update_connection(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::UpdateConnection::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"UpdateConnection",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`UpdateConnectionInput`](crate::input::UpdateConnectionInput).
pub fn builder() -> crate::input::update_connection_input::Builder {
crate::input::update_connection_input::Builder::default()
}
}
/// See [`UpdateCrawlerInput`](crate::input::UpdateCrawlerInput).
pub mod update_crawler_input {
/// A builder for [`UpdateCrawlerInput`](crate::input::UpdateCrawlerInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) name: std::option::Option<std::string::String>,
pub(crate) role: std::option::Option<std::string::String>,
pub(crate) database_name: std::option::Option<std::string::String>,
pub(crate) description: std::option::Option<std::string::String>,
pub(crate) targets: std::option::Option<crate::model::CrawlerTargets>,
pub(crate) schedule: std::option::Option<std::string::String>,
pub(crate) classifiers: std::option::Option<std::vec::Vec<std::string::String>>,
pub(crate) table_prefix: std::option::Option<std::string::String>,
pub(crate) schema_change_policy: std::option::Option<crate::model::SchemaChangePolicy>,
pub(crate) recrawl_policy: std::option::Option<crate::model::RecrawlPolicy>,
pub(crate) lineage_configuration: std::option::Option<crate::model::LineageConfiguration>,
pub(crate) lake_formation_configuration:
std::option::Option<crate::model::LakeFormationConfiguration>,
pub(crate) configuration: std::option::Option<std::string::String>,
pub(crate) crawler_security_configuration: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>Name of the new crawler.</p>
pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
self.name = Some(input.into());
self
}
/// <p>Name of the new crawler.</p>
pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.name = input;
self
}
/// <p>The IAM role or Amazon Resource Name (ARN) of an IAM role that is used by the new crawler to access customer resources.</p>
pub fn role(mut self, input: impl Into<std::string::String>) -> Self {
self.role = Some(input.into());
self
}
/// <p>The IAM role or Amazon Resource Name (ARN) of an IAM role that is used by the new crawler to access customer resources.</p>
pub fn set_role(mut self, input: std::option::Option<std::string::String>) -> Self {
self.role = input;
self
}
/// <p>The Glue database where results are stored, such as: <code>arn:aws:daylight:us-east-1::database/sometable/*</code>.</p>
pub fn database_name(mut self, input: impl Into<std::string::String>) -> Self {
self.database_name = Some(input.into());
self
}
/// <p>The Glue database where results are stored, such as: <code>arn:aws:daylight:us-east-1::database/sometable/*</code>.</p>
pub fn set_database_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.database_name = input;
self
}
/// <p>A description of the new crawler.</p>
pub fn description(mut self, input: impl Into<std::string::String>) -> Self {
self.description = Some(input.into());
self
}
/// <p>A description of the new crawler.</p>
pub fn set_description(mut self, input: std::option::Option<std::string::String>) -> Self {
self.description = input;
self
}
/// <p>A list of targets to crawl.</p>
pub fn targets(mut self, input: crate::model::CrawlerTargets) -> Self {
self.targets = Some(input);
self
}
/// <p>A list of targets to crawl.</p>
pub fn set_targets(
mut self,
input: std::option::Option<crate::model::CrawlerTargets>,
) -> Self {
self.targets = input;
self
}
/// <p>A <code>cron</code> expression used to specify the schedule (see <a href="https://docs.aws.amazon.com/glue/latest/dg/monitor-data-warehouse-schedule.html">Time-Based Schedules for Jobs and Crawlers</a>. For example, to run something every day at 12:15 UTC, you would specify: <code>cron(15 12 * * ? *)</code>.</p>
pub fn schedule(mut self, input: impl Into<std::string::String>) -> Self {
self.schedule = Some(input.into());
self
}
/// <p>A <code>cron</code> expression used to specify the schedule (see <a href="https://docs.aws.amazon.com/glue/latest/dg/monitor-data-warehouse-schedule.html">Time-Based Schedules for Jobs and Crawlers</a>. For example, to run something every day at 12:15 UTC, you would specify: <code>cron(15 12 * * ? *)</code>.</p>
pub fn set_schedule(mut self, input: std::option::Option<std::string::String>) -> Self {
self.schedule = input;
self
}
/// Appends an item to `classifiers`.
///
/// To override the contents of this collection use [`set_classifiers`](Self::set_classifiers).
///
/// <p>A list of custom classifiers that the user has registered. By default, all built-in classifiers are included in a crawl, but these custom classifiers always override the default classifiers for a given classification.</p>
pub fn classifiers(mut self, input: impl Into<std::string::String>) -> Self {
let mut v = self.classifiers.unwrap_or_default();
v.push(input.into());
self.classifiers = Some(v);
self
}
/// <p>A list of custom classifiers that the user has registered. By default, all built-in classifiers are included in a crawl, but these custom classifiers always override the default classifiers for a given classification.</p>
pub fn set_classifiers(
mut self,
input: std::option::Option<std::vec::Vec<std::string::String>>,
) -> Self {
self.classifiers = input;
self
}
/// <p>The table prefix used for catalog tables that are created.</p>
pub fn table_prefix(mut self, input: impl Into<std::string::String>) -> Self {
self.table_prefix = Some(input.into());
self
}
/// <p>The table prefix used for catalog tables that are created.</p>
pub fn set_table_prefix(mut self, input: std::option::Option<std::string::String>) -> Self {
self.table_prefix = input;
self
}
/// <p>The policy for the crawler's update and deletion behavior.</p>
pub fn schema_change_policy(mut self, input: crate::model::SchemaChangePolicy) -> Self {
self.schema_change_policy = Some(input);
self
}
/// <p>The policy for the crawler's update and deletion behavior.</p>
pub fn set_schema_change_policy(
mut self,
input: std::option::Option<crate::model::SchemaChangePolicy>,
) -> Self {
self.schema_change_policy = input;
self
}
/// <p>A policy that specifies whether to crawl the entire dataset again, or to crawl only folders that were added since the last crawler run.</p>
pub fn recrawl_policy(mut self, input: crate::model::RecrawlPolicy) -> Self {
self.recrawl_policy = Some(input);
self
}
/// <p>A policy that specifies whether to crawl the entire dataset again, or to crawl only folders that were added since the last crawler run.</p>
pub fn set_recrawl_policy(
mut self,
input: std::option::Option<crate::model::RecrawlPolicy>,
) -> Self {
self.recrawl_policy = input;
self
}
/// <p>Specifies data lineage configuration settings for the crawler.</p>
pub fn lineage_configuration(mut self, input: crate::model::LineageConfiguration) -> Self {
self.lineage_configuration = Some(input);
self
}
/// <p>Specifies data lineage configuration settings for the crawler.</p>
pub fn set_lineage_configuration(
mut self,
input: std::option::Option<crate::model::LineageConfiguration>,
) -> Self {
self.lineage_configuration = input;
self
}
/// <p>Specifies Lake Formation configuration settings for the crawler.</p>
pub fn lake_formation_configuration(
mut self,
input: crate::model::LakeFormationConfiguration,
) -> Self {
self.lake_formation_configuration = Some(input);
self
}
/// <p>Specifies Lake Formation configuration settings for the crawler.</p>
pub fn set_lake_formation_configuration(
mut self,
input: std::option::Option<crate::model::LakeFormationConfiguration>,
) -> Self {
self.lake_formation_configuration = input;
self
}
/// <p>Crawler configuration information. This versioned JSON string allows users to specify aspects of a crawler's behavior. For more information, see <a href="https://docs.aws.amazon.com/glue/latest/dg/crawler-configuration.html">Setting crawler configuration options</a>.</p>
pub fn configuration(mut self, input: impl Into<std::string::String>) -> Self {
self.configuration = Some(input.into());
self
}
/// <p>Crawler configuration information. This versioned JSON string allows users to specify aspects of a crawler's behavior. For more information, see <a href="https://docs.aws.amazon.com/glue/latest/dg/crawler-configuration.html">Setting crawler configuration options</a>.</p>
pub fn set_configuration(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.configuration = input;
self
}
/// <p>The name of the <code>SecurityConfiguration</code> structure to be used by this crawler.</p>
pub fn crawler_security_configuration(
mut self,
input: impl Into<std::string::String>,
) -> Self {
self.crawler_security_configuration = Some(input.into());
self
}
/// <p>The name of the <code>SecurityConfiguration</code> structure to be used by this crawler.</p>
pub fn set_crawler_security_configuration(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.crawler_security_configuration = input;
self
}
/// Consumes the builder and constructs a [`UpdateCrawlerInput`](crate::input::UpdateCrawlerInput).
pub fn build(
self,
) -> Result<crate::input::UpdateCrawlerInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::UpdateCrawlerInput {
name: self.name,
role: self.role,
database_name: self.database_name,
description: self.description,
targets: self.targets,
schedule: self.schedule,
classifiers: self.classifiers,
table_prefix: self.table_prefix,
schema_change_policy: self.schema_change_policy,
recrawl_policy: self.recrawl_policy,
lineage_configuration: self.lineage_configuration,
lake_formation_configuration: self.lake_formation_configuration,
configuration: self.configuration,
crawler_security_configuration: self.crawler_security_configuration,
})
}
}
}
impl UpdateCrawlerInput {
/// Consumes the builder and constructs an Operation<[`UpdateCrawler`](crate::operation::UpdateCrawler)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::UpdateCrawler,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::UpdateCrawlerInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::UpdateCrawlerInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.UpdateCrawler",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_update_crawler(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::UpdateCrawler::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"UpdateCrawler",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`UpdateCrawlerInput`](crate::input::UpdateCrawlerInput).
pub fn builder() -> crate::input::update_crawler_input::Builder {
crate::input::update_crawler_input::Builder::default()
}
}
/// See [`UpdateCrawlerScheduleInput`](crate::input::UpdateCrawlerScheduleInput).
pub mod update_crawler_schedule_input {
/// A builder for [`UpdateCrawlerScheduleInput`](crate::input::UpdateCrawlerScheduleInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) crawler_name: std::option::Option<std::string::String>,
pub(crate) schedule: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The name of the crawler whose schedule to update.</p>
pub fn crawler_name(mut self, input: impl Into<std::string::String>) -> Self {
self.crawler_name = Some(input.into());
self
}
/// <p>The name of the crawler whose schedule to update.</p>
pub fn set_crawler_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.crawler_name = input;
self
}
/// <p>The updated <code>cron</code> expression used to specify the schedule (see <a href="https://docs.aws.amazon.com/glue/latest/dg/monitor-data-warehouse-schedule.html">Time-Based Schedules for Jobs and Crawlers</a>. For example, to run something every day at 12:15 UTC, you would specify: <code>cron(15 12 * * ? *)</code>.</p>
pub fn schedule(mut self, input: impl Into<std::string::String>) -> Self {
self.schedule = Some(input.into());
self
}
/// <p>The updated <code>cron</code> expression used to specify the schedule (see <a href="https://docs.aws.amazon.com/glue/latest/dg/monitor-data-warehouse-schedule.html">Time-Based Schedules for Jobs and Crawlers</a>. For example, to run something every day at 12:15 UTC, you would specify: <code>cron(15 12 * * ? *)</code>.</p>
pub fn set_schedule(mut self, input: std::option::Option<std::string::String>) -> Self {
self.schedule = input;
self
}
/// Consumes the builder and constructs a [`UpdateCrawlerScheduleInput`](crate::input::UpdateCrawlerScheduleInput).
pub fn build(
self,
) -> Result<
crate::input::UpdateCrawlerScheduleInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::UpdateCrawlerScheduleInput {
crawler_name: self.crawler_name,
schedule: self.schedule,
})
}
}
}
impl UpdateCrawlerScheduleInput {
/// Consumes the builder and constructs an Operation<[`UpdateCrawlerSchedule`](crate::operation::UpdateCrawlerSchedule)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::UpdateCrawlerSchedule,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::UpdateCrawlerScheduleInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::UpdateCrawlerScheduleInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.UpdateCrawlerSchedule",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_update_crawler_schedule(
&self,
)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::UpdateCrawlerSchedule::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"UpdateCrawlerSchedule",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`UpdateCrawlerScheduleInput`](crate::input::UpdateCrawlerScheduleInput).
pub fn builder() -> crate::input::update_crawler_schedule_input::Builder {
crate::input::update_crawler_schedule_input::Builder::default()
}
}
/// See [`UpdateDatabaseInput`](crate::input::UpdateDatabaseInput).
pub mod update_database_input {
/// A builder for [`UpdateDatabaseInput`](crate::input::UpdateDatabaseInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) catalog_id: std::option::Option<std::string::String>,
pub(crate) name: std::option::Option<std::string::String>,
pub(crate) database_input: std::option::Option<crate::model::DatabaseInput>,
}
impl Builder {
/// <p>The ID of the Data Catalog in which the metadata database resides. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(mut self, input: impl Into<std::string::String>) -> Self {
self.catalog_id = Some(input.into());
self
}
/// <p>The ID of the Data Catalog in which the metadata database resides. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn set_catalog_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.catalog_id = input;
self
}
/// <p>The name of the database to update in the catalog. For Hive compatibility, this is folded to lowercase.</p>
pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
self.name = Some(input.into());
self
}
/// <p>The name of the database to update in the catalog. For Hive compatibility, this is folded to lowercase.</p>
pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.name = input;
self
}
/// <p>A <code>DatabaseInput</code> object specifying the new definition of the metadata database in the catalog.</p>
pub fn database_input(mut self, input: crate::model::DatabaseInput) -> Self {
self.database_input = Some(input);
self
}
/// <p>A <code>DatabaseInput</code> object specifying the new definition of the metadata database in the catalog.</p>
pub fn set_database_input(
mut self,
input: std::option::Option<crate::model::DatabaseInput>,
) -> Self {
self.database_input = input;
self
}
/// Consumes the builder and constructs a [`UpdateDatabaseInput`](crate::input::UpdateDatabaseInput).
pub fn build(
self,
) -> Result<crate::input::UpdateDatabaseInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::UpdateDatabaseInput {
catalog_id: self.catalog_id,
name: self.name,
database_input: self.database_input,
})
}
}
}
impl UpdateDatabaseInput {
/// Consumes the builder and constructs an Operation<[`UpdateDatabase`](crate::operation::UpdateDatabase)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::UpdateDatabase,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::UpdateDatabaseInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::UpdateDatabaseInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.UpdateDatabase",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_update_database(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::UpdateDatabase::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"UpdateDatabase",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`UpdateDatabaseInput`](crate::input::UpdateDatabaseInput).
pub fn builder() -> crate::input::update_database_input::Builder {
crate::input::update_database_input::Builder::default()
}
}
/// See [`UpdateDataQualityRulesetInput`](crate::input::UpdateDataQualityRulesetInput).
pub mod update_data_quality_ruleset_input {
/// A builder for [`UpdateDataQualityRulesetInput`](crate::input::UpdateDataQualityRulesetInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) name: std::option::Option<std::string::String>,
pub(crate) updated_name: std::option::Option<std::string::String>,
pub(crate) description: std::option::Option<std::string::String>,
pub(crate) ruleset: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The name of the data quality ruleset.</p>
pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
self.name = Some(input.into());
self
}
/// <p>The name of the data quality ruleset.</p>
pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.name = input;
self
}
/// <p>The new name of the ruleset, if you are renaming it.</p>
pub fn updated_name(mut self, input: impl Into<std::string::String>) -> Self {
self.updated_name = Some(input.into());
self
}
/// <p>The new name of the ruleset, if you are renaming it.</p>
pub fn set_updated_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.updated_name = input;
self
}
/// <p>A description of the ruleset.</p>
pub fn description(mut self, input: impl Into<std::string::String>) -> Self {
self.description = Some(input.into());
self
}
/// <p>A description of the ruleset.</p>
pub fn set_description(mut self, input: std::option::Option<std::string::String>) -> Self {
self.description = input;
self
}
/// <p>A Data Quality Definition Language (DQDL) ruleset. For more information, see the Glue developer guide.</p>
pub fn ruleset(mut self, input: impl Into<std::string::String>) -> Self {
self.ruleset = Some(input.into());
self
}
/// <p>A Data Quality Definition Language (DQDL) ruleset. For more information, see the Glue developer guide.</p>
pub fn set_ruleset(mut self, input: std::option::Option<std::string::String>) -> Self {
self.ruleset = input;
self
}
/// Consumes the builder and constructs a [`UpdateDataQualityRulesetInput`](crate::input::UpdateDataQualityRulesetInput).
pub fn build(
self,
) -> Result<
crate::input::UpdateDataQualityRulesetInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::UpdateDataQualityRulesetInput {
name: self.name,
updated_name: self.updated_name,
description: self.description,
ruleset: self.ruleset,
})
}
}
}
impl UpdateDataQualityRulesetInput {
/// Consumes the builder and constructs an Operation<[`UpdateDataQualityRuleset`](crate::operation::UpdateDataQualityRuleset)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::UpdateDataQualityRuleset,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::UpdateDataQualityRulesetInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::UpdateDataQualityRulesetInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.UpdateDataQualityRuleset",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_update_data_quality_ruleset(
&self,
)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::UpdateDataQualityRuleset::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"UpdateDataQualityRuleset",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`UpdateDataQualityRulesetInput`](crate::input::UpdateDataQualityRulesetInput).
pub fn builder() -> crate::input::update_data_quality_ruleset_input::Builder {
crate::input::update_data_quality_ruleset_input::Builder::default()
}
}
/// See [`UpdateDevEndpointInput`](crate::input::UpdateDevEndpointInput).
pub mod update_dev_endpoint_input {
/// A builder for [`UpdateDevEndpointInput`](crate::input::UpdateDevEndpointInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) endpoint_name: std::option::Option<std::string::String>,
pub(crate) public_key: std::option::Option<std::string::String>,
pub(crate) add_public_keys: std::option::Option<std::vec::Vec<std::string::String>>,
pub(crate) delete_public_keys: std::option::Option<std::vec::Vec<std::string::String>>,
pub(crate) custom_libraries: std::option::Option<crate::model::DevEndpointCustomLibraries>,
pub(crate) update_etl_libraries: std::option::Option<bool>,
pub(crate) delete_arguments: std::option::Option<std::vec::Vec<std::string::String>>,
pub(crate) add_arguments: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
}
impl Builder {
/// <p>The name of the <code>DevEndpoint</code> to be updated.</p>
pub fn endpoint_name(mut self, input: impl Into<std::string::String>) -> Self {
self.endpoint_name = Some(input.into());
self
}
/// <p>The name of the <code>DevEndpoint</code> to be updated.</p>
pub fn set_endpoint_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.endpoint_name = input;
self
}
/// <p>The public key for the <code>DevEndpoint</code> to use.</p>
pub fn public_key(mut self, input: impl Into<std::string::String>) -> Self {
self.public_key = Some(input.into());
self
}
/// <p>The public key for the <code>DevEndpoint</code> to use.</p>
pub fn set_public_key(mut self, input: std::option::Option<std::string::String>) -> Self {
self.public_key = input;
self
}
/// Appends an item to `add_public_keys`.
///
/// To override the contents of this collection use [`set_add_public_keys`](Self::set_add_public_keys).
///
/// <p>The list of public keys for the <code>DevEndpoint</code> to use.</p>
pub fn add_public_keys(mut self, input: impl Into<std::string::String>) -> Self {
let mut v = self.add_public_keys.unwrap_or_default();
v.push(input.into());
self.add_public_keys = Some(v);
self
}
/// <p>The list of public keys for the <code>DevEndpoint</code> to use.</p>
pub fn set_add_public_keys(
mut self,
input: std::option::Option<std::vec::Vec<std::string::String>>,
) -> Self {
self.add_public_keys = input;
self
}
/// Appends an item to `delete_public_keys`.
///
/// To override the contents of this collection use [`set_delete_public_keys`](Self::set_delete_public_keys).
///
/// <p>The list of public keys to be deleted from the <code>DevEndpoint</code>.</p>
pub fn delete_public_keys(mut self, input: impl Into<std::string::String>) -> Self {
let mut v = self.delete_public_keys.unwrap_or_default();
v.push(input.into());
self.delete_public_keys = Some(v);
self
}
/// <p>The list of public keys to be deleted from the <code>DevEndpoint</code>.</p>
pub fn set_delete_public_keys(
mut self,
input: std::option::Option<std::vec::Vec<std::string::String>>,
) -> Self {
self.delete_public_keys = input;
self
}
/// <p>Custom Python or Java libraries to be loaded in the <code>DevEndpoint</code>.</p>
pub fn custom_libraries(mut self, input: crate::model::DevEndpointCustomLibraries) -> Self {
self.custom_libraries = Some(input);
self
}
/// <p>Custom Python or Java libraries to be loaded in the <code>DevEndpoint</code>.</p>
pub fn set_custom_libraries(
mut self,
input: std::option::Option<crate::model::DevEndpointCustomLibraries>,
) -> Self {
self.custom_libraries = input;
self
}
/// <p> <code>True</code> if the list of custom libraries to be loaded in the development endpoint needs to be updated, or <code>False</code> if otherwise.</p>
pub fn update_etl_libraries(mut self, input: bool) -> Self {
self.update_etl_libraries = Some(input);
self
}
/// <p> <code>True</code> if the list of custom libraries to be loaded in the development endpoint needs to be updated, or <code>False</code> if otherwise.</p>
pub fn set_update_etl_libraries(mut self, input: std::option::Option<bool>) -> Self {
self.update_etl_libraries = input;
self
}
/// Appends an item to `delete_arguments`.
///
/// To override the contents of this collection use [`set_delete_arguments`](Self::set_delete_arguments).
///
/// <p>The list of argument keys to be deleted from the map of arguments used to configure the <code>DevEndpoint</code>.</p>
pub fn delete_arguments(mut self, input: impl Into<std::string::String>) -> Self {
let mut v = self.delete_arguments.unwrap_or_default();
v.push(input.into());
self.delete_arguments = Some(v);
self
}
/// <p>The list of argument keys to be deleted from the map of arguments used to configure the <code>DevEndpoint</code>.</p>
pub fn set_delete_arguments(
mut self,
input: std::option::Option<std::vec::Vec<std::string::String>>,
) -> Self {
self.delete_arguments = input;
self
}
/// Adds a key-value pair to `add_arguments`.
///
/// To override the contents of this collection use [`set_add_arguments`](Self::set_add_arguments).
///
/// <p>The map of arguments to add the map of arguments used to configure the <code>DevEndpoint</code>.</p>
/// <p>Valid arguments are:</p>
/// <ul>
/// <li> <p> <code>"--enable-glue-datacatalog": ""</code> </p> </li>
/// </ul>
/// <p>You can specify a version of Python support for development endpoints by using the <code>Arguments</code> parameter in the <code>CreateDevEndpoint</code> or <code>UpdateDevEndpoint</code> APIs. If no arguments are provided, the version defaults to Python 2.</p>
pub fn add_arguments(
mut self,
k: impl Into<std::string::String>,
v: impl Into<std::string::String>,
) -> Self {
let mut hash_map = self.add_arguments.unwrap_or_default();
hash_map.insert(k.into(), v.into());
self.add_arguments = Some(hash_map);
self
}
/// <p>The map of arguments to add the map of arguments used to configure the <code>DevEndpoint</code>.</p>
/// <p>Valid arguments are:</p>
/// <ul>
/// <li> <p> <code>"--enable-glue-datacatalog": ""</code> </p> </li>
/// </ul>
/// <p>You can specify a version of Python support for development endpoints by using the <code>Arguments</code> parameter in the <code>CreateDevEndpoint</code> or <code>UpdateDevEndpoint</code> APIs. If no arguments are provided, the version defaults to Python 2.</p>
pub fn set_add_arguments(
mut self,
input: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
) -> Self {
self.add_arguments = input;
self
}
/// Consumes the builder and constructs a [`UpdateDevEndpointInput`](crate::input::UpdateDevEndpointInput).
pub fn build(
self,
) -> Result<
crate::input::UpdateDevEndpointInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::UpdateDevEndpointInput {
endpoint_name: self.endpoint_name,
public_key: self.public_key,
add_public_keys: self.add_public_keys,
delete_public_keys: self.delete_public_keys,
custom_libraries: self.custom_libraries,
update_etl_libraries: self.update_etl_libraries.unwrap_or_default(),
delete_arguments: self.delete_arguments,
add_arguments: self.add_arguments,
})
}
}
}
impl UpdateDevEndpointInput {
/// Consumes the builder and constructs an Operation<[`UpdateDevEndpoint`](crate::operation::UpdateDevEndpoint)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::UpdateDevEndpoint,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::UpdateDevEndpointInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::UpdateDevEndpointInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.UpdateDevEndpoint",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_update_dev_endpoint(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::UpdateDevEndpoint::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"UpdateDevEndpoint",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`UpdateDevEndpointInput`](crate::input::UpdateDevEndpointInput).
pub fn builder() -> crate::input::update_dev_endpoint_input::Builder {
crate::input::update_dev_endpoint_input::Builder::default()
}
}
/// See [`UpdateJobInput`](crate::input::UpdateJobInput).
pub mod update_job_input {
/// A builder for [`UpdateJobInput`](crate::input::UpdateJobInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) job_name: std::option::Option<std::string::String>,
pub(crate) job_update: std::option::Option<crate::model::JobUpdate>,
}
impl Builder {
/// <p>The name of the job definition to update.</p>
pub fn job_name(mut self, input: impl Into<std::string::String>) -> Self {
self.job_name = Some(input.into());
self
}
/// <p>The name of the job definition to update.</p>
pub fn set_job_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.job_name = input;
self
}
/// <p>Specifies the values with which to update the job definition. Unspecified configuration is removed or reset to default values.</p>
pub fn job_update(mut self, input: crate::model::JobUpdate) -> Self {
self.job_update = Some(input);
self
}
/// <p>Specifies the values with which to update the job definition. Unspecified configuration is removed or reset to default values.</p>
pub fn set_job_update(
mut self,
input: std::option::Option<crate::model::JobUpdate>,
) -> Self {
self.job_update = input;
self
}
/// Consumes the builder and constructs a [`UpdateJobInput`](crate::input::UpdateJobInput).
pub fn build(
self,
) -> Result<crate::input::UpdateJobInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::UpdateJobInput {
job_name: self.job_name,
job_update: self.job_update,
})
}
}
}
impl UpdateJobInput {
/// Consumes the builder and constructs an Operation<[`UpdateJob`](crate::operation::UpdateJob)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::UpdateJob,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::UpdateJobInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::UpdateJobInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.UpdateJob",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_update_job(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op =
aws_smithy_http::operation::Operation::new(request, crate::operation::UpdateJob::new())
.with_metadata(aws_smithy_http::operation::Metadata::new(
"UpdateJob",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`UpdateJobInput`](crate::input::UpdateJobInput).
pub fn builder() -> crate::input::update_job_input::Builder {
crate::input::update_job_input::Builder::default()
}
}
/// See [`UpdateJobFromSourceControlInput`](crate::input::UpdateJobFromSourceControlInput).
pub mod update_job_from_source_control_input {
/// A builder for [`UpdateJobFromSourceControlInput`](crate::input::UpdateJobFromSourceControlInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) job_name: std::option::Option<std::string::String>,
pub(crate) provider: std::option::Option<crate::model::SourceControlProvider>,
pub(crate) repository_name: std::option::Option<std::string::String>,
pub(crate) repository_owner: std::option::Option<std::string::String>,
pub(crate) branch_name: std::option::Option<std::string::String>,
pub(crate) folder: std::option::Option<std::string::String>,
pub(crate) commit_id: std::option::Option<std::string::String>,
pub(crate) auth_strategy: std::option::Option<crate::model::SourceControlAuthStrategy>,
pub(crate) auth_token: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The name of the Glue job to be synchronized to or from the remote repository.</p>
pub fn job_name(mut self, input: impl Into<std::string::String>) -> Self {
self.job_name = Some(input.into());
self
}
/// <p>The name of the Glue job to be synchronized to or from the remote repository.</p>
pub fn set_job_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.job_name = input;
self
}
/// <p>The provider for the remote repository.</p>
pub fn provider(mut self, input: crate::model::SourceControlProvider) -> Self {
self.provider = Some(input);
self
}
/// <p>The provider for the remote repository.</p>
pub fn set_provider(
mut self,
input: std::option::Option<crate::model::SourceControlProvider>,
) -> Self {
self.provider = input;
self
}
/// <p>The name of the remote repository that contains the job artifacts.</p>
pub fn repository_name(mut self, input: impl Into<std::string::String>) -> Self {
self.repository_name = Some(input.into());
self
}
/// <p>The name of the remote repository that contains the job artifacts.</p>
pub fn set_repository_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.repository_name = input;
self
}
/// <p>The owner of the remote repository that contains the job artifacts.</p>
pub fn repository_owner(mut self, input: impl Into<std::string::String>) -> Self {
self.repository_owner = Some(input.into());
self
}
/// <p>The owner of the remote repository that contains the job artifacts.</p>
pub fn set_repository_owner(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.repository_owner = input;
self
}
/// <p>An optional branch in the remote repository.</p>
pub fn branch_name(mut self, input: impl Into<std::string::String>) -> Self {
self.branch_name = Some(input.into());
self
}
/// <p>An optional branch in the remote repository.</p>
pub fn set_branch_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.branch_name = input;
self
}
/// <p>An optional folder in the remote repository.</p>
pub fn folder(mut self, input: impl Into<std::string::String>) -> Self {
self.folder = Some(input.into());
self
}
/// <p>An optional folder in the remote repository.</p>
pub fn set_folder(mut self, input: std::option::Option<std::string::String>) -> Self {
self.folder = input;
self
}
/// <p>A commit ID for a commit in the remote repository.</p>
pub fn commit_id(mut self, input: impl Into<std::string::String>) -> Self {
self.commit_id = Some(input.into());
self
}
/// <p>A commit ID for a commit in the remote repository.</p>
pub fn set_commit_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.commit_id = input;
self
}
/// <p>The type of authentication, which can be an authentication token stored in Amazon Web Services Secrets Manager, or a personal access token.</p>
pub fn auth_strategy(mut self, input: crate::model::SourceControlAuthStrategy) -> Self {
self.auth_strategy = Some(input);
self
}
/// <p>The type of authentication, which can be an authentication token stored in Amazon Web Services Secrets Manager, or a personal access token.</p>
pub fn set_auth_strategy(
mut self,
input: std::option::Option<crate::model::SourceControlAuthStrategy>,
) -> Self {
self.auth_strategy = input;
self
}
/// <p>The value of the authorization token.</p>
pub fn auth_token(mut self, input: impl Into<std::string::String>) -> Self {
self.auth_token = Some(input.into());
self
}
/// <p>The value of the authorization token.</p>
pub fn set_auth_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.auth_token = input;
self
}
/// Consumes the builder and constructs a [`UpdateJobFromSourceControlInput`](crate::input::UpdateJobFromSourceControlInput).
pub fn build(
self,
) -> Result<
crate::input::UpdateJobFromSourceControlInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::UpdateJobFromSourceControlInput {
job_name: self.job_name,
provider: self.provider,
repository_name: self.repository_name,
repository_owner: self.repository_owner,
branch_name: self.branch_name,
folder: self.folder,
commit_id: self.commit_id,
auth_strategy: self.auth_strategy,
auth_token: self.auth_token,
})
}
}
}
impl UpdateJobFromSourceControlInput {
/// Consumes the builder and constructs an Operation<[`UpdateJobFromSourceControl`](crate::operation::UpdateJobFromSourceControl)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::UpdateJobFromSourceControl,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::UpdateJobFromSourceControlInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::UpdateJobFromSourceControlInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.UpdateJobFromSourceControl",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_update_job_from_source_control(&self)?
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::UpdateJobFromSourceControl::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"UpdateJobFromSourceControl",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`UpdateJobFromSourceControlInput`](crate::input::UpdateJobFromSourceControlInput).
pub fn builder() -> crate::input::update_job_from_source_control_input::Builder {
crate::input::update_job_from_source_control_input::Builder::default()
}
}
/// See [`UpdateMlTransformInput`](crate::input::UpdateMlTransformInput).
pub mod update_ml_transform_input {
/// A builder for [`UpdateMlTransformInput`](crate::input::UpdateMlTransformInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) transform_id: std::option::Option<std::string::String>,
pub(crate) name: std::option::Option<std::string::String>,
pub(crate) description: std::option::Option<std::string::String>,
pub(crate) parameters: std::option::Option<crate::model::TransformParameters>,
pub(crate) role: std::option::Option<std::string::String>,
pub(crate) glue_version: std::option::Option<std::string::String>,
pub(crate) max_capacity: std::option::Option<f64>,
pub(crate) worker_type: std::option::Option<crate::model::WorkerType>,
pub(crate) number_of_workers: std::option::Option<i32>,
pub(crate) timeout: std::option::Option<i32>,
pub(crate) max_retries: std::option::Option<i32>,
}
impl Builder {
/// <p>A unique identifier that was generated when the transform was created.</p>
pub fn transform_id(mut self, input: impl Into<std::string::String>) -> Self {
self.transform_id = Some(input.into());
self
}
/// <p>A unique identifier that was generated when the transform was created.</p>
pub fn set_transform_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.transform_id = input;
self
}
/// <p>The unique name that you gave the transform when you created it.</p>
pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
self.name = Some(input.into());
self
}
/// <p>The unique name that you gave the transform when you created it.</p>
pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.name = input;
self
}
/// <p>A description of the transform. The default is an empty string.</p>
pub fn description(mut self, input: impl Into<std::string::String>) -> Self {
self.description = Some(input.into());
self
}
/// <p>A description of the transform. The default is an empty string.</p>
pub fn set_description(mut self, input: std::option::Option<std::string::String>) -> Self {
self.description = input;
self
}
/// <p>The configuration parameters that are specific to the transform type (algorithm) used. Conditionally dependent on the transform type.</p>
pub fn parameters(mut self, input: crate::model::TransformParameters) -> Self {
self.parameters = Some(input);
self
}
/// <p>The configuration parameters that are specific to the transform type (algorithm) used. Conditionally dependent on the transform type.</p>
pub fn set_parameters(
mut self,
input: std::option::Option<crate::model::TransformParameters>,
) -> Self {
self.parameters = input;
self
}
/// <p>The name or Amazon Resource Name (ARN) of the IAM role with the required permissions.</p>
pub fn role(mut self, input: impl Into<std::string::String>) -> Self {
self.role = Some(input.into());
self
}
/// <p>The name or Amazon Resource Name (ARN) of the IAM role with the required permissions.</p>
pub fn set_role(mut self, input: std::option::Option<std::string::String>) -> Self {
self.role = input;
self
}
/// <p>This value determines which version of Glue this machine learning transform is compatible with. Glue 1.0 is recommended for most customers. If the value is not set, the Glue compatibility defaults to Glue 0.9. For more information, see <a href="https://docs.aws.amazon.com/glue/latest/dg/release-notes.html#release-notes-versions">Glue Versions</a> in the developer guide.</p>
pub fn glue_version(mut self, input: impl Into<std::string::String>) -> Self {
self.glue_version = Some(input.into());
self
}
/// <p>This value determines which version of Glue this machine learning transform is compatible with. Glue 1.0 is recommended for most customers. If the value is not set, the Glue compatibility defaults to Glue 0.9. For more information, see <a href="https://docs.aws.amazon.com/glue/latest/dg/release-notes.html#release-notes-versions">Glue Versions</a> in the developer guide.</p>
pub fn set_glue_version(mut self, input: std::option::Option<std::string::String>) -> Self {
self.glue_version = input;
self
}
/// <p>The number of Glue data processing units (DPUs) that are allocated to task runs for this transform. You can allocate from 2 to 100 DPUs; the default is 10. A DPU is a relative measure of processing power that consists of 4 vCPUs of compute capacity and 16 GB of memory. For more information, see the <a href="https://aws.amazon.com/glue/pricing/">Glue pricing page</a>. </p>
/// <p>When the <code>WorkerType</code> field is set to a value other than <code>Standard</code>, the <code>MaxCapacity</code> field is set automatically and becomes read-only.</p>
pub fn max_capacity(mut self, input: f64) -> Self {
self.max_capacity = Some(input);
self
}
/// <p>The number of Glue data processing units (DPUs) that are allocated to task runs for this transform. You can allocate from 2 to 100 DPUs; the default is 10. A DPU is a relative measure of processing power that consists of 4 vCPUs of compute capacity and 16 GB of memory. For more information, see the <a href="https://aws.amazon.com/glue/pricing/">Glue pricing page</a>. </p>
/// <p>When the <code>WorkerType</code> field is set to a value other than <code>Standard</code>, the <code>MaxCapacity</code> field is set automatically and becomes read-only.</p>
pub fn set_max_capacity(mut self, input: std::option::Option<f64>) -> Self {
self.max_capacity = input;
self
}
/// <p>The type of predefined worker that is allocated when this task runs. Accepts a value of Standard, G.1X, or G.2X.</p>
/// <ul>
/// <li> <p>For the <code>Standard</code> worker type, each worker provides 4 vCPU, 16 GB of memory and a 50GB disk, and 2 executors per worker.</p> </li>
/// <li> <p>For the <code>G.1X</code> worker type, each worker provides 4 vCPU, 16 GB of memory and a 64GB disk, and 1 executor per worker.</p> </li>
/// <li> <p>For the <code>G.2X</code> worker type, each worker provides 8 vCPU, 32 GB of memory and a 128GB disk, and 1 executor per worker.</p> </li>
/// </ul>
pub fn worker_type(mut self, input: crate::model::WorkerType) -> Self {
self.worker_type = Some(input);
self
}
/// <p>The type of predefined worker that is allocated when this task runs. Accepts a value of Standard, G.1X, or G.2X.</p>
/// <ul>
/// <li> <p>For the <code>Standard</code> worker type, each worker provides 4 vCPU, 16 GB of memory and a 50GB disk, and 2 executors per worker.</p> </li>
/// <li> <p>For the <code>G.1X</code> worker type, each worker provides 4 vCPU, 16 GB of memory and a 64GB disk, and 1 executor per worker.</p> </li>
/// <li> <p>For the <code>G.2X</code> worker type, each worker provides 8 vCPU, 32 GB of memory and a 128GB disk, and 1 executor per worker.</p> </li>
/// </ul>
pub fn set_worker_type(
mut self,
input: std::option::Option<crate::model::WorkerType>,
) -> Self {
self.worker_type = input;
self
}
/// <p>The number of workers of a defined <code>workerType</code> that are allocated when this task runs.</p>
pub fn number_of_workers(mut self, input: i32) -> Self {
self.number_of_workers = Some(input);
self
}
/// <p>The number of workers of a defined <code>workerType</code> that are allocated when this task runs.</p>
pub fn set_number_of_workers(mut self, input: std::option::Option<i32>) -> Self {
self.number_of_workers = input;
self
}
/// <p>The timeout for a task run for this transform in minutes. This is the maximum time that a task run for this transform can consume resources before it is terminated and enters <code>TIMEOUT</code> status. The default is 2,880 minutes (48 hours).</p>
pub fn timeout(mut self, input: i32) -> Self {
self.timeout = Some(input);
self
}
/// <p>The timeout for a task run for this transform in minutes. This is the maximum time that a task run for this transform can consume resources before it is terminated and enters <code>TIMEOUT</code> status. The default is 2,880 minutes (48 hours).</p>
pub fn set_timeout(mut self, input: std::option::Option<i32>) -> Self {
self.timeout = input;
self
}
/// <p>The maximum number of times to retry a task for this transform after a task run fails.</p>
pub fn max_retries(mut self, input: i32) -> Self {
self.max_retries = Some(input);
self
}
/// <p>The maximum number of times to retry a task for this transform after a task run fails.</p>
pub fn set_max_retries(mut self, input: std::option::Option<i32>) -> Self {
self.max_retries = input;
self
}
/// Consumes the builder and constructs a [`UpdateMlTransformInput`](crate::input::UpdateMlTransformInput).
pub fn build(
self,
) -> Result<
crate::input::UpdateMlTransformInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::UpdateMlTransformInput {
transform_id: self.transform_id,
name: self.name,
description: self.description,
parameters: self.parameters,
role: self.role,
glue_version: self.glue_version,
max_capacity: self.max_capacity,
worker_type: self.worker_type,
number_of_workers: self.number_of_workers,
timeout: self.timeout,
max_retries: self.max_retries,
})
}
}
}
impl UpdateMlTransformInput {
/// Consumes the builder and constructs an Operation<[`UpdateMLTransform`](crate::operation::UpdateMLTransform)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::UpdateMLTransform,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::UpdateMlTransformInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::UpdateMlTransformInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.UpdateMLTransform",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_update_ml_transform(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::UpdateMLTransform::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"UpdateMLTransform",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`UpdateMlTransformInput`](crate::input::UpdateMlTransformInput).
pub fn builder() -> crate::input::update_ml_transform_input::Builder {
crate::input::update_ml_transform_input::Builder::default()
}
}
/// See [`UpdatePartitionInput`](crate::input::UpdatePartitionInput).
pub mod update_partition_input {
/// A builder for [`UpdatePartitionInput`](crate::input::UpdatePartitionInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) catalog_id: std::option::Option<std::string::String>,
pub(crate) database_name: std::option::Option<std::string::String>,
pub(crate) table_name: std::option::Option<std::string::String>,
pub(crate) partition_value_list: std::option::Option<std::vec::Vec<std::string::String>>,
pub(crate) partition_input: std::option::Option<crate::model::PartitionInput>,
}
impl Builder {
/// <p>The ID of the Data Catalog where the partition to be updated resides. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(mut self, input: impl Into<std::string::String>) -> Self {
self.catalog_id = Some(input.into());
self
}
/// <p>The ID of the Data Catalog where the partition to be updated resides. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn set_catalog_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.catalog_id = input;
self
}
/// <p>The name of the catalog database in which the table in question resides.</p>
pub fn database_name(mut self, input: impl Into<std::string::String>) -> Self {
self.database_name = Some(input.into());
self
}
/// <p>The name of the catalog database in which the table in question resides.</p>
pub fn set_database_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.database_name = input;
self
}
/// <p>The name of the table in which the partition to be updated is located.</p>
pub fn table_name(mut self, input: impl Into<std::string::String>) -> Self {
self.table_name = Some(input.into());
self
}
/// <p>The name of the table in which the partition to be updated is located.</p>
pub fn set_table_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.table_name = input;
self
}
/// Appends an item to `partition_value_list`.
///
/// To override the contents of this collection use [`set_partition_value_list`](Self::set_partition_value_list).
///
/// <p>List of partition key values that define the partition to update.</p>
pub fn partition_value_list(mut self, input: impl Into<std::string::String>) -> Self {
let mut v = self.partition_value_list.unwrap_or_default();
v.push(input.into());
self.partition_value_list = Some(v);
self
}
/// <p>List of partition key values that define the partition to update.</p>
pub fn set_partition_value_list(
mut self,
input: std::option::Option<std::vec::Vec<std::string::String>>,
) -> Self {
self.partition_value_list = input;
self
}
/// <p>The new partition object to update the partition to.</p>
/// <p>The <code>Values</code> property can't be changed. If you want to change the partition key values for a partition, delete and recreate the partition.</p>
pub fn partition_input(mut self, input: crate::model::PartitionInput) -> Self {
self.partition_input = Some(input);
self
}
/// <p>The new partition object to update the partition to.</p>
/// <p>The <code>Values</code> property can't be changed. If you want to change the partition key values for a partition, delete and recreate the partition.</p>
pub fn set_partition_input(
mut self,
input: std::option::Option<crate::model::PartitionInput>,
) -> Self {
self.partition_input = input;
self
}
/// Consumes the builder and constructs a [`UpdatePartitionInput`](crate::input::UpdatePartitionInput).
pub fn build(
self,
) -> Result<crate::input::UpdatePartitionInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::UpdatePartitionInput {
catalog_id: self.catalog_id,
database_name: self.database_name,
table_name: self.table_name,
partition_value_list: self.partition_value_list,
partition_input: self.partition_input,
})
}
}
}
impl UpdatePartitionInput {
/// Consumes the builder and constructs an Operation<[`UpdatePartition`](crate::operation::UpdatePartition)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::UpdatePartition,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::UpdatePartitionInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::UpdatePartitionInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.UpdatePartition",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_update_partition(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::UpdatePartition::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"UpdatePartition",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`UpdatePartitionInput`](crate::input::UpdatePartitionInput).
pub fn builder() -> crate::input::update_partition_input::Builder {
crate::input::update_partition_input::Builder::default()
}
}
/// See [`UpdateRegistryInput`](crate::input::UpdateRegistryInput).
pub mod update_registry_input {
/// A builder for [`UpdateRegistryInput`](crate::input::UpdateRegistryInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) registry_id: std::option::Option<crate::model::RegistryId>,
pub(crate) description: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>This is a wrapper structure that may contain the registry name and Amazon Resource Name (ARN).</p>
pub fn registry_id(mut self, input: crate::model::RegistryId) -> Self {
self.registry_id = Some(input);
self
}
/// <p>This is a wrapper structure that may contain the registry name and Amazon Resource Name (ARN).</p>
pub fn set_registry_id(
mut self,
input: std::option::Option<crate::model::RegistryId>,
) -> Self {
self.registry_id = input;
self
}
/// <p>A description of the registry. If description is not provided, this field will not be updated.</p>
pub fn description(mut self, input: impl Into<std::string::String>) -> Self {
self.description = Some(input.into());
self
}
/// <p>A description of the registry. If description is not provided, this field will not be updated.</p>
pub fn set_description(mut self, input: std::option::Option<std::string::String>) -> Self {
self.description = input;
self
}
/// Consumes the builder and constructs a [`UpdateRegistryInput`](crate::input::UpdateRegistryInput).
pub fn build(
self,
) -> Result<crate::input::UpdateRegistryInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::UpdateRegistryInput {
registry_id: self.registry_id,
description: self.description,
})
}
}
}
impl UpdateRegistryInput {
/// Consumes the builder and constructs an Operation<[`UpdateRegistry`](crate::operation::UpdateRegistry)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::UpdateRegistry,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::UpdateRegistryInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::UpdateRegistryInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.UpdateRegistry",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_update_registry(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::UpdateRegistry::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"UpdateRegistry",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`UpdateRegistryInput`](crate::input::UpdateRegistryInput).
pub fn builder() -> crate::input::update_registry_input::Builder {
crate::input::update_registry_input::Builder::default()
}
}
/// See [`UpdateSchemaInput`](crate::input::UpdateSchemaInput).
pub mod update_schema_input {
/// A builder for [`UpdateSchemaInput`](crate::input::UpdateSchemaInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) schema_id: std::option::Option<crate::model::SchemaId>,
pub(crate) schema_version_number: std::option::Option<crate::model::SchemaVersionNumber>,
pub(crate) compatibility: std::option::Option<crate::model::Compatibility>,
pub(crate) description: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>This is a wrapper structure to contain schema identity fields. The structure contains:</p>
/// <ul>
/// <li> <p>SchemaId$SchemaArn: The Amazon Resource Name (ARN) of the schema. One of <code>SchemaArn</code> or <code>SchemaName</code> has to be provided.</p> </li>
/// <li> <p>SchemaId$SchemaName: The name of the schema. One of <code>SchemaArn</code> or <code>SchemaName</code> has to be provided.</p> </li>
/// </ul>
pub fn schema_id(mut self, input: crate::model::SchemaId) -> Self {
self.schema_id = Some(input);
self
}
/// <p>This is a wrapper structure to contain schema identity fields. The structure contains:</p>
/// <ul>
/// <li> <p>SchemaId$SchemaArn: The Amazon Resource Name (ARN) of the schema. One of <code>SchemaArn</code> or <code>SchemaName</code> has to be provided.</p> </li>
/// <li> <p>SchemaId$SchemaName: The name of the schema. One of <code>SchemaArn</code> or <code>SchemaName</code> has to be provided.</p> </li>
/// </ul>
pub fn set_schema_id(mut self, input: std::option::Option<crate::model::SchemaId>) -> Self {
self.schema_id = input;
self
}
/// <p>Version number required for check pointing. One of <code>VersionNumber</code> or <code>Compatibility</code> has to be provided.</p>
pub fn schema_version_number(mut self, input: crate::model::SchemaVersionNumber) -> Self {
self.schema_version_number = Some(input);
self
}
/// <p>Version number required for check pointing. One of <code>VersionNumber</code> or <code>Compatibility</code> has to be provided.</p>
pub fn set_schema_version_number(
mut self,
input: std::option::Option<crate::model::SchemaVersionNumber>,
) -> Self {
self.schema_version_number = input;
self
}
/// <p>The new compatibility setting for the schema.</p>
pub fn compatibility(mut self, input: crate::model::Compatibility) -> Self {
self.compatibility = Some(input);
self
}
/// <p>The new compatibility setting for the schema.</p>
pub fn set_compatibility(
mut self,
input: std::option::Option<crate::model::Compatibility>,
) -> Self {
self.compatibility = input;
self
}
/// <p>The new description for the schema.</p>
pub fn description(mut self, input: impl Into<std::string::String>) -> Self {
self.description = Some(input.into());
self
}
/// <p>The new description for the schema.</p>
pub fn set_description(mut self, input: std::option::Option<std::string::String>) -> Self {
self.description = input;
self
}
/// Consumes the builder and constructs a [`UpdateSchemaInput`](crate::input::UpdateSchemaInput).
pub fn build(
self,
) -> Result<crate::input::UpdateSchemaInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::UpdateSchemaInput {
schema_id: self.schema_id,
schema_version_number: self.schema_version_number,
compatibility: self.compatibility,
description: self.description,
})
}
}
}
impl UpdateSchemaInput {
/// Consumes the builder and constructs an Operation<[`UpdateSchema`](crate::operation::UpdateSchema)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::UpdateSchema,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::UpdateSchemaInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::UpdateSchemaInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.UpdateSchema",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_update_schema(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::UpdateSchema::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"UpdateSchema",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`UpdateSchemaInput`](crate::input::UpdateSchemaInput).
pub fn builder() -> crate::input::update_schema_input::Builder {
crate::input::update_schema_input::Builder::default()
}
}
/// See [`UpdateSourceControlFromJobInput`](crate::input::UpdateSourceControlFromJobInput).
pub mod update_source_control_from_job_input {
/// A builder for [`UpdateSourceControlFromJobInput`](crate::input::UpdateSourceControlFromJobInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) job_name: std::option::Option<std::string::String>,
pub(crate) provider: std::option::Option<crate::model::SourceControlProvider>,
pub(crate) repository_name: std::option::Option<std::string::String>,
pub(crate) repository_owner: std::option::Option<std::string::String>,
pub(crate) branch_name: std::option::Option<std::string::String>,
pub(crate) folder: std::option::Option<std::string::String>,
pub(crate) commit_id: std::option::Option<std::string::String>,
pub(crate) auth_strategy: std::option::Option<crate::model::SourceControlAuthStrategy>,
pub(crate) auth_token: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The name of the Glue job to be synchronized to or from the remote repository.</p>
pub fn job_name(mut self, input: impl Into<std::string::String>) -> Self {
self.job_name = Some(input.into());
self
}
/// <p>The name of the Glue job to be synchronized to or from the remote repository.</p>
pub fn set_job_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.job_name = input;
self
}
/// <p>The provider for the remote repository.</p>
pub fn provider(mut self, input: crate::model::SourceControlProvider) -> Self {
self.provider = Some(input);
self
}
/// <p>The provider for the remote repository.</p>
pub fn set_provider(
mut self,
input: std::option::Option<crate::model::SourceControlProvider>,
) -> Self {
self.provider = input;
self
}
/// <p>The name of the remote repository that contains the job artifacts.</p>
pub fn repository_name(mut self, input: impl Into<std::string::String>) -> Self {
self.repository_name = Some(input.into());
self
}
/// <p>The name of the remote repository that contains the job artifacts.</p>
pub fn set_repository_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.repository_name = input;
self
}
/// <p>The owner of the remote repository that contains the job artifacts.</p>
pub fn repository_owner(mut self, input: impl Into<std::string::String>) -> Self {
self.repository_owner = Some(input.into());
self
}
/// <p>The owner of the remote repository that contains the job artifacts.</p>
pub fn set_repository_owner(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.repository_owner = input;
self
}
/// <p>An optional branch in the remote repository.</p>
pub fn branch_name(mut self, input: impl Into<std::string::String>) -> Self {
self.branch_name = Some(input.into());
self
}
/// <p>An optional branch in the remote repository.</p>
pub fn set_branch_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.branch_name = input;
self
}
/// <p>An optional folder in the remote repository.</p>
pub fn folder(mut self, input: impl Into<std::string::String>) -> Self {
self.folder = Some(input.into());
self
}
/// <p>An optional folder in the remote repository.</p>
pub fn set_folder(mut self, input: std::option::Option<std::string::String>) -> Self {
self.folder = input;
self
}
/// <p>A commit ID for a commit in the remote repository.</p>
pub fn commit_id(mut self, input: impl Into<std::string::String>) -> Self {
self.commit_id = Some(input.into());
self
}
/// <p>A commit ID for a commit in the remote repository.</p>
pub fn set_commit_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.commit_id = input;
self
}
/// <p>The type of authentication, which can be an authentication token stored in Amazon Web Services Secrets Manager, or a personal access token.</p>
pub fn auth_strategy(mut self, input: crate::model::SourceControlAuthStrategy) -> Self {
self.auth_strategy = Some(input);
self
}
/// <p>The type of authentication, which can be an authentication token stored in Amazon Web Services Secrets Manager, or a personal access token.</p>
pub fn set_auth_strategy(
mut self,
input: std::option::Option<crate::model::SourceControlAuthStrategy>,
) -> Self {
self.auth_strategy = input;
self
}
/// <p>The value of the authorization token.</p>
pub fn auth_token(mut self, input: impl Into<std::string::String>) -> Self {
self.auth_token = Some(input.into());
self
}
/// <p>The value of the authorization token.</p>
pub fn set_auth_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.auth_token = input;
self
}
/// Consumes the builder and constructs a [`UpdateSourceControlFromJobInput`](crate::input::UpdateSourceControlFromJobInput).
pub fn build(
self,
) -> Result<
crate::input::UpdateSourceControlFromJobInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::UpdateSourceControlFromJobInput {
job_name: self.job_name,
provider: self.provider,
repository_name: self.repository_name,
repository_owner: self.repository_owner,
branch_name: self.branch_name,
folder: self.folder,
commit_id: self.commit_id,
auth_strategy: self.auth_strategy,
auth_token: self.auth_token,
})
}
}
}
impl UpdateSourceControlFromJobInput {
/// Consumes the builder and constructs an Operation<[`UpdateSourceControlFromJob`](crate::operation::UpdateSourceControlFromJob)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::UpdateSourceControlFromJob,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::UpdateSourceControlFromJobInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::UpdateSourceControlFromJobInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.UpdateSourceControlFromJob",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_update_source_control_from_job(&self)?
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::UpdateSourceControlFromJob::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"UpdateSourceControlFromJob",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`UpdateSourceControlFromJobInput`](crate::input::UpdateSourceControlFromJobInput).
pub fn builder() -> crate::input::update_source_control_from_job_input::Builder {
crate::input::update_source_control_from_job_input::Builder::default()
}
}
/// See [`UpdateTableInput`](crate::input::UpdateTableInput).
pub mod update_table_input {
/// A builder for [`UpdateTableInput`](crate::input::UpdateTableInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) catalog_id: std::option::Option<std::string::String>,
pub(crate) database_name: std::option::Option<std::string::String>,
pub(crate) table_input: std::option::Option<crate::model::TableInput>,
pub(crate) skip_archive: std::option::Option<bool>,
pub(crate) transaction_id: std::option::Option<std::string::String>,
pub(crate) version_id: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The ID of the Data Catalog where the table resides. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(mut self, input: impl Into<std::string::String>) -> Self {
self.catalog_id = Some(input.into());
self
}
/// <p>The ID of the Data Catalog where the table resides. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn set_catalog_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.catalog_id = input;
self
}
/// <p>The name of the catalog database in which the table resides. For Hive compatibility, this name is entirely lowercase.</p>
pub fn database_name(mut self, input: impl Into<std::string::String>) -> Self {
self.database_name = Some(input.into());
self
}
/// <p>The name of the catalog database in which the table resides. For Hive compatibility, this name is entirely lowercase.</p>
pub fn set_database_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.database_name = input;
self
}
/// <p>An updated <code>TableInput</code> object to define the metadata table in the catalog.</p>
pub fn table_input(mut self, input: crate::model::TableInput) -> Self {
self.table_input = Some(input);
self
}
/// <p>An updated <code>TableInput</code> object to define the metadata table in the catalog.</p>
pub fn set_table_input(
mut self,
input: std::option::Option<crate::model::TableInput>,
) -> Self {
self.table_input = input;
self
}
/// <p>By default, <code>UpdateTable</code> always creates an archived version of the table before updating it. However, if <code>skipArchive</code> is set to true, <code>UpdateTable</code> does not create the archived version.</p>
pub fn skip_archive(mut self, input: bool) -> Self {
self.skip_archive = Some(input);
self
}
/// <p>By default, <code>UpdateTable</code> always creates an archived version of the table before updating it. However, if <code>skipArchive</code> is set to true, <code>UpdateTable</code> does not create the archived version.</p>
pub fn set_skip_archive(mut self, input: std::option::Option<bool>) -> Self {
self.skip_archive = input;
self
}
/// <p>The transaction ID at which to update the table contents. </p>
pub fn transaction_id(mut self, input: impl Into<std::string::String>) -> Self {
self.transaction_id = Some(input.into());
self
}
/// <p>The transaction ID at which to update the table contents. </p>
pub fn set_transaction_id(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.transaction_id = input;
self
}
/// <p>The version ID at which to update the table contents. </p>
pub fn version_id(mut self, input: impl Into<std::string::String>) -> Self {
self.version_id = Some(input.into());
self
}
/// <p>The version ID at which to update the table contents. </p>
pub fn set_version_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.version_id = input;
self
}
/// Consumes the builder and constructs a [`UpdateTableInput`](crate::input::UpdateTableInput).
pub fn build(
self,
) -> Result<crate::input::UpdateTableInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::UpdateTableInput {
catalog_id: self.catalog_id,
database_name: self.database_name,
table_input: self.table_input,
skip_archive: self.skip_archive,
transaction_id: self.transaction_id,
version_id: self.version_id,
})
}
}
}
impl UpdateTableInput {
/// Consumes the builder and constructs an Operation<[`UpdateTable`](crate::operation::UpdateTable)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::UpdateTable,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::UpdateTableInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::UpdateTableInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.UpdateTable",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_update_table(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::UpdateTable::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"UpdateTable",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`UpdateTableInput`](crate::input::UpdateTableInput).
pub fn builder() -> crate::input::update_table_input::Builder {
crate::input::update_table_input::Builder::default()
}
}
/// See [`UpdateTriggerInput`](crate::input::UpdateTriggerInput).
pub mod update_trigger_input {
/// A builder for [`UpdateTriggerInput`](crate::input::UpdateTriggerInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) name: std::option::Option<std::string::String>,
pub(crate) trigger_update: std::option::Option<crate::model::TriggerUpdate>,
}
impl Builder {
/// <p>The name of the trigger to update.</p>
pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
self.name = Some(input.into());
self
}
/// <p>The name of the trigger to update.</p>
pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.name = input;
self
}
/// <p>The new values with which to update the trigger.</p>
pub fn trigger_update(mut self, input: crate::model::TriggerUpdate) -> Self {
self.trigger_update = Some(input);
self
}
/// <p>The new values with which to update the trigger.</p>
pub fn set_trigger_update(
mut self,
input: std::option::Option<crate::model::TriggerUpdate>,
) -> Self {
self.trigger_update = input;
self
}
/// Consumes the builder and constructs a [`UpdateTriggerInput`](crate::input::UpdateTriggerInput).
pub fn build(
self,
) -> Result<crate::input::UpdateTriggerInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::UpdateTriggerInput {
name: self.name,
trigger_update: self.trigger_update,
})
}
}
}
impl UpdateTriggerInput {
/// Consumes the builder and constructs an Operation<[`UpdateTrigger`](crate::operation::UpdateTrigger)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::UpdateTrigger,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::UpdateTriggerInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::UpdateTriggerInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.UpdateTrigger",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_update_trigger(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::UpdateTrigger::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"UpdateTrigger",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`UpdateTriggerInput`](crate::input::UpdateTriggerInput).
pub fn builder() -> crate::input::update_trigger_input::Builder {
crate::input::update_trigger_input::Builder::default()
}
}
/// See [`UpdateUserDefinedFunctionInput`](crate::input::UpdateUserDefinedFunctionInput).
pub mod update_user_defined_function_input {
/// A builder for [`UpdateUserDefinedFunctionInput`](crate::input::UpdateUserDefinedFunctionInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) catalog_id: std::option::Option<std::string::String>,
pub(crate) database_name: std::option::Option<std::string::String>,
pub(crate) function_name: std::option::Option<std::string::String>,
pub(crate) function_input: std::option::Option<crate::model::UserDefinedFunctionInput>,
}
impl Builder {
/// <p>The ID of the Data Catalog where the function to be updated is located. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(mut self, input: impl Into<std::string::String>) -> Self {
self.catalog_id = Some(input.into());
self
}
/// <p>The ID of the Data Catalog where the function to be updated is located. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn set_catalog_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.catalog_id = input;
self
}
/// <p>The name of the catalog database where the function to be updated is located.</p>
pub fn database_name(mut self, input: impl Into<std::string::String>) -> Self {
self.database_name = Some(input.into());
self
}
/// <p>The name of the catalog database where the function to be updated is located.</p>
pub fn set_database_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.database_name = input;
self
}
/// <p>The name of the function.</p>
pub fn function_name(mut self, input: impl Into<std::string::String>) -> Self {
self.function_name = Some(input.into());
self
}
/// <p>The name of the function.</p>
pub fn set_function_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.function_name = input;
self
}
/// <p>A <code>FunctionInput</code> object that redefines the function in the Data Catalog.</p>
pub fn function_input(mut self, input: crate::model::UserDefinedFunctionInput) -> Self {
self.function_input = Some(input);
self
}
/// <p>A <code>FunctionInput</code> object that redefines the function in the Data Catalog.</p>
pub fn set_function_input(
mut self,
input: std::option::Option<crate::model::UserDefinedFunctionInput>,
) -> Self {
self.function_input = input;
self
}
/// Consumes the builder and constructs a [`UpdateUserDefinedFunctionInput`](crate::input::UpdateUserDefinedFunctionInput).
pub fn build(
self,
) -> Result<
crate::input::UpdateUserDefinedFunctionInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::UpdateUserDefinedFunctionInput {
catalog_id: self.catalog_id,
database_name: self.database_name,
function_name: self.function_name,
function_input: self.function_input,
})
}
}
}
impl UpdateUserDefinedFunctionInput {
/// Consumes the builder and constructs an Operation<[`UpdateUserDefinedFunction`](crate::operation::UpdateUserDefinedFunction)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::UpdateUserDefinedFunction,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::UpdateUserDefinedFunctionInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::UpdateUserDefinedFunctionInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.UpdateUserDefinedFunction",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_update_user_defined_function(
&self,
)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::UpdateUserDefinedFunction::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"UpdateUserDefinedFunction",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`UpdateUserDefinedFunctionInput`](crate::input::UpdateUserDefinedFunctionInput).
pub fn builder() -> crate::input::update_user_defined_function_input::Builder {
crate::input::update_user_defined_function_input::Builder::default()
}
}
/// See [`UpdateWorkflowInput`](crate::input::UpdateWorkflowInput).
pub mod update_workflow_input {
/// A builder for [`UpdateWorkflowInput`](crate::input::UpdateWorkflowInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) name: std::option::Option<std::string::String>,
pub(crate) description: std::option::Option<std::string::String>,
pub(crate) default_run_properties: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
pub(crate) max_concurrent_runs: std::option::Option<i32>,
}
impl Builder {
/// <p>Name of the workflow to be updated.</p>
pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
self.name = Some(input.into());
self
}
/// <p>Name of the workflow to be updated.</p>
pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.name = input;
self
}
/// <p>The description of the workflow.</p>
pub fn description(mut self, input: impl Into<std::string::String>) -> Self {
self.description = Some(input.into());
self
}
/// <p>The description of the workflow.</p>
pub fn set_description(mut self, input: std::option::Option<std::string::String>) -> Self {
self.description = input;
self
}
/// Adds a key-value pair to `default_run_properties`.
///
/// To override the contents of this collection use [`set_default_run_properties`](Self::set_default_run_properties).
///
/// <p>A collection of properties to be used as part of each execution of the workflow.</p>
pub fn default_run_properties(
mut self,
k: impl Into<std::string::String>,
v: impl Into<std::string::String>,
) -> Self {
let mut hash_map = self.default_run_properties.unwrap_or_default();
hash_map.insert(k.into(), v.into());
self.default_run_properties = Some(hash_map);
self
}
/// <p>A collection of properties to be used as part of each execution of the workflow.</p>
pub fn set_default_run_properties(
mut self,
input: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
) -> Self {
self.default_run_properties = input;
self
}
/// <p>You can use this parameter to prevent unwanted multiple updates to data, to control costs, or in some cases, to prevent exceeding the maximum number of concurrent runs of any of the component jobs. If you leave this parameter blank, there is no limit to the number of concurrent workflow runs.</p>
pub fn max_concurrent_runs(mut self, input: i32) -> Self {
self.max_concurrent_runs = Some(input);
self
}
/// <p>You can use this parameter to prevent unwanted multiple updates to data, to control costs, or in some cases, to prevent exceeding the maximum number of concurrent runs of any of the component jobs. If you leave this parameter blank, there is no limit to the number of concurrent workflow runs.</p>
pub fn set_max_concurrent_runs(mut self, input: std::option::Option<i32>) -> Self {
self.max_concurrent_runs = input;
self
}
/// Consumes the builder and constructs a [`UpdateWorkflowInput`](crate::input::UpdateWorkflowInput).
pub fn build(
self,
) -> Result<crate::input::UpdateWorkflowInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::UpdateWorkflowInput {
name: self.name,
description: self.description,
default_run_properties: self.default_run_properties,
max_concurrent_runs: self.max_concurrent_runs,
})
}
}
}
impl UpdateWorkflowInput {
/// Consumes the builder and constructs an Operation<[`UpdateWorkflow`](crate::operation::UpdateWorkflow)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::UpdateWorkflow,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::UpdateWorkflowInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::UpdateWorkflowInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"AWSGlue.UpdateWorkflow",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_update_workflow(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::UpdateWorkflow::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"UpdateWorkflow",
"glue",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`UpdateWorkflowInput`](crate::input::UpdateWorkflowInput).
pub fn builder() -> crate::input::update_workflow_input::Builder {
crate::input::update_workflow_input::Builder::default()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UpdateWorkflowInput {
/// <p>Name of the workflow to be updated.</p>
#[doc(hidden)]
pub name: std::option::Option<std::string::String>,
/// <p>The description of the workflow.</p>
#[doc(hidden)]
pub description: std::option::Option<std::string::String>,
/// <p>A collection of properties to be used as part of each execution of the workflow.</p>
#[doc(hidden)]
pub default_run_properties:
std::option::Option<std::collections::HashMap<std::string::String, std::string::String>>,
/// <p>You can use this parameter to prevent unwanted multiple updates to data, to control costs, or in some cases, to prevent exceeding the maximum number of concurrent runs of any of the component jobs. If you leave this parameter blank, there is no limit to the number of concurrent workflow runs.</p>
#[doc(hidden)]
pub max_concurrent_runs: std::option::Option<i32>,
}
impl UpdateWorkflowInput {
/// <p>Name of the workflow to be updated.</p>
pub fn name(&self) -> std::option::Option<&str> {
self.name.as_deref()
}
/// <p>The description of the workflow.</p>
pub fn description(&self) -> std::option::Option<&str> {
self.description.as_deref()
}
/// <p>A collection of properties to be used as part of each execution of the workflow.</p>
pub fn default_run_properties(
&self,
) -> std::option::Option<&std::collections::HashMap<std::string::String, std::string::String>>
{
self.default_run_properties.as_ref()
}
/// <p>You can use this parameter to prevent unwanted multiple updates to data, to control costs, or in some cases, to prevent exceeding the maximum number of concurrent runs of any of the component jobs. If you leave this parameter blank, there is no limit to the number of concurrent workflow runs.</p>
pub fn max_concurrent_runs(&self) -> std::option::Option<i32> {
self.max_concurrent_runs
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UpdateUserDefinedFunctionInput {
/// <p>The ID of the Data Catalog where the function to be updated is located. If none is provided, the Amazon Web Services account ID is used by default.</p>
#[doc(hidden)]
pub catalog_id: std::option::Option<std::string::String>,
/// <p>The name of the catalog database where the function to be updated is located.</p>
#[doc(hidden)]
pub database_name: std::option::Option<std::string::String>,
/// <p>The name of the function.</p>
#[doc(hidden)]
pub function_name: std::option::Option<std::string::String>,
/// <p>A <code>FunctionInput</code> object that redefines the function in the Data Catalog.</p>
#[doc(hidden)]
pub function_input: std::option::Option<crate::model::UserDefinedFunctionInput>,
}
impl UpdateUserDefinedFunctionInput {
/// <p>The ID of the Data Catalog where the function to be updated is located. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(&self) -> std::option::Option<&str> {
self.catalog_id.as_deref()
}
/// <p>The name of the catalog database where the function to be updated is located.</p>
pub fn database_name(&self) -> std::option::Option<&str> {
self.database_name.as_deref()
}
/// <p>The name of the function.</p>
pub fn function_name(&self) -> std::option::Option<&str> {
self.function_name.as_deref()
}
/// <p>A <code>FunctionInput</code> object that redefines the function in the Data Catalog.</p>
pub fn function_input(&self) -> std::option::Option<&crate::model::UserDefinedFunctionInput> {
self.function_input.as_ref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UpdateTriggerInput {
/// <p>The name of the trigger to update.</p>
#[doc(hidden)]
pub name: std::option::Option<std::string::String>,
/// <p>The new values with which to update the trigger.</p>
#[doc(hidden)]
pub trigger_update: std::option::Option<crate::model::TriggerUpdate>,
}
impl UpdateTriggerInput {
/// <p>The name of the trigger to update.</p>
pub fn name(&self) -> std::option::Option<&str> {
self.name.as_deref()
}
/// <p>The new values with which to update the trigger.</p>
pub fn trigger_update(&self) -> std::option::Option<&crate::model::TriggerUpdate> {
self.trigger_update.as_ref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UpdateTableInput {
/// <p>The ID of the Data Catalog where the table resides. If none is provided, the Amazon Web Services account ID is used by default.</p>
#[doc(hidden)]
pub catalog_id: std::option::Option<std::string::String>,
/// <p>The name of the catalog database in which the table resides. For Hive compatibility, this name is entirely lowercase.</p>
#[doc(hidden)]
pub database_name: std::option::Option<std::string::String>,
/// <p>An updated <code>TableInput</code> object to define the metadata table in the catalog.</p>
#[doc(hidden)]
pub table_input: std::option::Option<crate::model::TableInput>,
/// <p>By default, <code>UpdateTable</code> always creates an archived version of the table before updating it. However, if <code>skipArchive</code> is set to true, <code>UpdateTable</code> does not create the archived version.</p>
#[doc(hidden)]
pub skip_archive: std::option::Option<bool>,
/// <p>The transaction ID at which to update the table contents. </p>
#[doc(hidden)]
pub transaction_id: std::option::Option<std::string::String>,
/// <p>The version ID at which to update the table contents. </p>
#[doc(hidden)]
pub version_id: std::option::Option<std::string::String>,
}
impl UpdateTableInput {
/// <p>The ID of the Data Catalog where the table resides. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(&self) -> std::option::Option<&str> {
self.catalog_id.as_deref()
}
/// <p>The name of the catalog database in which the table resides. For Hive compatibility, this name is entirely lowercase.</p>
pub fn database_name(&self) -> std::option::Option<&str> {
self.database_name.as_deref()
}
/// <p>An updated <code>TableInput</code> object to define the metadata table in the catalog.</p>
pub fn table_input(&self) -> std::option::Option<&crate::model::TableInput> {
self.table_input.as_ref()
}
/// <p>By default, <code>UpdateTable</code> always creates an archived version of the table before updating it. However, if <code>skipArchive</code> is set to true, <code>UpdateTable</code> does not create the archived version.</p>
pub fn skip_archive(&self) -> std::option::Option<bool> {
self.skip_archive
}
/// <p>The transaction ID at which to update the table contents. </p>
pub fn transaction_id(&self) -> std::option::Option<&str> {
self.transaction_id.as_deref()
}
/// <p>The version ID at which to update the table contents. </p>
pub fn version_id(&self) -> std::option::Option<&str> {
self.version_id.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UpdateSourceControlFromJobInput {
/// <p>The name of the Glue job to be synchronized to or from the remote repository.</p>
#[doc(hidden)]
pub job_name: std::option::Option<std::string::String>,
/// <p>The provider for the remote repository.</p>
#[doc(hidden)]
pub provider: std::option::Option<crate::model::SourceControlProvider>,
/// <p>The name of the remote repository that contains the job artifacts.</p>
#[doc(hidden)]
pub repository_name: std::option::Option<std::string::String>,
/// <p>The owner of the remote repository that contains the job artifacts.</p>
#[doc(hidden)]
pub repository_owner: std::option::Option<std::string::String>,
/// <p>An optional branch in the remote repository.</p>
#[doc(hidden)]
pub branch_name: std::option::Option<std::string::String>,
/// <p>An optional folder in the remote repository.</p>
#[doc(hidden)]
pub folder: std::option::Option<std::string::String>,
/// <p>A commit ID for a commit in the remote repository.</p>
#[doc(hidden)]
pub commit_id: std::option::Option<std::string::String>,
/// <p>The type of authentication, which can be an authentication token stored in Amazon Web Services Secrets Manager, or a personal access token.</p>
#[doc(hidden)]
pub auth_strategy: std::option::Option<crate::model::SourceControlAuthStrategy>,
/// <p>The value of the authorization token.</p>
#[doc(hidden)]
pub auth_token: std::option::Option<std::string::String>,
}
impl UpdateSourceControlFromJobInput {
/// <p>The name of the Glue job to be synchronized to or from the remote repository.</p>
pub fn job_name(&self) -> std::option::Option<&str> {
self.job_name.as_deref()
}
/// <p>The provider for the remote repository.</p>
pub fn provider(&self) -> std::option::Option<&crate::model::SourceControlProvider> {
self.provider.as_ref()
}
/// <p>The name of the remote repository that contains the job artifacts.</p>
pub fn repository_name(&self) -> std::option::Option<&str> {
self.repository_name.as_deref()
}
/// <p>The owner of the remote repository that contains the job artifacts.</p>
pub fn repository_owner(&self) -> std::option::Option<&str> {
self.repository_owner.as_deref()
}
/// <p>An optional branch in the remote repository.</p>
pub fn branch_name(&self) -> std::option::Option<&str> {
self.branch_name.as_deref()
}
/// <p>An optional folder in the remote repository.</p>
pub fn folder(&self) -> std::option::Option<&str> {
self.folder.as_deref()
}
/// <p>A commit ID for a commit in the remote repository.</p>
pub fn commit_id(&self) -> std::option::Option<&str> {
self.commit_id.as_deref()
}
/// <p>The type of authentication, which can be an authentication token stored in Amazon Web Services Secrets Manager, or a personal access token.</p>
pub fn auth_strategy(&self) -> std::option::Option<&crate::model::SourceControlAuthStrategy> {
self.auth_strategy.as_ref()
}
/// <p>The value of the authorization token.</p>
pub fn auth_token(&self) -> std::option::Option<&str> {
self.auth_token.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UpdateSchemaInput {
/// <p>This is a wrapper structure to contain schema identity fields. The structure contains:</p>
/// <ul>
/// <li> <p>SchemaId$SchemaArn: The Amazon Resource Name (ARN) of the schema. One of <code>SchemaArn</code> or <code>SchemaName</code> has to be provided.</p> </li>
/// <li> <p>SchemaId$SchemaName: The name of the schema. One of <code>SchemaArn</code> or <code>SchemaName</code> has to be provided.</p> </li>
/// </ul>
#[doc(hidden)]
pub schema_id: std::option::Option<crate::model::SchemaId>,
/// <p>Version number required for check pointing. One of <code>VersionNumber</code> or <code>Compatibility</code> has to be provided.</p>
#[doc(hidden)]
pub schema_version_number: std::option::Option<crate::model::SchemaVersionNumber>,
/// <p>The new compatibility setting for the schema.</p>
#[doc(hidden)]
pub compatibility: std::option::Option<crate::model::Compatibility>,
/// <p>The new description for the schema.</p>
#[doc(hidden)]
pub description: std::option::Option<std::string::String>,
}
impl UpdateSchemaInput {
/// <p>This is a wrapper structure to contain schema identity fields. The structure contains:</p>
/// <ul>
/// <li> <p>SchemaId$SchemaArn: The Amazon Resource Name (ARN) of the schema. One of <code>SchemaArn</code> or <code>SchemaName</code> has to be provided.</p> </li>
/// <li> <p>SchemaId$SchemaName: The name of the schema. One of <code>SchemaArn</code> or <code>SchemaName</code> has to be provided.</p> </li>
/// </ul>
pub fn schema_id(&self) -> std::option::Option<&crate::model::SchemaId> {
self.schema_id.as_ref()
}
/// <p>Version number required for check pointing. One of <code>VersionNumber</code> or <code>Compatibility</code> has to be provided.</p>
pub fn schema_version_number(&self) -> std::option::Option<&crate::model::SchemaVersionNumber> {
self.schema_version_number.as_ref()
}
/// <p>The new compatibility setting for the schema.</p>
pub fn compatibility(&self) -> std::option::Option<&crate::model::Compatibility> {
self.compatibility.as_ref()
}
/// <p>The new description for the schema.</p>
pub fn description(&self) -> std::option::Option<&str> {
self.description.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UpdateRegistryInput {
/// <p>This is a wrapper structure that may contain the registry name and Amazon Resource Name (ARN).</p>
#[doc(hidden)]
pub registry_id: std::option::Option<crate::model::RegistryId>,
/// <p>A description of the registry. If description is not provided, this field will not be updated.</p>
#[doc(hidden)]
pub description: std::option::Option<std::string::String>,
}
impl UpdateRegistryInput {
/// <p>This is a wrapper structure that may contain the registry name and Amazon Resource Name (ARN).</p>
pub fn registry_id(&self) -> std::option::Option<&crate::model::RegistryId> {
self.registry_id.as_ref()
}
/// <p>A description of the registry. If description is not provided, this field will not be updated.</p>
pub fn description(&self) -> std::option::Option<&str> {
self.description.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UpdatePartitionInput {
/// <p>The ID of the Data Catalog where the partition to be updated resides. If none is provided, the Amazon Web Services account ID is used by default.</p>
#[doc(hidden)]
pub catalog_id: std::option::Option<std::string::String>,
/// <p>The name of the catalog database in which the table in question resides.</p>
#[doc(hidden)]
pub database_name: std::option::Option<std::string::String>,
/// <p>The name of the table in which the partition to be updated is located.</p>
#[doc(hidden)]
pub table_name: std::option::Option<std::string::String>,
/// <p>List of partition key values that define the partition to update.</p>
#[doc(hidden)]
pub partition_value_list: std::option::Option<std::vec::Vec<std::string::String>>,
/// <p>The new partition object to update the partition to.</p>
/// <p>The <code>Values</code> property can't be changed. If you want to change the partition key values for a partition, delete and recreate the partition.</p>
#[doc(hidden)]
pub partition_input: std::option::Option<crate::model::PartitionInput>,
}
impl UpdatePartitionInput {
/// <p>The ID of the Data Catalog where the partition to be updated resides. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(&self) -> std::option::Option<&str> {
self.catalog_id.as_deref()
}
/// <p>The name of the catalog database in which the table in question resides.</p>
pub fn database_name(&self) -> std::option::Option<&str> {
self.database_name.as_deref()
}
/// <p>The name of the table in which the partition to be updated is located.</p>
pub fn table_name(&self) -> std::option::Option<&str> {
self.table_name.as_deref()
}
/// <p>List of partition key values that define the partition to update.</p>
pub fn partition_value_list(&self) -> std::option::Option<&[std::string::String]> {
self.partition_value_list.as_deref()
}
/// <p>The new partition object to update the partition to.</p>
/// <p>The <code>Values</code> property can't be changed. If you want to change the partition key values for a partition, delete and recreate the partition.</p>
pub fn partition_input(&self) -> std::option::Option<&crate::model::PartitionInput> {
self.partition_input.as_ref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UpdateMlTransformInput {
/// <p>A unique identifier that was generated when the transform was created.</p>
#[doc(hidden)]
pub transform_id: std::option::Option<std::string::String>,
/// <p>The unique name that you gave the transform when you created it.</p>
#[doc(hidden)]
pub name: std::option::Option<std::string::String>,
/// <p>A description of the transform. The default is an empty string.</p>
#[doc(hidden)]
pub description: std::option::Option<std::string::String>,
/// <p>The configuration parameters that are specific to the transform type (algorithm) used. Conditionally dependent on the transform type.</p>
#[doc(hidden)]
pub parameters: std::option::Option<crate::model::TransformParameters>,
/// <p>The name or Amazon Resource Name (ARN) of the IAM role with the required permissions.</p>
#[doc(hidden)]
pub role: std::option::Option<std::string::String>,
/// <p>This value determines which version of Glue this machine learning transform is compatible with. Glue 1.0 is recommended for most customers. If the value is not set, the Glue compatibility defaults to Glue 0.9. For more information, see <a href="https://docs.aws.amazon.com/glue/latest/dg/release-notes.html#release-notes-versions">Glue Versions</a> in the developer guide.</p>
#[doc(hidden)]
pub glue_version: std::option::Option<std::string::String>,
/// <p>The number of Glue data processing units (DPUs) that are allocated to task runs for this transform. You can allocate from 2 to 100 DPUs; the default is 10. A DPU is a relative measure of processing power that consists of 4 vCPUs of compute capacity and 16 GB of memory. For more information, see the <a href="https://aws.amazon.com/glue/pricing/">Glue pricing page</a>. </p>
/// <p>When the <code>WorkerType</code> field is set to a value other than <code>Standard</code>, the <code>MaxCapacity</code> field is set automatically and becomes read-only.</p>
#[doc(hidden)]
pub max_capacity: std::option::Option<f64>,
/// <p>The type of predefined worker that is allocated when this task runs. Accepts a value of Standard, G.1X, or G.2X.</p>
/// <ul>
/// <li> <p>For the <code>Standard</code> worker type, each worker provides 4 vCPU, 16 GB of memory and a 50GB disk, and 2 executors per worker.</p> </li>
/// <li> <p>For the <code>G.1X</code> worker type, each worker provides 4 vCPU, 16 GB of memory and a 64GB disk, and 1 executor per worker.</p> </li>
/// <li> <p>For the <code>G.2X</code> worker type, each worker provides 8 vCPU, 32 GB of memory and a 128GB disk, and 1 executor per worker.</p> </li>
/// </ul>
#[doc(hidden)]
pub worker_type: std::option::Option<crate::model::WorkerType>,
/// <p>The number of workers of a defined <code>workerType</code> that are allocated when this task runs.</p>
#[doc(hidden)]
pub number_of_workers: std::option::Option<i32>,
/// <p>The timeout for a task run for this transform in minutes. This is the maximum time that a task run for this transform can consume resources before it is terminated and enters <code>TIMEOUT</code> status. The default is 2,880 minutes (48 hours).</p>
#[doc(hidden)]
pub timeout: std::option::Option<i32>,
/// <p>The maximum number of times to retry a task for this transform after a task run fails.</p>
#[doc(hidden)]
pub max_retries: std::option::Option<i32>,
}
impl UpdateMlTransformInput {
/// <p>A unique identifier that was generated when the transform was created.</p>
pub fn transform_id(&self) -> std::option::Option<&str> {
self.transform_id.as_deref()
}
/// <p>The unique name that you gave the transform when you created it.</p>
pub fn name(&self) -> std::option::Option<&str> {
self.name.as_deref()
}
/// <p>A description of the transform. The default is an empty string.</p>
pub fn description(&self) -> std::option::Option<&str> {
self.description.as_deref()
}
/// <p>The configuration parameters that are specific to the transform type (algorithm) used. Conditionally dependent on the transform type.</p>
pub fn parameters(&self) -> std::option::Option<&crate::model::TransformParameters> {
self.parameters.as_ref()
}
/// <p>The name or Amazon Resource Name (ARN) of the IAM role with the required permissions.</p>
pub fn role(&self) -> std::option::Option<&str> {
self.role.as_deref()
}
/// <p>This value determines which version of Glue this machine learning transform is compatible with. Glue 1.0 is recommended for most customers. If the value is not set, the Glue compatibility defaults to Glue 0.9. For more information, see <a href="https://docs.aws.amazon.com/glue/latest/dg/release-notes.html#release-notes-versions">Glue Versions</a> in the developer guide.</p>
pub fn glue_version(&self) -> std::option::Option<&str> {
self.glue_version.as_deref()
}
/// <p>The number of Glue data processing units (DPUs) that are allocated to task runs for this transform. You can allocate from 2 to 100 DPUs; the default is 10. A DPU is a relative measure of processing power that consists of 4 vCPUs of compute capacity and 16 GB of memory. For more information, see the <a href="https://aws.amazon.com/glue/pricing/">Glue pricing page</a>. </p>
/// <p>When the <code>WorkerType</code> field is set to a value other than <code>Standard</code>, the <code>MaxCapacity</code> field is set automatically and becomes read-only.</p>
pub fn max_capacity(&self) -> std::option::Option<f64> {
self.max_capacity
}
/// <p>The type of predefined worker that is allocated when this task runs. Accepts a value of Standard, G.1X, or G.2X.</p>
/// <ul>
/// <li> <p>For the <code>Standard</code> worker type, each worker provides 4 vCPU, 16 GB of memory and a 50GB disk, and 2 executors per worker.</p> </li>
/// <li> <p>For the <code>G.1X</code> worker type, each worker provides 4 vCPU, 16 GB of memory and a 64GB disk, and 1 executor per worker.</p> </li>
/// <li> <p>For the <code>G.2X</code> worker type, each worker provides 8 vCPU, 32 GB of memory and a 128GB disk, and 1 executor per worker.</p> </li>
/// </ul>
pub fn worker_type(&self) -> std::option::Option<&crate::model::WorkerType> {
self.worker_type.as_ref()
}
/// <p>The number of workers of a defined <code>workerType</code> that are allocated when this task runs.</p>
pub fn number_of_workers(&self) -> std::option::Option<i32> {
self.number_of_workers
}
/// <p>The timeout for a task run for this transform in minutes. This is the maximum time that a task run for this transform can consume resources before it is terminated and enters <code>TIMEOUT</code> status. The default is 2,880 minutes (48 hours).</p>
pub fn timeout(&self) -> std::option::Option<i32> {
self.timeout
}
/// <p>The maximum number of times to retry a task for this transform after a task run fails.</p>
pub fn max_retries(&self) -> std::option::Option<i32> {
self.max_retries
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UpdateJobFromSourceControlInput {
/// <p>The name of the Glue job to be synchronized to or from the remote repository.</p>
#[doc(hidden)]
pub job_name: std::option::Option<std::string::String>,
/// <p>The provider for the remote repository.</p>
#[doc(hidden)]
pub provider: std::option::Option<crate::model::SourceControlProvider>,
/// <p>The name of the remote repository that contains the job artifacts.</p>
#[doc(hidden)]
pub repository_name: std::option::Option<std::string::String>,
/// <p>The owner of the remote repository that contains the job artifacts.</p>
#[doc(hidden)]
pub repository_owner: std::option::Option<std::string::String>,
/// <p>An optional branch in the remote repository.</p>
#[doc(hidden)]
pub branch_name: std::option::Option<std::string::String>,
/// <p>An optional folder in the remote repository.</p>
#[doc(hidden)]
pub folder: std::option::Option<std::string::String>,
/// <p>A commit ID for a commit in the remote repository.</p>
#[doc(hidden)]
pub commit_id: std::option::Option<std::string::String>,
/// <p>The type of authentication, which can be an authentication token stored in Amazon Web Services Secrets Manager, or a personal access token.</p>
#[doc(hidden)]
pub auth_strategy: std::option::Option<crate::model::SourceControlAuthStrategy>,
/// <p>The value of the authorization token.</p>
#[doc(hidden)]
pub auth_token: std::option::Option<std::string::String>,
}
impl UpdateJobFromSourceControlInput {
/// <p>The name of the Glue job to be synchronized to or from the remote repository.</p>
pub fn job_name(&self) -> std::option::Option<&str> {
self.job_name.as_deref()
}
/// <p>The provider for the remote repository.</p>
pub fn provider(&self) -> std::option::Option<&crate::model::SourceControlProvider> {
self.provider.as_ref()
}
/// <p>The name of the remote repository that contains the job artifacts.</p>
pub fn repository_name(&self) -> std::option::Option<&str> {
self.repository_name.as_deref()
}
/// <p>The owner of the remote repository that contains the job artifacts.</p>
pub fn repository_owner(&self) -> std::option::Option<&str> {
self.repository_owner.as_deref()
}
/// <p>An optional branch in the remote repository.</p>
pub fn branch_name(&self) -> std::option::Option<&str> {
self.branch_name.as_deref()
}
/// <p>An optional folder in the remote repository.</p>
pub fn folder(&self) -> std::option::Option<&str> {
self.folder.as_deref()
}
/// <p>A commit ID for a commit in the remote repository.</p>
pub fn commit_id(&self) -> std::option::Option<&str> {
self.commit_id.as_deref()
}
/// <p>The type of authentication, which can be an authentication token stored in Amazon Web Services Secrets Manager, or a personal access token.</p>
pub fn auth_strategy(&self) -> std::option::Option<&crate::model::SourceControlAuthStrategy> {
self.auth_strategy.as_ref()
}
/// <p>The value of the authorization token.</p>
pub fn auth_token(&self) -> std::option::Option<&str> {
self.auth_token.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UpdateJobInput {
/// <p>The name of the job definition to update.</p>
#[doc(hidden)]
pub job_name: std::option::Option<std::string::String>,
/// <p>Specifies the values with which to update the job definition. Unspecified configuration is removed or reset to default values.</p>
#[doc(hidden)]
pub job_update: std::option::Option<crate::model::JobUpdate>,
}
impl UpdateJobInput {
/// <p>The name of the job definition to update.</p>
pub fn job_name(&self) -> std::option::Option<&str> {
self.job_name.as_deref()
}
/// <p>Specifies the values with which to update the job definition. Unspecified configuration is removed or reset to default values.</p>
pub fn job_update(&self) -> std::option::Option<&crate::model::JobUpdate> {
self.job_update.as_ref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UpdateDevEndpointInput {
/// <p>The name of the <code>DevEndpoint</code> to be updated.</p>
#[doc(hidden)]
pub endpoint_name: std::option::Option<std::string::String>,
/// <p>The public key for the <code>DevEndpoint</code> to use.</p>
#[doc(hidden)]
pub public_key: std::option::Option<std::string::String>,
/// <p>The list of public keys for the <code>DevEndpoint</code> to use.</p>
#[doc(hidden)]
pub add_public_keys: std::option::Option<std::vec::Vec<std::string::String>>,
/// <p>The list of public keys to be deleted from the <code>DevEndpoint</code>.</p>
#[doc(hidden)]
pub delete_public_keys: std::option::Option<std::vec::Vec<std::string::String>>,
/// <p>Custom Python or Java libraries to be loaded in the <code>DevEndpoint</code>.</p>
#[doc(hidden)]
pub custom_libraries: std::option::Option<crate::model::DevEndpointCustomLibraries>,
/// <p> <code>True</code> if the list of custom libraries to be loaded in the development endpoint needs to be updated, or <code>False</code> if otherwise.</p>
#[doc(hidden)]
pub update_etl_libraries: bool,
/// <p>The list of argument keys to be deleted from the map of arguments used to configure the <code>DevEndpoint</code>.</p>
#[doc(hidden)]
pub delete_arguments: std::option::Option<std::vec::Vec<std::string::String>>,
/// <p>The map of arguments to add the map of arguments used to configure the <code>DevEndpoint</code>.</p>
/// <p>Valid arguments are:</p>
/// <ul>
/// <li> <p> <code>"--enable-glue-datacatalog": ""</code> </p> </li>
/// </ul>
/// <p>You can specify a version of Python support for development endpoints by using the <code>Arguments</code> parameter in the <code>CreateDevEndpoint</code> or <code>UpdateDevEndpoint</code> APIs. If no arguments are provided, the version defaults to Python 2.</p>
#[doc(hidden)]
pub add_arguments:
std::option::Option<std::collections::HashMap<std::string::String, std::string::String>>,
}
impl UpdateDevEndpointInput {
/// <p>The name of the <code>DevEndpoint</code> to be updated.</p>
pub fn endpoint_name(&self) -> std::option::Option<&str> {
self.endpoint_name.as_deref()
}
/// <p>The public key for the <code>DevEndpoint</code> to use.</p>
pub fn public_key(&self) -> std::option::Option<&str> {
self.public_key.as_deref()
}
/// <p>The list of public keys for the <code>DevEndpoint</code> to use.</p>
pub fn add_public_keys(&self) -> std::option::Option<&[std::string::String]> {
self.add_public_keys.as_deref()
}
/// <p>The list of public keys to be deleted from the <code>DevEndpoint</code>.</p>
pub fn delete_public_keys(&self) -> std::option::Option<&[std::string::String]> {
self.delete_public_keys.as_deref()
}
/// <p>Custom Python or Java libraries to be loaded in the <code>DevEndpoint</code>.</p>
pub fn custom_libraries(
&self,
) -> std::option::Option<&crate::model::DevEndpointCustomLibraries> {
self.custom_libraries.as_ref()
}
/// <p> <code>True</code> if the list of custom libraries to be loaded in the development endpoint needs to be updated, or <code>False</code> if otherwise.</p>
pub fn update_etl_libraries(&self) -> bool {
self.update_etl_libraries
}
/// <p>The list of argument keys to be deleted from the map of arguments used to configure the <code>DevEndpoint</code>.</p>
pub fn delete_arguments(&self) -> std::option::Option<&[std::string::String]> {
self.delete_arguments.as_deref()
}
/// <p>The map of arguments to add the map of arguments used to configure the <code>DevEndpoint</code>.</p>
/// <p>Valid arguments are:</p>
/// <ul>
/// <li> <p> <code>"--enable-glue-datacatalog": ""</code> </p> </li>
/// </ul>
/// <p>You can specify a version of Python support for development endpoints by using the <code>Arguments</code> parameter in the <code>CreateDevEndpoint</code> or <code>UpdateDevEndpoint</code> APIs. If no arguments are provided, the version defaults to Python 2.</p>
pub fn add_arguments(
&self,
) -> std::option::Option<&std::collections::HashMap<std::string::String, std::string::String>>
{
self.add_arguments.as_ref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UpdateDataQualityRulesetInput {
/// <p>The name of the data quality ruleset.</p>
#[doc(hidden)]
pub name: std::option::Option<std::string::String>,
/// <p>The new name of the ruleset, if you are renaming it.</p>
#[doc(hidden)]
pub updated_name: std::option::Option<std::string::String>,
/// <p>A description of the ruleset.</p>
#[doc(hidden)]
pub description: std::option::Option<std::string::String>,
/// <p>A Data Quality Definition Language (DQDL) ruleset. For more information, see the Glue developer guide.</p>
#[doc(hidden)]
pub ruleset: std::option::Option<std::string::String>,
}
impl UpdateDataQualityRulesetInput {
/// <p>The name of the data quality ruleset.</p>
pub fn name(&self) -> std::option::Option<&str> {
self.name.as_deref()
}
/// <p>The new name of the ruleset, if you are renaming it.</p>
pub fn updated_name(&self) -> std::option::Option<&str> {
self.updated_name.as_deref()
}
/// <p>A description of the ruleset.</p>
pub fn description(&self) -> std::option::Option<&str> {
self.description.as_deref()
}
/// <p>A Data Quality Definition Language (DQDL) ruleset. For more information, see the Glue developer guide.</p>
pub fn ruleset(&self) -> std::option::Option<&str> {
self.ruleset.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UpdateDatabaseInput {
/// <p>The ID of the Data Catalog in which the metadata database resides. If none is provided, the Amazon Web Services account ID is used by default.</p>
#[doc(hidden)]
pub catalog_id: std::option::Option<std::string::String>,
/// <p>The name of the database to update in the catalog. For Hive compatibility, this is folded to lowercase.</p>
#[doc(hidden)]
pub name: std::option::Option<std::string::String>,
/// <p>A <code>DatabaseInput</code> object specifying the new definition of the metadata database in the catalog.</p>
#[doc(hidden)]
pub database_input: std::option::Option<crate::model::DatabaseInput>,
}
impl UpdateDatabaseInput {
/// <p>The ID of the Data Catalog in which the metadata database resides. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(&self) -> std::option::Option<&str> {
self.catalog_id.as_deref()
}
/// <p>The name of the database to update in the catalog. For Hive compatibility, this is folded to lowercase.</p>
pub fn name(&self) -> std::option::Option<&str> {
self.name.as_deref()
}
/// <p>A <code>DatabaseInput</code> object specifying the new definition of the metadata database in the catalog.</p>
pub fn database_input(&self) -> std::option::Option<&crate::model::DatabaseInput> {
self.database_input.as_ref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UpdateCrawlerScheduleInput {
/// <p>The name of the crawler whose schedule to update.</p>
#[doc(hidden)]
pub crawler_name: std::option::Option<std::string::String>,
/// <p>The updated <code>cron</code> expression used to specify the schedule (see <a href="https://docs.aws.amazon.com/glue/latest/dg/monitor-data-warehouse-schedule.html">Time-Based Schedules for Jobs and Crawlers</a>. For example, to run something every day at 12:15 UTC, you would specify: <code>cron(15 12 * * ? *)</code>.</p>
#[doc(hidden)]
pub schedule: std::option::Option<std::string::String>,
}
impl UpdateCrawlerScheduleInput {
/// <p>The name of the crawler whose schedule to update.</p>
pub fn crawler_name(&self) -> std::option::Option<&str> {
self.crawler_name.as_deref()
}
/// <p>The updated <code>cron</code> expression used to specify the schedule (see <a href="https://docs.aws.amazon.com/glue/latest/dg/monitor-data-warehouse-schedule.html">Time-Based Schedules for Jobs and Crawlers</a>. For example, to run something every day at 12:15 UTC, you would specify: <code>cron(15 12 * * ? *)</code>.</p>
pub fn schedule(&self) -> std::option::Option<&str> {
self.schedule.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UpdateCrawlerInput {
/// <p>Name of the new crawler.</p>
#[doc(hidden)]
pub name: std::option::Option<std::string::String>,
/// <p>The IAM role or Amazon Resource Name (ARN) of an IAM role that is used by the new crawler to access customer resources.</p>
#[doc(hidden)]
pub role: std::option::Option<std::string::String>,
/// <p>The Glue database where results are stored, such as: <code>arn:aws:daylight:us-east-1::database/sometable/*</code>.</p>
#[doc(hidden)]
pub database_name: std::option::Option<std::string::String>,
/// <p>A description of the new crawler.</p>
#[doc(hidden)]
pub description: std::option::Option<std::string::String>,
/// <p>A list of targets to crawl.</p>
#[doc(hidden)]
pub targets: std::option::Option<crate::model::CrawlerTargets>,
/// <p>A <code>cron</code> expression used to specify the schedule (see <a href="https://docs.aws.amazon.com/glue/latest/dg/monitor-data-warehouse-schedule.html">Time-Based Schedules for Jobs and Crawlers</a>. For example, to run something every day at 12:15 UTC, you would specify: <code>cron(15 12 * * ? *)</code>.</p>
#[doc(hidden)]
pub schedule: std::option::Option<std::string::String>,
/// <p>A list of custom classifiers that the user has registered. By default, all built-in classifiers are included in a crawl, but these custom classifiers always override the default classifiers for a given classification.</p>
#[doc(hidden)]
pub classifiers: std::option::Option<std::vec::Vec<std::string::String>>,
/// <p>The table prefix used for catalog tables that are created.</p>
#[doc(hidden)]
pub table_prefix: std::option::Option<std::string::String>,
/// <p>The policy for the crawler's update and deletion behavior.</p>
#[doc(hidden)]
pub schema_change_policy: std::option::Option<crate::model::SchemaChangePolicy>,
/// <p>A policy that specifies whether to crawl the entire dataset again, or to crawl only folders that were added since the last crawler run.</p>
#[doc(hidden)]
pub recrawl_policy: std::option::Option<crate::model::RecrawlPolicy>,
/// <p>Specifies data lineage configuration settings for the crawler.</p>
#[doc(hidden)]
pub lineage_configuration: std::option::Option<crate::model::LineageConfiguration>,
/// <p>Specifies Lake Formation configuration settings for the crawler.</p>
#[doc(hidden)]
pub lake_formation_configuration: std::option::Option<crate::model::LakeFormationConfiguration>,
/// <p>Crawler configuration information. This versioned JSON string allows users to specify aspects of a crawler's behavior. For more information, see <a href="https://docs.aws.amazon.com/glue/latest/dg/crawler-configuration.html">Setting crawler configuration options</a>.</p>
#[doc(hidden)]
pub configuration: std::option::Option<std::string::String>,
/// <p>The name of the <code>SecurityConfiguration</code> structure to be used by this crawler.</p>
#[doc(hidden)]
pub crawler_security_configuration: std::option::Option<std::string::String>,
}
impl UpdateCrawlerInput {
/// <p>Name of the new crawler.</p>
pub fn name(&self) -> std::option::Option<&str> {
self.name.as_deref()
}
/// <p>The IAM role or Amazon Resource Name (ARN) of an IAM role that is used by the new crawler to access customer resources.</p>
pub fn role(&self) -> std::option::Option<&str> {
self.role.as_deref()
}
/// <p>The Glue database where results are stored, such as: <code>arn:aws:daylight:us-east-1::database/sometable/*</code>.</p>
pub fn database_name(&self) -> std::option::Option<&str> {
self.database_name.as_deref()
}
/// <p>A description of the new crawler.</p>
pub fn description(&self) -> std::option::Option<&str> {
self.description.as_deref()
}
/// <p>A list of targets to crawl.</p>
pub fn targets(&self) -> std::option::Option<&crate::model::CrawlerTargets> {
self.targets.as_ref()
}
/// <p>A <code>cron</code> expression used to specify the schedule (see <a href="https://docs.aws.amazon.com/glue/latest/dg/monitor-data-warehouse-schedule.html">Time-Based Schedules for Jobs and Crawlers</a>. For example, to run something every day at 12:15 UTC, you would specify: <code>cron(15 12 * * ? *)</code>.</p>
pub fn schedule(&self) -> std::option::Option<&str> {
self.schedule.as_deref()
}
/// <p>A list of custom classifiers that the user has registered. By default, all built-in classifiers are included in a crawl, but these custom classifiers always override the default classifiers for a given classification.</p>
pub fn classifiers(&self) -> std::option::Option<&[std::string::String]> {
self.classifiers.as_deref()
}
/// <p>The table prefix used for catalog tables that are created.</p>
pub fn table_prefix(&self) -> std::option::Option<&str> {
self.table_prefix.as_deref()
}
/// <p>The policy for the crawler's update and deletion behavior.</p>
pub fn schema_change_policy(&self) -> std::option::Option<&crate::model::SchemaChangePolicy> {
self.schema_change_policy.as_ref()
}
/// <p>A policy that specifies whether to crawl the entire dataset again, or to crawl only folders that were added since the last crawler run.</p>
pub fn recrawl_policy(&self) -> std::option::Option<&crate::model::RecrawlPolicy> {
self.recrawl_policy.as_ref()
}
/// <p>Specifies data lineage configuration settings for the crawler.</p>
pub fn lineage_configuration(
&self,
) -> std::option::Option<&crate::model::LineageConfiguration> {
self.lineage_configuration.as_ref()
}
/// <p>Specifies Lake Formation configuration settings for the crawler.</p>
pub fn lake_formation_configuration(
&self,
) -> std::option::Option<&crate::model::LakeFormationConfiguration> {
self.lake_formation_configuration.as_ref()
}
/// <p>Crawler configuration information. This versioned JSON string allows users to specify aspects of a crawler's behavior. For more information, see <a href="https://docs.aws.amazon.com/glue/latest/dg/crawler-configuration.html">Setting crawler configuration options</a>.</p>
pub fn configuration(&self) -> std::option::Option<&str> {
self.configuration.as_deref()
}
/// <p>The name of the <code>SecurityConfiguration</code> structure to be used by this crawler.</p>
pub fn crawler_security_configuration(&self) -> std::option::Option<&str> {
self.crawler_security_configuration.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UpdateConnectionInput {
/// <p>The ID of the Data Catalog in which the connection resides. If none is provided, the Amazon Web Services account ID is used by default.</p>
#[doc(hidden)]
pub catalog_id: std::option::Option<std::string::String>,
/// <p>The name of the connection definition to update.</p>
#[doc(hidden)]
pub name: std::option::Option<std::string::String>,
/// <p>A <code>ConnectionInput</code> object that redefines the connection in question.</p>
#[doc(hidden)]
pub connection_input: std::option::Option<crate::model::ConnectionInput>,
}
impl UpdateConnectionInput {
/// <p>The ID of the Data Catalog in which the connection resides. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(&self) -> std::option::Option<&str> {
self.catalog_id.as_deref()
}
/// <p>The name of the connection definition to update.</p>
pub fn name(&self) -> std::option::Option<&str> {
self.name.as_deref()
}
/// <p>A <code>ConnectionInput</code> object that redefines the connection in question.</p>
pub fn connection_input(&self) -> std::option::Option<&crate::model::ConnectionInput> {
self.connection_input.as_ref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UpdateColumnStatisticsForTableInput {
/// <p>The ID of the Data Catalog where the partitions in question reside. If none is supplied, the Amazon Web Services account ID is used by default.</p>
#[doc(hidden)]
pub catalog_id: std::option::Option<std::string::String>,
/// <p>The name of the catalog database where the partitions reside.</p>
#[doc(hidden)]
pub database_name: std::option::Option<std::string::String>,
/// <p>The name of the partitions' table.</p>
#[doc(hidden)]
pub table_name: std::option::Option<std::string::String>,
/// <p>A list of the column statistics.</p>
#[doc(hidden)]
pub column_statistics_list: std::option::Option<std::vec::Vec<crate::model::ColumnStatistics>>,
}
impl UpdateColumnStatisticsForTableInput {
/// <p>The ID of the Data Catalog where the partitions in question reside. If none is supplied, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(&self) -> std::option::Option<&str> {
self.catalog_id.as_deref()
}
/// <p>The name of the catalog database where the partitions reside.</p>
pub fn database_name(&self) -> std::option::Option<&str> {
self.database_name.as_deref()
}
/// <p>The name of the partitions' table.</p>
pub fn table_name(&self) -> std::option::Option<&str> {
self.table_name.as_deref()
}
/// <p>A list of the column statistics.</p>
pub fn column_statistics_list(&self) -> std::option::Option<&[crate::model::ColumnStatistics]> {
self.column_statistics_list.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UpdateColumnStatisticsForPartitionInput {
/// <p>The ID of the Data Catalog where the partitions in question reside. If none is supplied, the Amazon Web Services account ID is used by default.</p>
#[doc(hidden)]
pub catalog_id: std::option::Option<std::string::String>,
/// <p>The name of the catalog database where the partitions reside.</p>
#[doc(hidden)]
pub database_name: std::option::Option<std::string::String>,
/// <p>The name of the partitions' table.</p>
#[doc(hidden)]
pub table_name: std::option::Option<std::string::String>,
/// <p>A list of partition values identifying the partition.</p>
#[doc(hidden)]
pub partition_values: std::option::Option<std::vec::Vec<std::string::String>>,
/// <p>A list of the column statistics.</p>
#[doc(hidden)]
pub column_statistics_list: std::option::Option<std::vec::Vec<crate::model::ColumnStatistics>>,
}
impl UpdateColumnStatisticsForPartitionInput {
/// <p>The ID of the Data Catalog where the partitions in question reside. If none is supplied, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(&self) -> std::option::Option<&str> {
self.catalog_id.as_deref()
}
/// <p>The name of the catalog database where the partitions reside.</p>
pub fn database_name(&self) -> std::option::Option<&str> {
self.database_name.as_deref()
}
/// <p>The name of the partitions' table.</p>
pub fn table_name(&self) -> std::option::Option<&str> {
self.table_name.as_deref()
}
/// <p>A list of partition values identifying the partition.</p>
pub fn partition_values(&self) -> std::option::Option<&[std::string::String]> {
self.partition_values.as_deref()
}
/// <p>A list of the column statistics.</p>
pub fn column_statistics_list(&self) -> std::option::Option<&[crate::model::ColumnStatistics]> {
self.column_statistics_list.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UpdateClassifierInput {
/// <p>A <code>GrokClassifier</code> object with updated fields.</p>
#[doc(hidden)]
pub grok_classifier: std::option::Option<crate::model::UpdateGrokClassifierRequest>,
/// <p>An <code>XMLClassifier</code> object with updated fields.</p>
#[doc(hidden)]
pub xml_classifier: std::option::Option<crate::model::UpdateXmlClassifierRequest>,
/// <p>A <code>JsonClassifier</code> object with updated fields.</p>
#[doc(hidden)]
pub json_classifier: std::option::Option<crate::model::UpdateJsonClassifierRequest>,
/// <p>A <code>CsvClassifier</code> object with updated fields.</p>
#[doc(hidden)]
pub csv_classifier: std::option::Option<crate::model::UpdateCsvClassifierRequest>,
}
impl UpdateClassifierInput {
/// <p>A <code>GrokClassifier</code> object with updated fields.</p>
pub fn grok_classifier(
&self,
) -> std::option::Option<&crate::model::UpdateGrokClassifierRequest> {
self.grok_classifier.as_ref()
}
/// <p>An <code>XMLClassifier</code> object with updated fields.</p>
pub fn xml_classifier(&self) -> std::option::Option<&crate::model::UpdateXmlClassifierRequest> {
self.xml_classifier.as_ref()
}
/// <p>A <code>JsonClassifier</code> object with updated fields.</p>
pub fn json_classifier(
&self,
) -> std::option::Option<&crate::model::UpdateJsonClassifierRequest> {
self.json_classifier.as_ref()
}
/// <p>A <code>CsvClassifier</code> object with updated fields.</p>
pub fn csv_classifier(&self) -> std::option::Option<&crate::model::UpdateCsvClassifierRequest> {
self.csv_classifier.as_ref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UpdateBlueprintInput {
/// <p>The name of the blueprint.</p>
#[doc(hidden)]
pub name: std::option::Option<std::string::String>,
/// <p>A description of the blueprint.</p>
#[doc(hidden)]
pub description: std::option::Option<std::string::String>,
/// <p>Specifies a path in Amazon S3 where the blueprint is published.</p>
#[doc(hidden)]
pub blueprint_location: std::option::Option<std::string::String>,
}
impl UpdateBlueprintInput {
/// <p>The name of the blueprint.</p>
pub fn name(&self) -> std::option::Option<&str> {
self.name.as_deref()
}
/// <p>A description of the blueprint.</p>
pub fn description(&self) -> std::option::Option<&str> {
self.description.as_deref()
}
/// <p>Specifies a path in Amazon S3 where the blueprint is published.</p>
pub fn blueprint_location(&self) -> std::option::Option<&str> {
self.blueprint_location.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UntagResourceInput {
/// <p>The Amazon Resource Name (ARN) of the resource from which to remove the tags.</p>
#[doc(hidden)]
pub resource_arn: std::option::Option<std::string::String>,
/// <p>Tags to remove from this resource.</p>
#[doc(hidden)]
pub tags_to_remove: std::option::Option<std::vec::Vec<std::string::String>>,
}
impl UntagResourceInput {
/// <p>The Amazon Resource Name (ARN) of the resource from which to remove the tags.</p>
pub fn resource_arn(&self) -> std::option::Option<&str> {
self.resource_arn.as_deref()
}
/// <p>Tags to remove from this resource.</p>
pub fn tags_to_remove(&self) -> std::option::Option<&[std::string::String]> {
self.tags_to_remove.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct TagResourceInput {
/// <p>The ARN of the Glue resource to which to add the tags. For more information about Glue resource ARNs, see the <a href="https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-common.html#aws-glue-api-regex-aws-glue-arn-id">Glue ARN string pattern</a>.</p>
#[doc(hidden)]
pub resource_arn: std::option::Option<std::string::String>,
/// <p>Tags to add to this resource.</p>
#[doc(hidden)]
pub tags_to_add:
std::option::Option<std::collections::HashMap<std::string::String, std::string::String>>,
}
impl TagResourceInput {
/// <p>The ARN of the Glue resource to which to add the tags. For more information about Glue resource ARNs, see the <a href="https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-common.html#aws-glue-api-regex-aws-glue-arn-id">Glue ARN string pattern</a>.</p>
pub fn resource_arn(&self) -> std::option::Option<&str> {
self.resource_arn.as_deref()
}
/// <p>Tags to add to this resource.</p>
pub fn tags_to_add(
&self,
) -> std::option::Option<&std::collections::HashMap<std::string::String, std::string::String>>
{
self.tags_to_add.as_ref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct StopWorkflowRunInput {
/// <p>The name of the workflow to stop.</p>
#[doc(hidden)]
pub name: std::option::Option<std::string::String>,
/// <p>The ID of the workflow run to stop.</p>
#[doc(hidden)]
pub run_id: std::option::Option<std::string::String>,
}
impl StopWorkflowRunInput {
/// <p>The name of the workflow to stop.</p>
pub fn name(&self) -> std::option::Option<&str> {
self.name.as_deref()
}
/// <p>The ID of the workflow run to stop.</p>
pub fn run_id(&self) -> std::option::Option<&str> {
self.run_id.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct StopTriggerInput {
/// <p>The name of the trigger to stop.</p>
#[doc(hidden)]
pub name: std::option::Option<std::string::String>,
}
impl StopTriggerInput {
/// <p>The name of the trigger to stop.</p>
pub fn name(&self) -> std::option::Option<&str> {
self.name.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct StopSessionInput {
/// <p>The ID of the session to be stopped.</p>
#[doc(hidden)]
pub id: std::option::Option<std::string::String>,
/// <p>The origin of the request.</p>
#[doc(hidden)]
pub request_origin: std::option::Option<std::string::String>,
}
impl StopSessionInput {
/// <p>The ID of the session to be stopped.</p>
pub fn id(&self) -> std::option::Option<&str> {
self.id.as_deref()
}
/// <p>The origin of the request.</p>
pub fn request_origin(&self) -> std::option::Option<&str> {
self.request_origin.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct StopCrawlerScheduleInput {
/// <p>Name of the crawler whose schedule state to set.</p>
#[doc(hidden)]
pub crawler_name: std::option::Option<std::string::String>,
}
impl StopCrawlerScheduleInput {
/// <p>Name of the crawler whose schedule state to set.</p>
pub fn crawler_name(&self) -> std::option::Option<&str> {
self.crawler_name.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct StopCrawlerInput {
/// <p>Name of the crawler to stop.</p>
#[doc(hidden)]
pub name: std::option::Option<std::string::String>,
}
impl StopCrawlerInput {
/// <p>Name of the crawler to stop.</p>
pub fn name(&self) -> std::option::Option<&str> {
self.name.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct StartWorkflowRunInput {
/// <p>The name of the workflow to start.</p>
#[doc(hidden)]
pub name: std::option::Option<std::string::String>,
/// <p>The workflow run properties for the new workflow run.</p>
#[doc(hidden)]
pub run_properties:
std::option::Option<std::collections::HashMap<std::string::String, std::string::String>>,
}
impl StartWorkflowRunInput {
/// <p>The name of the workflow to start.</p>
pub fn name(&self) -> std::option::Option<&str> {
self.name.as_deref()
}
/// <p>The workflow run properties for the new workflow run.</p>
pub fn run_properties(
&self,
) -> std::option::Option<&std::collections::HashMap<std::string::String, std::string::String>>
{
self.run_properties.as_ref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct StartTriggerInput {
/// <p>The name of the trigger to start.</p>
#[doc(hidden)]
pub name: std::option::Option<std::string::String>,
}
impl StartTriggerInput {
/// <p>The name of the trigger to start.</p>
pub fn name(&self) -> std::option::Option<&str> {
self.name.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct StartMlLabelingSetGenerationTaskRunInput {
/// <p>The unique identifier of the machine learning transform.</p>
#[doc(hidden)]
pub transform_id: std::option::Option<std::string::String>,
/// <p>The Amazon Simple Storage Service (Amazon S3) path where you generate the labeling set.</p>
#[doc(hidden)]
pub output_s3_path: std::option::Option<std::string::String>,
}
impl StartMlLabelingSetGenerationTaskRunInput {
/// <p>The unique identifier of the machine learning transform.</p>
pub fn transform_id(&self) -> std::option::Option<&str> {
self.transform_id.as_deref()
}
/// <p>The Amazon Simple Storage Service (Amazon S3) path where you generate the labeling set.</p>
pub fn output_s3_path(&self) -> std::option::Option<&str> {
self.output_s3_path.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct StartMlEvaluationTaskRunInput {
/// <p>The unique identifier of the machine learning transform.</p>
#[doc(hidden)]
pub transform_id: std::option::Option<std::string::String>,
}
impl StartMlEvaluationTaskRunInput {
/// <p>The unique identifier of the machine learning transform.</p>
pub fn transform_id(&self) -> std::option::Option<&str> {
self.transform_id.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct StartJobRunInput {
/// <p>The name of the job definition to use.</p>
#[doc(hidden)]
pub job_name: std::option::Option<std::string::String>,
/// <p>The ID of a previous <code>JobRun</code> to retry.</p>
#[doc(hidden)]
pub job_run_id: std::option::Option<std::string::String>,
/// <p>The job arguments specifically for this run. For this job run, they replace the default arguments set in the job definition itself.</p>
/// <p>You can specify arguments here that your own job-execution script consumes, as well as arguments that Glue itself consumes.</p>
/// <p>Job arguments may be logged. Do not pass plaintext secrets as arguments. Retrieve secrets from a Glue Connection, Secrets Manager or other secret management mechanism if you intend to keep them within the Job. </p>
/// <p>For information about how to specify and consume your own Job arguments, see the <a href="https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-python-calling.html">Calling Glue APIs in Python</a> topic in the developer guide.</p>
/// <p>For information about the key-value pairs that Glue consumes to set up your job, see the <a href="https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html">Special Parameters Used by Glue</a> topic in the developer guide.</p>
#[doc(hidden)]
pub arguments:
std::option::Option<std::collections::HashMap<std::string::String, std::string::String>>,
/// <p>This field is deprecated. Use <code>MaxCapacity</code> instead.</p>
/// <p>The number of Glue data processing units (DPUs) to allocate to this JobRun. You can allocate a minimum of 2 DPUs; the default is 10. A DPU is a relative measure of processing power that consists of 4 vCPUs of compute capacity and 16 GB of memory. For more information, see the <a href="https://aws.amazon.com/glue/pricing/">Glue pricing page</a>.</p>
#[deprecated(note = "This property is deprecated, use MaxCapacity instead.")]
#[doc(hidden)]
pub allocated_capacity: i32,
/// <p>The <code>JobRun</code> timeout in minutes. This is the maximum time that a job run can consume resources before it is terminated and enters <code>TIMEOUT</code> status. This value overrides the timeout value set in the parent job.</p>
/// <p>Streaming jobs do not have a timeout. The default for non-streaming jobs is 2,880 minutes (48 hours).</p>
#[doc(hidden)]
pub timeout: std::option::Option<i32>,
/// <p>The number of Glue data processing units (DPUs) that can be allocated when this job runs. A DPU is a relative measure of processing power that consists of 4 vCPUs of compute capacity and 16 GB of memory. For more information, see the <a href="https://aws.amazon.com/glue/pricing/">Glue pricing page</a>.</p>
/// <p>Do not set <code>Max Capacity</code> if using <code>WorkerType</code> and <code>NumberOfWorkers</code>.</p>
/// <p>The value that can be allocated for <code>MaxCapacity</code> depends on whether you are running a Python shell job, or an Apache Spark ETL job:</p>
/// <ul>
/// <li> <p>When you specify a Python shell job (<code>JobCommand.Name</code>="pythonshell"), you can allocate either 0.0625 or 1 DPU. The default is 0.0625 DPU.</p> </li>
/// <li> <p>When you specify an Apache Spark ETL job (<code>JobCommand.Name</code>="glueetl"), you can allocate a minimum of 2 DPUs. The default is 10 DPUs. This job type cannot have a fractional DPU allocation.</p> </li>
/// </ul>
#[doc(hidden)]
pub max_capacity: std::option::Option<f64>,
/// <p>The name of the <code>SecurityConfiguration</code> structure to be used with this job run.</p>
#[doc(hidden)]
pub security_configuration: std::option::Option<std::string::String>,
/// <p>Specifies configuration properties of a job run notification.</p>
#[doc(hidden)]
pub notification_property: std::option::Option<crate::model::NotificationProperty>,
/// <p>The type of predefined worker that is allocated when a job runs. Accepts a value of Standard, G.1X, G.2X, or G.025X.</p>
/// <ul>
/// <li> <p>For the <code>Standard</code> worker type, each worker provides 4 vCPU, 16 GB of memory and a 50GB disk, and 2 executors per worker.</p> </li>
/// <li> <p>For the <code>G.1X</code> worker type, each worker provides 4 vCPU, 16 GB of memory and a 64GB disk, and 1 executor per worker.</p> </li>
/// <li> <p>For the <code>G.2X</code> worker type, each worker provides 8 vCPU, 32 GB of memory and a 128GB disk, and 1 executor per worker.</p> </li>
/// <li> <p>For the <code>G.025X</code> worker type, each worker maps to 0.25 DPU (2 vCPU, 4 GB of memory, 64 GB disk), and provides 1 executor per worker. We recommend this worker type for low volume streaming jobs. This worker type is only available for Glue version 3.0 streaming jobs.</p> </li>
/// </ul>
#[doc(hidden)]
pub worker_type: std::option::Option<crate::model::WorkerType>,
/// <p>The number of workers of a defined <code>workerType</code> that are allocated when a job runs.</p>
#[doc(hidden)]
pub number_of_workers: std::option::Option<i32>,
/// <p>Indicates whether the job is run with a standard or flexible execution class. The standard execution-class is ideal for time-sensitive workloads that require fast job startup and dedicated resources.</p>
/// <p>The flexible execution class is appropriate for time-insensitive jobs whose start and completion times may vary. </p>
/// <p>Only jobs with Glue version 3.0 and above and command type <code>glueetl</code> will be allowed to set <code>ExecutionClass</code> to <code>FLEX</code>. The flexible execution class is available for Spark jobs.</p>
#[doc(hidden)]
pub execution_class: std::option::Option<crate::model::ExecutionClass>,
}
impl StartJobRunInput {
/// <p>The name of the job definition to use.</p>
pub fn job_name(&self) -> std::option::Option<&str> {
self.job_name.as_deref()
}
/// <p>The ID of a previous <code>JobRun</code> to retry.</p>
pub fn job_run_id(&self) -> std::option::Option<&str> {
self.job_run_id.as_deref()
}
/// <p>The job arguments specifically for this run. For this job run, they replace the default arguments set in the job definition itself.</p>
/// <p>You can specify arguments here that your own job-execution script consumes, as well as arguments that Glue itself consumes.</p>
/// <p>Job arguments may be logged. Do not pass plaintext secrets as arguments. Retrieve secrets from a Glue Connection, Secrets Manager or other secret management mechanism if you intend to keep them within the Job. </p>
/// <p>For information about how to specify and consume your own Job arguments, see the <a href="https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-python-calling.html">Calling Glue APIs in Python</a> topic in the developer guide.</p>
/// <p>For information about the key-value pairs that Glue consumes to set up your job, see the <a href="https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html">Special Parameters Used by Glue</a> topic in the developer guide.</p>
pub fn arguments(
&self,
) -> std::option::Option<&std::collections::HashMap<std::string::String, std::string::String>>
{
self.arguments.as_ref()
}
/// <p>This field is deprecated. Use <code>MaxCapacity</code> instead.</p>
/// <p>The number of Glue data processing units (DPUs) to allocate to this JobRun. You can allocate a minimum of 2 DPUs; the default is 10. A DPU is a relative measure of processing power that consists of 4 vCPUs of compute capacity and 16 GB of memory. For more information, see the <a href="https://aws.amazon.com/glue/pricing/">Glue pricing page</a>.</p>
#[deprecated(note = "This property is deprecated, use MaxCapacity instead.")]
pub fn allocated_capacity(&self) -> i32 {
self.allocated_capacity
}
/// <p>The <code>JobRun</code> timeout in minutes. This is the maximum time that a job run can consume resources before it is terminated and enters <code>TIMEOUT</code> status. This value overrides the timeout value set in the parent job.</p>
/// <p>Streaming jobs do not have a timeout. The default for non-streaming jobs is 2,880 minutes (48 hours).</p>
pub fn timeout(&self) -> std::option::Option<i32> {
self.timeout
}
/// <p>The number of Glue data processing units (DPUs) that can be allocated when this job runs. A DPU is a relative measure of processing power that consists of 4 vCPUs of compute capacity and 16 GB of memory. For more information, see the <a href="https://aws.amazon.com/glue/pricing/">Glue pricing page</a>.</p>
/// <p>Do not set <code>Max Capacity</code> if using <code>WorkerType</code> and <code>NumberOfWorkers</code>.</p>
/// <p>The value that can be allocated for <code>MaxCapacity</code> depends on whether you are running a Python shell job, or an Apache Spark ETL job:</p>
/// <ul>
/// <li> <p>When you specify a Python shell job (<code>JobCommand.Name</code>="pythonshell"), you can allocate either 0.0625 or 1 DPU. The default is 0.0625 DPU.</p> </li>
/// <li> <p>When you specify an Apache Spark ETL job (<code>JobCommand.Name</code>="glueetl"), you can allocate a minimum of 2 DPUs. The default is 10 DPUs. This job type cannot have a fractional DPU allocation.</p> </li>
/// </ul>
pub fn max_capacity(&self) -> std::option::Option<f64> {
self.max_capacity
}
/// <p>The name of the <code>SecurityConfiguration</code> structure to be used with this job run.</p>
pub fn security_configuration(&self) -> std::option::Option<&str> {
self.security_configuration.as_deref()
}
/// <p>Specifies configuration properties of a job run notification.</p>
pub fn notification_property(
&self,
) -> std::option::Option<&crate::model::NotificationProperty> {
self.notification_property.as_ref()
}
/// <p>The type of predefined worker that is allocated when a job runs. Accepts a value of Standard, G.1X, G.2X, or G.025X.</p>
/// <ul>
/// <li> <p>For the <code>Standard</code> worker type, each worker provides 4 vCPU, 16 GB of memory and a 50GB disk, and 2 executors per worker.</p> </li>
/// <li> <p>For the <code>G.1X</code> worker type, each worker provides 4 vCPU, 16 GB of memory and a 64GB disk, and 1 executor per worker.</p> </li>
/// <li> <p>For the <code>G.2X</code> worker type, each worker provides 8 vCPU, 32 GB of memory and a 128GB disk, and 1 executor per worker.</p> </li>
/// <li> <p>For the <code>G.025X</code> worker type, each worker maps to 0.25 DPU (2 vCPU, 4 GB of memory, 64 GB disk), and provides 1 executor per worker. We recommend this worker type for low volume streaming jobs. This worker type is only available for Glue version 3.0 streaming jobs.</p> </li>
/// </ul>
pub fn worker_type(&self) -> std::option::Option<&crate::model::WorkerType> {
self.worker_type.as_ref()
}
/// <p>The number of workers of a defined <code>workerType</code> that are allocated when a job runs.</p>
pub fn number_of_workers(&self) -> std::option::Option<i32> {
self.number_of_workers
}
/// <p>Indicates whether the job is run with a standard or flexible execution class. The standard execution-class is ideal for time-sensitive workloads that require fast job startup and dedicated resources.</p>
/// <p>The flexible execution class is appropriate for time-insensitive jobs whose start and completion times may vary. </p>
/// <p>Only jobs with Glue version 3.0 and above and command type <code>glueetl</code> will be allowed to set <code>ExecutionClass</code> to <code>FLEX</code>. The flexible execution class is available for Spark jobs.</p>
pub fn execution_class(&self) -> std::option::Option<&crate::model::ExecutionClass> {
self.execution_class.as_ref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct StartImportLabelsTaskRunInput {
/// <p>The unique identifier of the machine learning transform.</p>
#[doc(hidden)]
pub transform_id: std::option::Option<std::string::String>,
/// <p>The Amazon Simple Storage Service (Amazon S3) path from where you import the labels.</p>
#[doc(hidden)]
pub input_s3_path: std::option::Option<std::string::String>,
/// <p>Indicates whether to overwrite your existing labels.</p>
#[doc(hidden)]
pub replace_all_labels: bool,
}
impl StartImportLabelsTaskRunInput {
/// <p>The unique identifier of the machine learning transform.</p>
pub fn transform_id(&self) -> std::option::Option<&str> {
self.transform_id.as_deref()
}
/// <p>The Amazon Simple Storage Service (Amazon S3) path from where you import the labels.</p>
pub fn input_s3_path(&self) -> std::option::Option<&str> {
self.input_s3_path.as_deref()
}
/// <p>Indicates whether to overwrite your existing labels.</p>
pub fn replace_all_labels(&self) -> bool {
self.replace_all_labels
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct StartExportLabelsTaskRunInput {
/// <p>The unique identifier of the machine learning transform.</p>
#[doc(hidden)]
pub transform_id: std::option::Option<std::string::String>,
/// <p>The Amazon S3 path where you export the labels.</p>
#[doc(hidden)]
pub output_s3_path: std::option::Option<std::string::String>,
}
impl StartExportLabelsTaskRunInput {
/// <p>The unique identifier of the machine learning transform.</p>
pub fn transform_id(&self) -> std::option::Option<&str> {
self.transform_id.as_deref()
}
/// <p>The Amazon S3 path where you export the labels.</p>
pub fn output_s3_path(&self) -> std::option::Option<&str> {
self.output_s3_path.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct StartDataQualityRulesetEvaluationRunInput {
/// <p>The data source (Glue table) associated with this run.</p>
#[doc(hidden)]
pub data_source: std::option::Option<crate::model::DataSource>,
/// <p>An IAM role supplied to encrypt the results of the run.</p>
#[doc(hidden)]
pub role: std::option::Option<std::string::String>,
/// <p>The number of <code>G.1X</code> workers to be used in the run. The default is 5.</p>
#[doc(hidden)]
pub number_of_workers: std::option::Option<i32>,
/// <p>The timeout for a run in minutes. This is the maximum time that a run can consume resources before it is terminated and enters <code>TIMEOUT</code> status. The default is 2,880 minutes (48 hours).</p>
#[doc(hidden)]
pub timeout: std::option::Option<i32>,
/// <p>Used for idempotency and is recommended to be set to a random ID (such as a UUID) to avoid creating or starting multiple instances of the same resource.</p>
#[doc(hidden)]
pub client_token: std::option::Option<std::string::String>,
/// <p>Additional run options you can specify for an evaluation run.</p>
#[doc(hidden)]
pub additional_run_options:
std::option::Option<crate::model::DataQualityEvaluationRunAdditionalRunOptions>,
/// <p>A list of ruleset names.</p>
#[doc(hidden)]
pub ruleset_names: std::option::Option<std::vec::Vec<std::string::String>>,
}
impl StartDataQualityRulesetEvaluationRunInput {
/// <p>The data source (Glue table) associated with this run.</p>
pub fn data_source(&self) -> std::option::Option<&crate::model::DataSource> {
self.data_source.as_ref()
}
/// <p>An IAM role supplied to encrypt the results of the run.</p>
pub fn role(&self) -> std::option::Option<&str> {
self.role.as_deref()
}
/// <p>The number of <code>G.1X</code> workers to be used in the run. The default is 5.</p>
pub fn number_of_workers(&self) -> std::option::Option<i32> {
self.number_of_workers
}
/// <p>The timeout for a run in minutes. This is the maximum time that a run can consume resources before it is terminated and enters <code>TIMEOUT</code> status. The default is 2,880 minutes (48 hours).</p>
pub fn timeout(&self) -> std::option::Option<i32> {
self.timeout
}
/// <p>Used for idempotency and is recommended to be set to a random ID (such as a UUID) to avoid creating or starting multiple instances of the same resource.</p>
pub fn client_token(&self) -> std::option::Option<&str> {
self.client_token.as_deref()
}
/// <p>Additional run options you can specify for an evaluation run.</p>
pub fn additional_run_options(
&self,
) -> std::option::Option<&crate::model::DataQualityEvaluationRunAdditionalRunOptions> {
self.additional_run_options.as_ref()
}
/// <p>A list of ruleset names.</p>
pub fn ruleset_names(&self) -> std::option::Option<&[std::string::String]> {
self.ruleset_names.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct StartDataQualityRuleRecommendationRunInput {
/// <p>The data source (Glue table) associated with this run.</p>
#[doc(hidden)]
pub data_source: std::option::Option<crate::model::DataSource>,
/// <p>An IAM role supplied to encrypt the results of the run.</p>
#[doc(hidden)]
pub role: std::option::Option<std::string::String>,
/// <p>The number of <code>G.1X</code> workers to be used in the run. The default is 5.</p>
#[doc(hidden)]
pub number_of_workers: std::option::Option<i32>,
/// <p>The timeout for a run in minutes. This is the maximum time that a run can consume resources before it is terminated and enters <code>TIMEOUT</code> status. The default is 2,880 minutes (48 hours).</p>
#[doc(hidden)]
pub timeout: std::option::Option<i32>,
/// <p>A name for the ruleset.</p>
#[doc(hidden)]
pub created_ruleset_name: std::option::Option<std::string::String>,
/// <p>Used for idempotency and is recommended to be set to a random ID (such as a UUID) to avoid creating or starting multiple instances of the same resource.</p>
#[doc(hidden)]
pub client_token: std::option::Option<std::string::String>,
}
impl StartDataQualityRuleRecommendationRunInput {
/// <p>The data source (Glue table) associated with this run.</p>
pub fn data_source(&self) -> std::option::Option<&crate::model::DataSource> {
self.data_source.as_ref()
}
/// <p>An IAM role supplied to encrypt the results of the run.</p>
pub fn role(&self) -> std::option::Option<&str> {
self.role.as_deref()
}
/// <p>The number of <code>G.1X</code> workers to be used in the run. The default is 5.</p>
pub fn number_of_workers(&self) -> std::option::Option<i32> {
self.number_of_workers
}
/// <p>The timeout for a run in minutes. This is the maximum time that a run can consume resources before it is terminated and enters <code>TIMEOUT</code> status. The default is 2,880 minutes (48 hours).</p>
pub fn timeout(&self) -> std::option::Option<i32> {
self.timeout
}
/// <p>A name for the ruleset.</p>
pub fn created_ruleset_name(&self) -> std::option::Option<&str> {
self.created_ruleset_name.as_deref()
}
/// <p>Used for idempotency and is recommended to be set to a random ID (such as a UUID) to avoid creating or starting multiple instances of the same resource.</p>
pub fn client_token(&self) -> std::option::Option<&str> {
self.client_token.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct StartCrawlerScheduleInput {
/// <p>Name of the crawler to schedule.</p>
#[doc(hidden)]
pub crawler_name: std::option::Option<std::string::String>,
}
impl StartCrawlerScheduleInput {
/// <p>Name of the crawler to schedule.</p>
pub fn crawler_name(&self) -> std::option::Option<&str> {
self.crawler_name.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct StartCrawlerInput {
/// <p>Name of the crawler to start.</p>
#[doc(hidden)]
pub name: std::option::Option<std::string::String>,
}
impl StartCrawlerInput {
/// <p>Name of the crawler to start.</p>
pub fn name(&self) -> std::option::Option<&str> {
self.name.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct StartBlueprintRunInput {
/// <p>The name of the blueprint.</p>
#[doc(hidden)]
pub blueprint_name: std::option::Option<std::string::String>,
/// <p>Specifies the parameters as a <code>BlueprintParameters</code> object.</p>
#[doc(hidden)]
pub parameters: std::option::Option<std::string::String>,
/// <p>Specifies the IAM role used to create the workflow.</p>
#[doc(hidden)]
pub role_arn: std::option::Option<std::string::String>,
}
impl StartBlueprintRunInput {
/// <p>The name of the blueprint.</p>
pub fn blueprint_name(&self) -> std::option::Option<&str> {
self.blueprint_name.as_deref()
}
/// <p>Specifies the parameters as a <code>BlueprintParameters</code> object.</p>
pub fn parameters(&self) -> std::option::Option<&str> {
self.parameters.as_deref()
}
/// <p>Specifies the IAM role used to create the workflow.</p>
pub fn role_arn(&self) -> std::option::Option<&str> {
self.role_arn.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct SearchTablesInput {
/// <p>A unique identifier, consisting of <code> <i>account_id</i> </code>.</p>
#[doc(hidden)]
pub catalog_id: std::option::Option<std::string::String>,
/// <p>A continuation token, included if this is a continuation call.</p>
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
/// <p>A list of key-value pairs, and a comparator used to filter the search results. Returns all entities matching the predicate.</p>
/// <p>The <code>Comparator</code> member of the <code>PropertyPredicate</code> struct is used only for time fields, and can be omitted for other field types. Also, when comparing string values, such as when <code>Key=Name</code>, a fuzzy match algorithm is used. The <code>Key</code> field (for example, the value of the <code>Name</code> field) is split on certain punctuation characters, for example, -, :, #, etc. into tokens. Then each token is exact-match compared with the <code>Value</code> member of <code>PropertyPredicate</code>. For example, if <code>Key=Name</code> and <code>Value=link</code>, tables named <code>customer-link</code> and <code>xx-link-yy</code> are returned, but <code>xxlinkyy</code> is not returned.</p>
#[doc(hidden)]
pub filters: std::option::Option<std::vec::Vec<crate::model::PropertyPredicate>>,
/// <p>A string used for a text search.</p>
/// <p>Specifying a value in quotes filters based on an exact match to the value.</p>
#[doc(hidden)]
pub search_text: std::option::Option<std::string::String>,
/// <p>A list of criteria for sorting the results by a field name, in an ascending or descending order.</p>
#[doc(hidden)]
pub sort_criteria: std::option::Option<std::vec::Vec<crate::model::SortCriterion>>,
/// <p>The maximum number of tables to return in a single response.</p>
#[doc(hidden)]
pub max_results: std::option::Option<i32>,
/// <p>Allows you to specify that you want to search the tables shared with your account. The allowable values are <code>FOREIGN</code> or <code>ALL</code>. </p>
/// <ul>
/// <li> <p>If set to <code>FOREIGN</code>, will search the tables shared with your account. </p> </li>
/// <li> <p>If set to <code>ALL</code>, will search the tables shared with your account, as well as the tables in yor local account. </p> </li>
/// </ul>
#[doc(hidden)]
pub resource_share_type: std::option::Option<crate::model::ResourceShareType>,
}
impl SearchTablesInput {
/// <p>A unique identifier, consisting of <code> <i>account_id</i> </code>.</p>
pub fn catalog_id(&self) -> std::option::Option<&str> {
self.catalog_id.as_deref()
}
/// <p>A continuation token, included if this is a continuation call.</p>
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
/// <p>A list of key-value pairs, and a comparator used to filter the search results. Returns all entities matching the predicate.</p>
/// <p>The <code>Comparator</code> member of the <code>PropertyPredicate</code> struct is used only for time fields, and can be omitted for other field types. Also, when comparing string values, such as when <code>Key=Name</code>, a fuzzy match algorithm is used. The <code>Key</code> field (for example, the value of the <code>Name</code> field) is split on certain punctuation characters, for example, -, :, #, etc. into tokens. Then each token is exact-match compared with the <code>Value</code> member of <code>PropertyPredicate</code>. For example, if <code>Key=Name</code> and <code>Value=link</code>, tables named <code>customer-link</code> and <code>xx-link-yy</code> are returned, but <code>xxlinkyy</code> is not returned.</p>
pub fn filters(&self) -> std::option::Option<&[crate::model::PropertyPredicate]> {
self.filters.as_deref()
}
/// <p>A string used for a text search.</p>
/// <p>Specifying a value in quotes filters based on an exact match to the value.</p>
pub fn search_text(&self) -> std::option::Option<&str> {
self.search_text.as_deref()
}
/// <p>A list of criteria for sorting the results by a field name, in an ascending or descending order.</p>
pub fn sort_criteria(&self) -> std::option::Option<&[crate::model::SortCriterion]> {
self.sort_criteria.as_deref()
}
/// <p>The maximum number of tables to return in a single response.</p>
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
/// <p>Allows you to specify that you want to search the tables shared with your account. The allowable values are <code>FOREIGN</code> or <code>ALL</code>. </p>
/// <ul>
/// <li> <p>If set to <code>FOREIGN</code>, will search the tables shared with your account. </p> </li>
/// <li> <p>If set to <code>ALL</code>, will search the tables shared with your account, as well as the tables in yor local account. </p> </li>
/// </ul>
pub fn resource_share_type(&self) -> std::option::Option<&crate::model::ResourceShareType> {
self.resource_share_type.as_ref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct RunStatementInput {
/// <p>The Session Id of the statement to be run.</p>
#[doc(hidden)]
pub session_id: std::option::Option<std::string::String>,
/// <p>The statement code to be run.</p>
#[doc(hidden)]
pub code: std::option::Option<std::string::String>,
/// <p>The origin of the request.</p>
#[doc(hidden)]
pub request_origin: std::option::Option<std::string::String>,
}
impl RunStatementInput {
/// <p>The Session Id of the statement to be run.</p>
pub fn session_id(&self) -> std::option::Option<&str> {
self.session_id.as_deref()
}
/// <p>The statement code to be run.</p>
pub fn code(&self) -> std::option::Option<&str> {
self.code.as_deref()
}
/// <p>The origin of the request.</p>
pub fn request_origin(&self) -> std::option::Option<&str> {
self.request_origin.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ResumeWorkflowRunInput {
/// <p>The name of the workflow to resume.</p>
#[doc(hidden)]
pub name: std::option::Option<std::string::String>,
/// <p>The ID of the workflow run to resume.</p>
#[doc(hidden)]
pub run_id: std::option::Option<std::string::String>,
/// <p>A list of the node IDs for the nodes you want to restart. The nodes that are to be restarted must have a run attempt in the original run.</p>
#[doc(hidden)]
pub node_ids: std::option::Option<std::vec::Vec<std::string::String>>,
}
impl ResumeWorkflowRunInput {
/// <p>The name of the workflow to resume.</p>
pub fn name(&self) -> std::option::Option<&str> {
self.name.as_deref()
}
/// <p>The ID of the workflow run to resume.</p>
pub fn run_id(&self) -> std::option::Option<&str> {
self.run_id.as_deref()
}
/// <p>A list of the node IDs for the nodes you want to restart. The nodes that are to be restarted must have a run attempt in the original run.</p>
pub fn node_ids(&self) -> std::option::Option<&[std::string::String]> {
self.node_ids.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ResetJobBookmarkInput {
/// <p>The name of the job in question.</p>
#[doc(hidden)]
pub job_name: std::option::Option<std::string::String>,
/// <p>The unique run identifier associated with this job run.</p>
#[doc(hidden)]
pub run_id: std::option::Option<std::string::String>,
}
impl ResetJobBookmarkInput {
/// <p>The name of the job in question.</p>
pub fn job_name(&self) -> std::option::Option<&str> {
self.job_name.as_deref()
}
/// <p>The unique run identifier associated with this job run.</p>
pub fn run_id(&self) -> std::option::Option<&str> {
self.run_id.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct RemoveSchemaVersionMetadataInput {
/// <p>A wrapper structure that may contain the schema name and Amazon Resource Name (ARN).</p>
#[doc(hidden)]
pub schema_id: std::option::Option<crate::model::SchemaId>,
/// <p>The version number of the schema.</p>
#[doc(hidden)]
pub schema_version_number: std::option::Option<crate::model::SchemaVersionNumber>,
/// <p>The unique version ID of the schema version.</p>
#[doc(hidden)]
pub schema_version_id: std::option::Option<std::string::String>,
/// <p>The value of the metadata key.</p>
#[doc(hidden)]
pub metadata_key_value: std::option::Option<crate::model::MetadataKeyValuePair>,
}
impl RemoveSchemaVersionMetadataInput {
/// <p>A wrapper structure that may contain the schema name and Amazon Resource Name (ARN).</p>
pub fn schema_id(&self) -> std::option::Option<&crate::model::SchemaId> {
self.schema_id.as_ref()
}
/// <p>The version number of the schema.</p>
pub fn schema_version_number(&self) -> std::option::Option<&crate::model::SchemaVersionNumber> {
self.schema_version_number.as_ref()
}
/// <p>The unique version ID of the schema version.</p>
pub fn schema_version_id(&self) -> std::option::Option<&str> {
self.schema_version_id.as_deref()
}
/// <p>The value of the metadata key.</p>
pub fn metadata_key_value(&self) -> std::option::Option<&crate::model::MetadataKeyValuePair> {
self.metadata_key_value.as_ref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct RegisterSchemaVersionInput {
/// <p>This is a wrapper structure to contain schema identity fields. The structure contains:</p>
/// <ul>
/// <li> <p>SchemaId$SchemaArn: The Amazon Resource Name (ARN) of the schema. Either <code>SchemaArn</code> or <code>SchemaName</code> and <code>RegistryName</code> has to be provided.</p> </li>
/// <li> <p>SchemaId$SchemaName: The name of the schema. Either <code>SchemaArn</code> or <code>SchemaName</code> and <code>RegistryName</code> has to be provided.</p> </li>
/// </ul>
#[doc(hidden)]
pub schema_id: std::option::Option<crate::model::SchemaId>,
/// <p>The schema definition using the <code>DataFormat</code> setting for the <code>SchemaName</code>.</p>
#[doc(hidden)]
pub schema_definition: std::option::Option<std::string::String>,
}
impl RegisterSchemaVersionInput {
/// <p>This is a wrapper structure to contain schema identity fields. The structure contains:</p>
/// <ul>
/// <li> <p>SchemaId$SchemaArn: The Amazon Resource Name (ARN) of the schema. Either <code>SchemaArn</code> or <code>SchemaName</code> and <code>RegistryName</code> has to be provided.</p> </li>
/// <li> <p>SchemaId$SchemaName: The name of the schema. Either <code>SchemaArn</code> or <code>SchemaName</code> and <code>RegistryName</code> has to be provided.</p> </li>
/// </ul>
pub fn schema_id(&self) -> std::option::Option<&crate::model::SchemaId> {
self.schema_id.as_ref()
}
/// <p>The schema definition using the <code>DataFormat</code> setting for the <code>SchemaName</code>.</p>
pub fn schema_definition(&self) -> std::option::Option<&str> {
self.schema_definition.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct QuerySchemaVersionMetadataInput {
/// <p>A wrapper structure that may contain the schema name and Amazon Resource Name (ARN).</p>
#[doc(hidden)]
pub schema_id: std::option::Option<crate::model::SchemaId>,
/// <p>The version number of the schema.</p>
#[doc(hidden)]
pub schema_version_number: std::option::Option<crate::model::SchemaVersionNumber>,
/// <p>The unique version ID of the schema version.</p>
#[doc(hidden)]
pub schema_version_id: std::option::Option<std::string::String>,
/// <p>Search key-value pairs for metadata, if they are not provided all the metadata information will be fetched.</p>
#[doc(hidden)]
pub metadata_list: std::option::Option<std::vec::Vec<crate::model::MetadataKeyValuePair>>,
/// <p>Maximum number of results required per page. If the value is not supplied, this will be defaulted to 25 per page.</p>
#[doc(hidden)]
pub max_results: i32,
/// <p>A continuation token, if this is a continuation call.</p>
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
}
impl QuerySchemaVersionMetadataInput {
/// <p>A wrapper structure that may contain the schema name and Amazon Resource Name (ARN).</p>
pub fn schema_id(&self) -> std::option::Option<&crate::model::SchemaId> {
self.schema_id.as_ref()
}
/// <p>The version number of the schema.</p>
pub fn schema_version_number(&self) -> std::option::Option<&crate::model::SchemaVersionNumber> {
self.schema_version_number.as_ref()
}
/// <p>The unique version ID of the schema version.</p>
pub fn schema_version_id(&self) -> std::option::Option<&str> {
self.schema_version_id.as_deref()
}
/// <p>Search key-value pairs for metadata, if they are not provided all the metadata information will be fetched.</p>
pub fn metadata_list(&self) -> std::option::Option<&[crate::model::MetadataKeyValuePair]> {
self.metadata_list.as_deref()
}
/// <p>Maximum number of results required per page. If the value is not supplied, this will be defaulted to 25 per page.</p>
pub fn max_results(&self) -> i32 {
self.max_results
}
/// <p>A continuation token, if this is a continuation call.</p>
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct PutWorkflowRunPropertiesInput {
/// <p>Name of the workflow which was run.</p>
#[doc(hidden)]
pub name: std::option::Option<std::string::String>,
/// <p>The ID of the workflow run for which the run properties should be updated.</p>
#[doc(hidden)]
pub run_id: std::option::Option<std::string::String>,
/// <p>The properties to put for the specified run.</p>
#[doc(hidden)]
pub run_properties:
std::option::Option<std::collections::HashMap<std::string::String, std::string::String>>,
}
impl PutWorkflowRunPropertiesInput {
/// <p>Name of the workflow which was run.</p>
pub fn name(&self) -> std::option::Option<&str> {
self.name.as_deref()
}
/// <p>The ID of the workflow run for which the run properties should be updated.</p>
pub fn run_id(&self) -> std::option::Option<&str> {
self.run_id.as_deref()
}
/// <p>The properties to put for the specified run.</p>
pub fn run_properties(
&self,
) -> std::option::Option<&std::collections::HashMap<std::string::String, std::string::String>>
{
self.run_properties.as_ref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct PutSchemaVersionMetadataInput {
/// <p>The unique ID for the schema.</p>
#[doc(hidden)]
pub schema_id: std::option::Option<crate::model::SchemaId>,
/// <p>The version number of the schema.</p>
#[doc(hidden)]
pub schema_version_number: std::option::Option<crate::model::SchemaVersionNumber>,
/// <p>The unique version ID of the schema version.</p>
#[doc(hidden)]
pub schema_version_id: std::option::Option<std::string::String>,
/// <p>The metadata key's corresponding value.</p>
#[doc(hidden)]
pub metadata_key_value: std::option::Option<crate::model::MetadataKeyValuePair>,
}
impl PutSchemaVersionMetadataInput {
/// <p>The unique ID for the schema.</p>
pub fn schema_id(&self) -> std::option::Option<&crate::model::SchemaId> {
self.schema_id.as_ref()
}
/// <p>The version number of the schema.</p>
pub fn schema_version_number(&self) -> std::option::Option<&crate::model::SchemaVersionNumber> {
self.schema_version_number.as_ref()
}
/// <p>The unique version ID of the schema version.</p>
pub fn schema_version_id(&self) -> std::option::Option<&str> {
self.schema_version_id.as_deref()
}
/// <p>The metadata key's corresponding value.</p>
pub fn metadata_key_value(&self) -> std::option::Option<&crate::model::MetadataKeyValuePair> {
self.metadata_key_value.as_ref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct PutResourcePolicyInput {
/// <p>Contains the policy document to set, in JSON format.</p>
#[doc(hidden)]
pub policy_in_json: std::option::Option<std::string::String>,
/// <p>Do not use. For internal use only.</p>
#[doc(hidden)]
pub resource_arn: std::option::Option<std::string::String>,
/// <p>The hash value returned when the previous policy was set using <code>PutResourcePolicy</code>. Its purpose is to prevent concurrent modifications of a policy. Do not use this parameter if no previous policy has been set.</p>
#[doc(hidden)]
pub policy_hash_condition: std::option::Option<std::string::String>,
/// <p>A value of <code>MUST_EXIST</code> is used to update a policy. A value of <code>NOT_EXIST</code> is used to create a new policy. If a value of <code>NONE</code> or a null value is used, the call does not depend on the existence of a policy.</p>
#[doc(hidden)]
pub policy_exists_condition: std::option::Option<crate::model::ExistCondition>,
/// <p>If <code>'TRUE'</code>, indicates that you are using both methods to grant cross-account access to Data Catalog resources:</p>
/// <ul>
/// <li> <p>By directly updating the resource policy with <code>PutResourePolicy</code> </p> </li>
/// <li> <p>By using the <b>Grant permissions</b> command on the Amazon Web Services Management Console.</p> </li>
/// </ul>
/// <p>Must be set to <code>'TRUE'</code> if you have already used the Management Console to grant cross-account access, otherwise the call fails. Default is 'FALSE'.</p>
#[doc(hidden)]
pub enable_hybrid: std::option::Option<crate::model::EnableHybridValues>,
}
impl PutResourcePolicyInput {
/// <p>Contains the policy document to set, in JSON format.</p>
pub fn policy_in_json(&self) -> std::option::Option<&str> {
self.policy_in_json.as_deref()
}
/// <p>Do not use. For internal use only.</p>
pub fn resource_arn(&self) -> std::option::Option<&str> {
self.resource_arn.as_deref()
}
/// <p>The hash value returned when the previous policy was set using <code>PutResourcePolicy</code>. Its purpose is to prevent concurrent modifications of a policy. Do not use this parameter if no previous policy has been set.</p>
pub fn policy_hash_condition(&self) -> std::option::Option<&str> {
self.policy_hash_condition.as_deref()
}
/// <p>A value of <code>MUST_EXIST</code> is used to update a policy. A value of <code>NOT_EXIST</code> is used to create a new policy. If a value of <code>NONE</code> or a null value is used, the call does not depend on the existence of a policy.</p>
pub fn policy_exists_condition(&self) -> std::option::Option<&crate::model::ExistCondition> {
self.policy_exists_condition.as_ref()
}
/// <p>If <code>'TRUE'</code>, indicates that you are using both methods to grant cross-account access to Data Catalog resources:</p>
/// <ul>
/// <li> <p>By directly updating the resource policy with <code>PutResourePolicy</code> </p> </li>
/// <li> <p>By using the <b>Grant permissions</b> command on the Amazon Web Services Management Console.</p> </li>
/// </ul>
/// <p>Must be set to <code>'TRUE'</code> if you have already used the Management Console to grant cross-account access, otherwise the call fails. Default is 'FALSE'.</p>
pub fn enable_hybrid(&self) -> std::option::Option<&crate::model::EnableHybridValues> {
self.enable_hybrid.as_ref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct PutDataCatalogEncryptionSettingsInput {
/// <p>The ID of the Data Catalog to set the security configuration for. If none is provided, the Amazon Web Services account ID is used by default.</p>
#[doc(hidden)]
pub catalog_id: std::option::Option<std::string::String>,
/// <p>The security configuration to set.</p>
#[doc(hidden)]
pub data_catalog_encryption_settings:
std::option::Option<crate::model::DataCatalogEncryptionSettings>,
}
impl PutDataCatalogEncryptionSettingsInput {
/// <p>The ID of the Data Catalog to set the security configuration for. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(&self) -> std::option::Option<&str> {
self.catalog_id.as_deref()
}
/// <p>The security configuration to set.</p>
pub fn data_catalog_encryption_settings(
&self,
) -> std::option::Option<&crate::model::DataCatalogEncryptionSettings> {
self.data_catalog_encryption_settings.as_ref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListWorkflowsInput {
/// <p>A continuation token, if this is a continuation request.</p>
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
/// <p>The maximum size of a list to return.</p>
#[doc(hidden)]
pub max_results: std::option::Option<i32>,
}
impl ListWorkflowsInput {
/// <p>A continuation token, if this is a continuation request.</p>
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
/// <p>The maximum size of a list to return.</p>
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListTriggersInput {
/// <p>A continuation token, if this is a continuation request.</p>
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
/// <p> The name of the job for which to retrieve triggers. The trigger that can start this job is returned. If there is no such trigger, all triggers are returned.</p>
#[doc(hidden)]
pub dependent_job_name: std::option::Option<std::string::String>,
/// <p>The maximum size of a list to return.</p>
#[doc(hidden)]
pub max_results: std::option::Option<i32>,
/// <p>Specifies to return only these tagged resources.</p>
#[doc(hidden)]
pub tags:
std::option::Option<std::collections::HashMap<std::string::String, std::string::String>>,
}
impl ListTriggersInput {
/// <p>A continuation token, if this is a continuation request.</p>
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
/// <p> The name of the job for which to retrieve triggers. The trigger that can start this job is returned. If there is no such trigger, all triggers are returned.</p>
pub fn dependent_job_name(&self) -> std::option::Option<&str> {
self.dependent_job_name.as_deref()
}
/// <p>The maximum size of a list to return.</p>
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
/// <p>Specifies to return only these tagged resources.</p>
pub fn tags(
&self,
) -> std::option::Option<&std::collections::HashMap<std::string::String, std::string::String>>
{
self.tags.as_ref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListStatementsInput {
/// <p>The Session ID of the statements.</p>
#[doc(hidden)]
pub session_id: std::option::Option<std::string::String>,
/// <p>The origin of the request to list statements.</p>
#[doc(hidden)]
pub request_origin: std::option::Option<std::string::String>,
/// <p>A continuation token, if this is a continuation call.</p>
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
}
impl ListStatementsInput {
/// <p>The Session ID of the statements.</p>
pub fn session_id(&self) -> std::option::Option<&str> {
self.session_id.as_deref()
}
/// <p>The origin of the request to list statements.</p>
pub fn request_origin(&self) -> std::option::Option<&str> {
self.request_origin.as_deref()
}
/// <p>A continuation token, if this is a continuation call.</p>
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListSessionsInput {
/// <p>The token for the next set of results, or null if there are no more result. </p>
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
/// <p>The maximum number of results. </p>
#[doc(hidden)]
pub max_results: std::option::Option<i32>,
/// <p>Tags belonging to the session. </p>
#[doc(hidden)]
pub tags:
std::option::Option<std::collections::HashMap<std::string::String, std::string::String>>,
/// <p>The origin of the request. </p>
#[doc(hidden)]
pub request_origin: std::option::Option<std::string::String>,
}
impl ListSessionsInput {
/// <p>The token for the next set of results, or null if there are no more result. </p>
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
/// <p>The maximum number of results. </p>
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
/// <p>Tags belonging to the session. </p>
pub fn tags(
&self,
) -> std::option::Option<&std::collections::HashMap<std::string::String, std::string::String>>
{
self.tags.as_ref()
}
/// <p>The origin of the request. </p>
pub fn request_origin(&self) -> std::option::Option<&str> {
self.request_origin.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListSchemaVersionsInput {
/// <p>This is a wrapper structure to contain schema identity fields. The structure contains:</p>
/// <ul>
/// <li> <p>SchemaId$SchemaArn: The Amazon Resource Name (ARN) of the schema. Either <code>SchemaArn</code> or <code>SchemaName</code> and <code>RegistryName</code> has to be provided.</p> </li>
/// <li> <p>SchemaId$SchemaName: The name of the schema. Either <code>SchemaArn</code> or <code>SchemaName</code> and <code>RegistryName</code> has to be provided.</p> </li>
/// </ul>
#[doc(hidden)]
pub schema_id: std::option::Option<crate::model::SchemaId>,
/// <p>Maximum number of results required per page. If the value is not supplied, this will be defaulted to 25 per page.</p>
#[doc(hidden)]
pub max_results: std::option::Option<i32>,
/// <p>A continuation token, if this is a continuation call.</p>
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
}
impl ListSchemaVersionsInput {
/// <p>This is a wrapper structure to contain schema identity fields. The structure contains:</p>
/// <ul>
/// <li> <p>SchemaId$SchemaArn: The Amazon Resource Name (ARN) of the schema. Either <code>SchemaArn</code> or <code>SchemaName</code> and <code>RegistryName</code> has to be provided.</p> </li>
/// <li> <p>SchemaId$SchemaName: The name of the schema. Either <code>SchemaArn</code> or <code>SchemaName</code> and <code>RegistryName</code> has to be provided.</p> </li>
/// </ul>
pub fn schema_id(&self) -> std::option::Option<&crate::model::SchemaId> {
self.schema_id.as_ref()
}
/// <p>Maximum number of results required per page. If the value is not supplied, this will be defaulted to 25 per page.</p>
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
/// <p>A continuation token, if this is a continuation call.</p>
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListSchemasInput {
/// <p>A wrapper structure that may contain the registry name and Amazon Resource Name (ARN).</p>
#[doc(hidden)]
pub registry_id: std::option::Option<crate::model::RegistryId>,
/// <p>Maximum number of results required per page. If the value is not supplied, this will be defaulted to 25 per page.</p>
#[doc(hidden)]
pub max_results: std::option::Option<i32>,
/// <p>A continuation token, if this is a continuation call.</p>
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
}
impl ListSchemasInput {
/// <p>A wrapper structure that may contain the registry name and Amazon Resource Name (ARN).</p>
pub fn registry_id(&self) -> std::option::Option<&crate::model::RegistryId> {
self.registry_id.as_ref()
}
/// <p>Maximum number of results required per page. If the value is not supplied, this will be defaulted to 25 per page.</p>
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
/// <p>A continuation token, if this is a continuation call.</p>
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListRegistriesInput {
/// <p>Maximum number of results required per page. If the value is not supplied, this will be defaulted to 25 per page.</p>
#[doc(hidden)]
pub max_results: std::option::Option<i32>,
/// <p>A continuation token, if this is a continuation call.</p>
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
}
impl ListRegistriesInput {
/// <p>Maximum number of results required per page. If the value is not supplied, this will be defaulted to 25 per page.</p>
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
/// <p>A continuation token, if this is a continuation call.</p>
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListMlTransformsInput {
/// <p>A continuation token, if this is a continuation request.</p>
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
/// <p>The maximum size of a list to return.</p>
#[doc(hidden)]
pub max_results: std::option::Option<i32>,
/// <p>A <code>TransformFilterCriteria</code> used to filter the machine learning transforms.</p>
#[doc(hidden)]
pub filter: std::option::Option<crate::model::TransformFilterCriteria>,
/// <p>A <code>TransformSortCriteria</code> used to sort the machine learning transforms.</p>
#[doc(hidden)]
pub sort: std::option::Option<crate::model::TransformSortCriteria>,
/// <p>Specifies to return only these tagged resources.</p>
#[doc(hidden)]
pub tags:
std::option::Option<std::collections::HashMap<std::string::String, std::string::String>>,
}
impl ListMlTransformsInput {
/// <p>A continuation token, if this is a continuation request.</p>
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
/// <p>The maximum size of a list to return.</p>
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
/// <p>A <code>TransformFilterCriteria</code> used to filter the machine learning transforms.</p>
pub fn filter(&self) -> std::option::Option<&crate::model::TransformFilterCriteria> {
self.filter.as_ref()
}
/// <p>A <code>TransformSortCriteria</code> used to sort the machine learning transforms.</p>
pub fn sort(&self) -> std::option::Option<&crate::model::TransformSortCriteria> {
self.sort.as_ref()
}
/// <p>Specifies to return only these tagged resources.</p>
pub fn tags(
&self,
) -> std::option::Option<&std::collections::HashMap<std::string::String, std::string::String>>
{
self.tags.as_ref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListJobsInput {
/// <p>A continuation token, if this is a continuation request.</p>
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
/// <p>The maximum size of a list to return.</p>
#[doc(hidden)]
pub max_results: std::option::Option<i32>,
/// <p>Specifies to return only these tagged resources.</p>
#[doc(hidden)]
pub tags:
std::option::Option<std::collections::HashMap<std::string::String, std::string::String>>,
}
impl ListJobsInput {
/// <p>A continuation token, if this is a continuation request.</p>
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
/// <p>The maximum size of a list to return.</p>
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
/// <p>Specifies to return only these tagged resources.</p>
pub fn tags(
&self,
) -> std::option::Option<&std::collections::HashMap<std::string::String, std::string::String>>
{
self.tags.as_ref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListDevEndpointsInput {
/// <p>A continuation token, if this is a continuation request.</p>
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
/// <p>The maximum size of a list to return.</p>
#[doc(hidden)]
pub max_results: std::option::Option<i32>,
/// <p>Specifies to return only these tagged resources.</p>
#[doc(hidden)]
pub tags:
std::option::Option<std::collections::HashMap<std::string::String, std::string::String>>,
}
impl ListDevEndpointsInput {
/// <p>A continuation token, if this is a continuation request.</p>
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
/// <p>The maximum size of a list to return.</p>
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
/// <p>Specifies to return only these tagged resources.</p>
pub fn tags(
&self,
) -> std::option::Option<&std::collections::HashMap<std::string::String, std::string::String>>
{
self.tags.as_ref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListDataQualityRulesetsInput {
/// <p>A paginated token to offset the results.</p>
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
/// <p>The maximum number of results to return.</p>
#[doc(hidden)]
pub max_results: std::option::Option<i32>,
/// <p>The filter criteria. </p>
#[doc(hidden)]
pub filter: std::option::Option<crate::model::DataQualityRulesetFilterCriteria>,
/// <p>A list of key-value pair tags.</p>
#[doc(hidden)]
pub tags:
std::option::Option<std::collections::HashMap<std::string::String, std::string::String>>,
}
impl ListDataQualityRulesetsInput {
/// <p>A paginated token to offset the results.</p>
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
/// <p>The maximum number of results to return.</p>
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
/// <p>The filter criteria. </p>
pub fn filter(&self) -> std::option::Option<&crate::model::DataQualityRulesetFilterCriteria> {
self.filter.as_ref()
}
/// <p>A list of key-value pair tags.</p>
pub fn tags(
&self,
) -> std::option::Option<&std::collections::HashMap<std::string::String, std::string::String>>
{
self.tags.as_ref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListDataQualityRulesetEvaluationRunsInput {
/// <p>The filter criteria.</p>
#[doc(hidden)]
pub filter: std::option::Option<crate::model::DataQualityRulesetEvaluationRunFilter>,
/// <p>A paginated token to offset the results.</p>
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
/// <p>The maximum number of results to return.</p>
#[doc(hidden)]
pub max_results: std::option::Option<i32>,
}
impl ListDataQualityRulesetEvaluationRunsInput {
/// <p>The filter criteria.</p>
pub fn filter(
&self,
) -> std::option::Option<&crate::model::DataQualityRulesetEvaluationRunFilter> {
self.filter.as_ref()
}
/// <p>A paginated token to offset the results.</p>
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
/// <p>The maximum number of results to return.</p>
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListDataQualityRuleRecommendationRunsInput {
/// <p>The filter criteria.</p>
#[doc(hidden)]
pub filter: std::option::Option<crate::model::DataQualityRuleRecommendationRunFilter>,
/// <p>A paginated token to offset the results.</p>
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
/// <p>The maximum number of results to return.</p>
#[doc(hidden)]
pub max_results: std::option::Option<i32>,
}
impl ListDataQualityRuleRecommendationRunsInput {
/// <p>The filter criteria.</p>
pub fn filter(
&self,
) -> std::option::Option<&crate::model::DataQualityRuleRecommendationRunFilter> {
self.filter.as_ref()
}
/// <p>A paginated token to offset the results.</p>
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
/// <p>The maximum number of results to return.</p>
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListDataQualityResultsInput {
/// <p>The filter criteria.</p>
#[doc(hidden)]
pub filter: std::option::Option<crate::model::DataQualityResultFilterCriteria>,
/// <p>A paginated token to offset the results.</p>
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
/// <p>The maximum number of results to return.</p>
#[doc(hidden)]
pub max_results: std::option::Option<i32>,
}
impl ListDataQualityResultsInput {
/// <p>The filter criteria.</p>
pub fn filter(&self) -> std::option::Option<&crate::model::DataQualityResultFilterCriteria> {
self.filter.as_ref()
}
/// <p>A paginated token to offset the results.</p>
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
/// <p>The maximum number of results to return.</p>
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListCustomEntityTypesInput {
/// <p>A paginated token to offset the results.</p>
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
/// <p>The maximum number of results to return.</p>
#[doc(hidden)]
pub max_results: std::option::Option<i32>,
}
impl ListCustomEntityTypesInput {
/// <p>A paginated token to offset the results.</p>
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
/// <p>The maximum number of results to return.</p>
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListCrawlsInput {
/// <p>The name of the crawler whose runs you want to retrieve.</p>
#[doc(hidden)]
pub crawler_name: std::option::Option<std::string::String>,
/// <p>The maximum number of results to return. The default is 20, and maximum is 100.</p>
#[doc(hidden)]
pub max_results: std::option::Option<i32>,
/// <p>Filters the crawls by the criteria you specify in a list of <code>CrawlsFilter</code> objects.</p>
#[doc(hidden)]
pub filters: std::option::Option<std::vec::Vec<crate::model::CrawlsFilter>>,
/// <p>A continuation token, if this is a continuation call.</p>
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
}
impl ListCrawlsInput {
/// <p>The name of the crawler whose runs you want to retrieve.</p>
pub fn crawler_name(&self) -> std::option::Option<&str> {
self.crawler_name.as_deref()
}
/// <p>The maximum number of results to return. The default is 20, and maximum is 100.</p>
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
/// <p>Filters the crawls by the criteria you specify in a list of <code>CrawlsFilter</code> objects.</p>
pub fn filters(&self) -> std::option::Option<&[crate::model::CrawlsFilter]> {
self.filters.as_deref()
}
/// <p>A continuation token, if this is a continuation call.</p>
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListCrawlersInput {
/// <p>The maximum size of a list to return.</p>
#[doc(hidden)]
pub max_results: std::option::Option<i32>,
/// <p>A continuation token, if this is a continuation request.</p>
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
/// <p>Specifies to return only these tagged resources.</p>
#[doc(hidden)]
pub tags:
std::option::Option<std::collections::HashMap<std::string::String, std::string::String>>,
}
impl ListCrawlersInput {
/// <p>The maximum size of a list to return.</p>
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
/// <p>A continuation token, if this is a continuation request.</p>
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
/// <p>Specifies to return only these tagged resources.</p>
pub fn tags(
&self,
) -> std::option::Option<&std::collections::HashMap<std::string::String, std::string::String>>
{
self.tags.as_ref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListBlueprintsInput {
/// <p>A continuation token, if this is a continuation request.</p>
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
/// <p>The maximum size of a list to return.</p>
#[doc(hidden)]
pub max_results: std::option::Option<i32>,
/// <p>Filters the list by an Amazon Web Services resource tag.</p>
#[doc(hidden)]
pub tags:
std::option::Option<std::collections::HashMap<std::string::String, std::string::String>>,
}
impl ListBlueprintsInput {
/// <p>A continuation token, if this is a continuation request.</p>
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
/// <p>The maximum size of a list to return.</p>
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
/// <p>Filters the list by an Amazon Web Services resource tag.</p>
pub fn tags(
&self,
) -> std::option::Option<&std::collections::HashMap<std::string::String, std::string::String>>
{
self.tags.as_ref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ImportCatalogToGlueInput {
/// <p>The ID of the catalog to import. Currently, this should be the Amazon Web Services account ID.</p>
#[doc(hidden)]
pub catalog_id: std::option::Option<std::string::String>,
}
impl ImportCatalogToGlueInput {
/// <p>The ID of the catalog to import. Currently, this should be the Amazon Web Services account ID.</p>
pub fn catalog_id(&self) -> std::option::Option<&str> {
self.catalog_id.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetWorkflowRunsInput {
/// <p>Name of the workflow whose metadata of runs should be returned.</p>
#[doc(hidden)]
pub name: std::option::Option<std::string::String>,
/// <p>Specifies whether to include the workflow graph in response or not.</p>
#[doc(hidden)]
pub include_graph: std::option::Option<bool>,
/// <p>The maximum size of the response.</p>
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
/// <p>The maximum number of workflow runs to be included in the response.</p>
#[doc(hidden)]
pub max_results: std::option::Option<i32>,
}
impl GetWorkflowRunsInput {
/// <p>Name of the workflow whose metadata of runs should be returned.</p>
pub fn name(&self) -> std::option::Option<&str> {
self.name.as_deref()
}
/// <p>Specifies whether to include the workflow graph in response or not.</p>
pub fn include_graph(&self) -> std::option::Option<bool> {
self.include_graph
}
/// <p>The maximum size of the response.</p>
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
/// <p>The maximum number of workflow runs to be included in the response.</p>
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetWorkflowRunPropertiesInput {
/// <p>Name of the workflow which was run.</p>
#[doc(hidden)]
pub name: std::option::Option<std::string::String>,
/// <p>The ID of the workflow run whose run properties should be returned.</p>
#[doc(hidden)]
pub run_id: std::option::Option<std::string::String>,
}
impl GetWorkflowRunPropertiesInput {
/// <p>Name of the workflow which was run.</p>
pub fn name(&self) -> std::option::Option<&str> {
self.name.as_deref()
}
/// <p>The ID of the workflow run whose run properties should be returned.</p>
pub fn run_id(&self) -> std::option::Option<&str> {
self.run_id.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetWorkflowRunInput {
/// <p>Name of the workflow being run.</p>
#[doc(hidden)]
pub name: std::option::Option<std::string::String>,
/// <p>The ID of the workflow run.</p>
#[doc(hidden)]
pub run_id: std::option::Option<std::string::String>,
/// <p>Specifies whether to include the workflow graph in response or not.</p>
#[doc(hidden)]
pub include_graph: std::option::Option<bool>,
}
impl GetWorkflowRunInput {
/// <p>Name of the workflow being run.</p>
pub fn name(&self) -> std::option::Option<&str> {
self.name.as_deref()
}
/// <p>The ID of the workflow run.</p>
pub fn run_id(&self) -> std::option::Option<&str> {
self.run_id.as_deref()
}
/// <p>Specifies whether to include the workflow graph in response or not.</p>
pub fn include_graph(&self) -> std::option::Option<bool> {
self.include_graph
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetWorkflowInput {
/// <p>The name of the workflow to retrieve.</p>
#[doc(hidden)]
pub name: std::option::Option<std::string::String>,
/// <p>Specifies whether to include a graph when returning the workflow resource metadata.</p>
#[doc(hidden)]
pub include_graph: std::option::Option<bool>,
}
impl GetWorkflowInput {
/// <p>The name of the workflow to retrieve.</p>
pub fn name(&self) -> std::option::Option<&str> {
self.name.as_deref()
}
/// <p>Specifies whether to include a graph when returning the workflow resource metadata.</p>
pub fn include_graph(&self) -> std::option::Option<bool> {
self.include_graph
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetUserDefinedFunctionsInput {
/// <p>The ID of the Data Catalog where the functions to be retrieved are located. If none is provided, the Amazon Web Services account ID is used by default.</p>
#[doc(hidden)]
pub catalog_id: std::option::Option<std::string::String>,
/// <p>The name of the catalog database where the functions are located. If none is provided, functions from all the databases across the catalog will be returned.</p>
#[doc(hidden)]
pub database_name: std::option::Option<std::string::String>,
/// <p>An optional function-name pattern string that filters the function definitions returned.</p>
#[doc(hidden)]
pub pattern: std::option::Option<std::string::String>,
/// <p>A continuation token, if this is a continuation call.</p>
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
/// <p>The maximum number of functions to return in one response.</p>
#[doc(hidden)]
pub max_results: std::option::Option<i32>,
}
impl GetUserDefinedFunctionsInput {
/// <p>The ID of the Data Catalog where the functions to be retrieved are located. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(&self) -> std::option::Option<&str> {
self.catalog_id.as_deref()
}
/// <p>The name of the catalog database where the functions are located. If none is provided, functions from all the databases across the catalog will be returned.</p>
pub fn database_name(&self) -> std::option::Option<&str> {
self.database_name.as_deref()
}
/// <p>An optional function-name pattern string that filters the function definitions returned.</p>
pub fn pattern(&self) -> std::option::Option<&str> {
self.pattern.as_deref()
}
/// <p>A continuation token, if this is a continuation call.</p>
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
/// <p>The maximum number of functions to return in one response.</p>
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetUserDefinedFunctionInput {
/// <p>The ID of the Data Catalog where the function to be retrieved is located. If none is provided, the Amazon Web Services account ID is used by default.</p>
#[doc(hidden)]
pub catalog_id: std::option::Option<std::string::String>,
/// <p>The name of the catalog database where the function is located.</p>
#[doc(hidden)]
pub database_name: std::option::Option<std::string::String>,
/// <p>The name of the function.</p>
#[doc(hidden)]
pub function_name: std::option::Option<std::string::String>,
}
impl GetUserDefinedFunctionInput {
/// <p>The ID of the Data Catalog where the function to be retrieved is located. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(&self) -> std::option::Option<&str> {
self.catalog_id.as_deref()
}
/// <p>The name of the catalog database where the function is located.</p>
pub fn database_name(&self) -> std::option::Option<&str> {
self.database_name.as_deref()
}
/// <p>The name of the function.</p>
pub fn function_name(&self) -> std::option::Option<&str> {
self.function_name.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetUnfilteredTableMetadataInput {
#[allow(missing_docs)] // documentation missing in model
#[doc(hidden)]
pub catalog_id: std::option::Option<std::string::String>,
#[allow(missing_docs)] // documentation missing in model
#[doc(hidden)]
pub database_name: std::option::Option<std::string::String>,
#[allow(missing_docs)] // documentation missing in model
#[doc(hidden)]
pub name: std::option::Option<std::string::String>,
/// <p>A structure containing information for audit.</p>
#[doc(hidden)]
pub audit_context: std::option::Option<crate::model::AuditContext>,
#[allow(missing_docs)] // documentation missing in model
#[doc(hidden)]
pub supported_permission_types:
std::option::Option<std::vec::Vec<crate::model::PermissionType>>,
}
impl GetUnfilteredTableMetadataInput {
#[allow(missing_docs)] // documentation missing in model
pub fn catalog_id(&self) -> std::option::Option<&str> {
self.catalog_id.as_deref()
}
#[allow(missing_docs)] // documentation missing in model
pub fn database_name(&self) -> std::option::Option<&str> {
self.database_name.as_deref()
}
#[allow(missing_docs)] // documentation missing in model
pub fn name(&self) -> std::option::Option<&str> {
self.name.as_deref()
}
/// <p>A structure containing information for audit.</p>
pub fn audit_context(&self) -> std::option::Option<&crate::model::AuditContext> {
self.audit_context.as_ref()
}
#[allow(missing_docs)] // documentation missing in model
pub fn supported_permission_types(
&self,
) -> std::option::Option<&[crate::model::PermissionType]> {
self.supported_permission_types.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetUnfilteredPartitionsMetadataInput {
#[allow(missing_docs)] // documentation missing in model
#[doc(hidden)]
pub catalog_id: std::option::Option<std::string::String>,
#[allow(missing_docs)] // documentation missing in model
#[doc(hidden)]
pub database_name: std::option::Option<std::string::String>,
#[allow(missing_docs)] // documentation missing in model
#[doc(hidden)]
pub table_name: std::option::Option<std::string::String>,
#[allow(missing_docs)] // documentation missing in model
#[doc(hidden)]
pub expression: std::option::Option<std::string::String>,
/// <p>A structure containing information for audit.</p>
#[doc(hidden)]
pub audit_context: std::option::Option<crate::model::AuditContext>,
#[allow(missing_docs)] // documentation missing in model
#[doc(hidden)]
pub supported_permission_types:
std::option::Option<std::vec::Vec<crate::model::PermissionType>>,
#[allow(missing_docs)] // documentation missing in model
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
/// <p>Defines a non-overlapping region of a table's partitions, allowing multiple requests to be run in parallel.</p>
#[doc(hidden)]
pub segment: std::option::Option<crate::model::Segment>,
#[allow(missing_docs)] // documentation missing in model
#[doc(hidden)]
pub max_results: std::option::Option<i32>,
}
impl GetUnfilteredPartitionsMetadataInput {
#[allow(missing_docs)] // documentation missing in model
pub fn catalog_id(&self) -> std::option::Option<&str> {
self.catalog_id.as_deref()
}
#[allow(missing_docs)] // documentation missing in model
pub fn database_name(&self) -> std::option::Option<&str> {
self.database_name.as_deref()
}
#[allow(missing_docs)] // documentation missing in model
pub fn table_name(&self) -> std::option::Option<&str> {
self.table_name.as_deref()
}
#[allow(missing_docs)] // documentation missing in model
pub fn expression(&self) -> std::option::Option<&str> {
self.expression.as_deref()
}
/// <p>A structure containing information for audit.</p>
pub fn audit_context(&self) -> std::option::Option<&crate::model::AuditContext> {
self.audit_context.as_ref()
}
#[allow(missing_docs)] // documentation missing in model
pub fn supported_permission_types(
&self,
) -> std::option::Option<&[crate::model::PermissionType]> {
self.supported_permission_types.as_deref()
}
#[allow(missing_docs)] // documentation missing in model
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
/// <p>Defines a non-overlapping region of a table's partitions, allowing multiple requests to be run in parallel.</p>
pub fn segment(&self) -> std::option::Option<&crate::model::Segment> {
self.segment.as_ref()
}
#[allow(missing_docs)] // documentation missing in model
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetUnfilteredPartitionMetadataInput {
#[allow(missing_docs)] // documentation missing in model
#[doc(hidden)]
pub catalog_id: std::option::Option<std::string::String>,
#[allow(missing_docs)] // documentation missing in model
#[doc(hidden)]
pub database_name: std::option::Option<std::string::String>,
#[allow(missing_docs)] // documentation missing in model
#[doc(hidden)]
pub table_name: std::option::Option<std::string::String>,
#[allow(missing_docs)] // documentation missing in model
#[doc(hidden)]
pub partition_values: std::option::Option<std::vec::Vec<std::string::String>>,
/// <p>A structure containing information for audit.</p>
#[doc(hidden)]
pub audit_context: std::option::Option<crate::model::AuditContext>,
#[allow(missing_docs)] // documentation missing in model
#[doc(hidden)]
pub supported_permission_types:
std::option::Option<std::vec::Vec<crate::model::PermissionType>>,
}
impl GetUnfilteredPartitionMetadataInput {
#[allow(missing_docs)] // documentation missing in model
pub fn catalog_id(&self) -> std::option::Option<&str> {
self.catalog_id.as_deref()
}
#[allow(missing_docs)] // documentation missing in model
pub fn database_name(&self) -> std::option::Option<&str> {
self.database_name.as_deref()
}
#[allow(missing_docs)] // documentation missing in model
pub fn table_name(&self) -> std::option::Option<&str> {
self.table_name.as_deref()
}
#[allow(missing_docs)] // documentation missing in model
pub fn partition_values(&self) -> std::option::Option<&[std::string::String]> {
self.partition_values.as_deref()
}
/// <p>A structure containing information for audit.</p>
pub fn audit_context(&self) -> std::option::Option<&crate::model::AuditContext> {
self.audit_context.as_ref()
}
#[allow(missing_docs)] // documentation missing in model
pub fn supported_permission_types(
&self,
) -> std::option::Option<&[crate::model::PermissionType]> {
self.supported_permission_types.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetTriggersInput {
/// <p>A continuation token, if this is a continuation call.</p>
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
/// <p>The name of the job to retrieve triggers for. The trigger that can start this job is returned, and if there is no such trigger, all triggers are returned.</p>
#[doc(hidden)]
pub dependent_job_name: std::option::Option<std::string::String>,
/// <p>The maximum size of the response.</p>
#[doc(hidden)]
pub max_results: std::option::Option<i32>,
}
impl GetTriggersInput {
/// <p>A continuation token, if this is a continuation call.</p>
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
/// <p>The name of the job to retrieve triggers for. The trigger that can start this job is returned, and if there is no such trigger, all triggers are returned.</p>
pub fn dependent_job_name(&self) -> std::option::Option<&str> {
self.dependent_job_name.as_deref()
}
/// <p>The maximum size of the response.</p>
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetTriggerInput {
/// <p>The name of the trigger to retrieve.</p>
#[doc(hidden)]
pub name: std::option::Option<std::string::String>,
}
impl GetTriggerInput {
/// <p>The name of the trigger to retrieve.</p>
pub fn name(&self) -> std::option::Option<&str> {
self.name.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetTagsInput {
/// <p>The Amazon Resource Name (ARN) of the resource for which to retrieve tags.</p>
#[doc(hidden)]
pub resource_arn: std::option::Option<std::string::String>,
}
impl GetTagsInput {
/// <p>The Amazon Resource Name (ARN) of the resource for which to retrieve tags.</p>
pub fn resource_arn(&self) -> std::option::Option<&str> {
self.resource_arn.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetTableVersionsInput {
/// <p>The ID of the Data Catalog where the tables reside. If none is provided, the Amazon Web Services account ID is used by default.</p>
#[doc(hidden)]
pub catalog_id: std::option::Option<std::string::String>,
/// <p>The database in the catalog in which the table resides. For Hive compatibility, this name is entirely lowercase.</p>
#[doc(hidden)]
pub database_name: std::option::Option<std::string::String>,
/// <p>The name of the table. For Hive compatibility, this name is entirely lowercase.</p>
#[doc(hidden)]
pub table_name: std::option::Option<std::string::String>,
/// <p>A continuation token, if this is not the first call.</p>
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
/// <p>The maximum number of table versions to return in one response.</p>
#[doc(hidden)]
pub max_results: std::option::Option<i32>,
}
impl GetTableVersionsInput {
/// <p>The ID of the Data Catalog where the tables reside. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(&self) -> std::option::Option<&str> {
self.catalog_id.as_deref()
}
/// <p>The database in the catalog in which the table resides. For Hive compatibility, this name is entirely lowercase.</p>
pub fn database_name(&self) -> std::option::Option<&str> {
self.database_name.as_deref()
}
/// <p>The name of the table. For Hive compatibility, this name is entirely lowercase.</p>
pub fn table_name(&self) -> std::option::Option<&str> {
self.table_name.as_deref()
}
/// <p>A continuation token, if this is not the first call.</p>
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
/// <p>The maximum number of table versions to return in one response.</p>
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetTableVersionInput {
/// <p>The ID of the Data Catalog where the tables reside. If none is provided, the Amazon Web Services account ID is used by default.</p>
#[doc(hidden)]
pub catalog_id: std::option::Option<std::string::String>,
/// <p>The database in the catalog in which the table resides. For Hive compatibility, this name is entirely lowercase.</p>
#[doc(hidden)]
pub database_name: std::option::Option<std::string::String>,
/// <p>The name of the table. For Hive compatibility, this name is entirely lowercase.</p>
#[doc(hidden)]
pub table_name: std::option::Option<std::string::String>,
/// <p>The ID value of the table version to be retrieved. A <code>VersionID</code> is a string representation of an integer. Each version is incremented by 1. </p>
#[doc(hidden)]
pub version_id: std::option::Option<std::string::String>,
}
impl GetTableVersionInput {
/// <p>The ID of the Data Catalog where the tables reside. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(&self) -> std::option::Option<&str> {
self.catalog_id.as_deref()
}
/// <p>The database in the catalog in which the table resides. For Hive compatibility, this name is entirely lowercase.</p>
pub fn database_name(&self) -> std::option::Option<&str> {
self.database_name.as_deref()
}
/// <p>The name of the table. For Hive compatibility, this name is entirely lowercase.</p>
pub fn table_name(&self) -> std::option::Option<&str> {
self.table_name.as_deref()
}
/// <p>The ID value of the table version to be retrieved. A <code>VersionID</code> is a string representation of an integer. Each version is incremented by 1. </p>
pub fn version_id(&self) -> std::option::Option<&str> {
self.version_id.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetTablesInput {
/// <p>The ID of the Data Catalog where the tables reside. If none is provided, the Amazon Web Services account ID is used by default.</p>
#[doc(hidden)]
pub catalog_id: std::option::Option<std::string::String>,
/// <p>The database in the catalog whose tables to list. For Hive compatibility, this name is entirely lowercase.</p>
#[doc(hidden)]
pub database_name: std::option::Option<std::string::String>,
/// <p>A regular expression pattern. If present, only those tables whose names match the pattern are returned.</p>
#[doc(hidden)]
pub expression: std::option::Option<std::string::String>,
/// <p>A continuation token, included if this is a continuation call.</p>
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
/// <p>The maximum number of tables to return in a single response.</p>
#[doc(hidden)]
pub max_results: std::option::Option<i32>,
/// <p>The transaction ID at which to read the table contents.</p>
#[doc(hidden)]
pub transaction_id: std::option::Option<std::string::String>,
/// <p>The time as of when to read the table contents. If not set, the most recent transaction commit time will be used. Cannot be specified along with <code>TransactionId</code>.</p>
#[doc(hidden)]
pub query_as_of_time: std::option::Option<aws_smithy_types::DateTime>,
}
impl GetTablesInput {
/// <p>The ID of the Data Catalog where the tables reside. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(&self) -> std::option::Option<&str> {
self.catalog_id.as_deref()
}
/// <p>The database in the catalog whose tables to list. For Hive compatibility, this name is entirely lowercase.</p>
pub fn database_name(&self) -> std::option::Option<&str> {
self.database_name.as_deref()
}
/// <p>A regular expression pattern. If present, only those tables whose names match the pattern are returned.</p>
pub fn expression(&self) -> std::option::Option<&str> {
self.expression.as_deref()
}
/// <p>A continuation token, included if this is a continuation call.</p>
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
/// <p>The maximum number of tables to return in a single response.</p>
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
/// <p>The transaction ID at which to read the table contents.</p>
pub fn transaction_id(&self) -> std::option::Option<&str> {
self.transaction_id.as_deref()
}
/// <p>The time as of when to read the table contents. If not set, the most recent transaction commit time will be used. Cannot be specified along with <code>TransactionId</code>.</p>
pub fn query_as_of_time(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
self.query_as_of_time.as_ref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetTableInput {
/// <p>The ID of the Data Catalog where the table resides. If none is provided, the Amazon Web Services account ID is used by default.</p>
#[doc(hidden)]
pub catalog_id: std::option::Option<std::string::String>,
/// <p>The name of the database in the catalog in which the table resides. For Hive compatibility, this name is entirely lowercase.</p>
#[doc(hidden)]
pub database_name: std::option::Option<std::string::String>,
/// <p>The name of the table for which to retrieve the definition. For Hive compatibility, this name is entirely lowercase.</p>
#[doc(hidden)]
pub name: std::option::Option<std::string::String>,
/// <p>The transaction ID at which to read the table contents. </p>
#[doc(hidden)]
pub transaction_id: std::option::Option<std::string::String>,
/// <p>The time as of when to read the table contents. If not set, the most recent transaction commit time will be used. Cannot be specified along with <code>TransactionId</code>.</p>
#[doc(hidden)]
pub query_as_of_time: std::option::Option<aws_smithy_types::DateTime>,
}
impl GetTableInput {
/// <p>The ID of the Data Catalog where the table resides. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(&self) -> std::option::Option<&str> {
self.catalog_id.as_deref()
}
/// <p>The name of the database in the catalog in which the table resides. For Hive compatibility, this name is entirely lowercase.</p>
pub fn database_name(&self) -> std::option::Option<&str> {
self.database_name.as_deref()
}
/// <p>The name of the table for which to retrieve the definition. For Hive compatibility, this name is entirely lowercase.</p>
pub fn name(&self) -> std::option::Option<&str> {
self.name.as_deref()
}
/// <p>The transaction ID at which to read the table contents. </p>
pub fn transaction_id(&self) -> std::option::Option<&str> {
self.transaction_id.as_deref()
}
/// <p>The time as of when to read the table contents. If not set, the most recent transaction commit time will be used. Cannot be specified along with <code>TransactionId</code>.</p>
pub fn query_as_of_time(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
self.query_as_of_time.as_ref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetStatementInput {
/// <p>The Session ID of the statement.</p>
#[doc(hidden)]
pub session_id: std::option::Option<std::string::String>,
/// <p>The Id of the statement.</p>
#[doc(hidden)]
pub id: i32,
/// <p>The origin of the request.</p>
#[doc(hidden)]
pub request_origin: std::option::Option<std::string::String>,
}
impl GetStatementInput {
/// <p>The Session ID of the statement.</p>
pub fn session_id(&self) -> std::option::Option<&str> {
self.session_id.as_deref()
}
/// <p>The Id of the statement.</p>
pub fn id(&self) -> i32 {
self.id
}
/// <p>The origin of the request.</p>
pub fn request_origin(&self) -> std::option::Option<&str> {
self.request_origin.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetSessionInput {
/// <p>The ID of the session. </p>
#[doc(hidden)]
pub id: std::option::Option<std::string::String>,
/// <p>The origin of the request. </p>
#[doc(hidden)]
pub request_origin: std::option::Option<std::string::String>,
}
impl GetSessionInput {
/// <p>The ID of the session. </p>
pub fn id(&self) -> std::option::Option<&str> {
self.id.as_deref()
}
/// <p>The origin of the request. </p>
pub fn request_origin(&self) -> std::option::Option<&str> {
self.request_origin.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetSecurityConfigurationsInput {
/// <p>The maximum number of results to return.</p>
#[doc(hidden)]
pub max_results: std::option::Option<i32>,
/// <p>A continuation token, if this is a continuation call.</p>
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
}
impl GetSecurityConfigurationsInput {
/// <p>The maximum number of results to return.</p>
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
/// <p>A continuation token, if this is a continuation call.</p>
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetSecurityConfigurationInput {
/// <p>The name of the security configuration to retrieve.</p>
#[doc(hidden)]
pub name: std::option::Option<std::string::String>,
}
impl GetSecurityConfigurationInput {
/// <p>The name of the security configuration to retrieve.</p>
pub fn name(&self) -> std::option::Option<&str> {
self.name.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetSchemaVersionsDiffInput {
/// <p>This is a wrapper structure to contain schema identity fields. The structure contains:</p>
/// <ul>
/// <li> <p>SchemaId$SchemaArn: The Amazon Resource Name (ARN) of the schema. One of <code>SchemaArn</code> or <code>SchemaName</code> has to be provided.</p> </li>
/// <li> <p>SchemaId$SchemaName: The name of the schema. One of <code>SchemaArn</code> or <code>SchemaName</code> has to be provided.</p> </li>
/// </ul>
#[doc(hidden)]
pub schema_id: std::option::Option<crate::model::SchemaId>,
/// <p>The first of the two schema versions to be compared.</p>
#[doc(hidden)]
pub first_schema_version_number: std::option::Option<crate::model::SchemaVersionNumber>,
/// <p>The second of the two schema versions to be compared.</p>
#[doc(hidden)]
pub second_schema_version_number: std::option::Option<crate::model::SchemaVersionNumber>,
/// <p>Refers to <code>SYNTAX_DIFF</code>, which is the currently supported diff type.</p>
#[doc(hidden)]
pub schema_diff_type: std::option::Option<crate::model::SchemaDiffType>,
}
impl GetSchemaVersionsDiffInput {
/// <p>This is a wrapper structure to contain schema identity fields. The structure contains:</p>
/// <ul>
/// <li> <p>SchemaId$SchemaArn: The Amazon Resource Name (ARN) of the schema. One of <code>SchemaArn</code> or <code>SchemaName</code> has to be provided.</p> </li>
/// <li> <p>SchemaId$SchemaName: The name of the schema. One of <code>SchemaArn</code> or <code>SchemaName</code> has to be provided.</p> </li>
/// </ul>
pub fn schema_id(&self) -> std::option::Option<&crate::model::SchemaId> {
self.schema_id.as_ref()
}
/// <p>The first of the two schema versions to be compared.</p>
pub fn first_schema_version_number(
&self,
) -> std::option::Option<&crate::model::SchemaVersionNumber> {
self.first_schema_version_number.as_ref()
}
/// <p>The second of the two schema versions to be compared.</p>
pub fn second_schema_version_number(
&self,
) -> std::option::Option<&crate::model::SchemaVersionNumber> {
self.second_schema_version_number.as_ref()
}
/// <p>Refers to <code>SYNTAX_DIFF</code>, which is the currently supported diff type.</p>
pub fn schema_diff_type(&self) -> std::option::Option<&crate::model::SchemaDiffType> {
self.schema_diff_type.as_ref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetSchemaVersionInput {
/// <p>This is a wrapper structure to contain schema identity fields. The structure contains:</p>
/// <ul>
/// <li> <p>SchemaId$SchemaArn: The Amazon Resource Name (ARN) of the schema. Either <code>SchemaArn</code> or <code>SchemaName</code> and <code>RegistryName</code> has to be provided.</p> </li>
/// <li> <p>SchemaId$SchemaName: The name of the schema. Either <code>SchemaArn</code> or <code>SchemaName</code> and <code>RegistryName</code> has to be provided.</p> </li>
/// </ul>
#[doc(hidden)]
pub schema_id: std::option::Option<crate::model::SchemaId>,
/// <p>The <code>SchemaVersionId</code> of the schema version. This field is required for fetching by schema ID. Either this or the <code>SchemaId</code> wrapper has to be provided.</p>
#[doc(hidden)]
pub schema_version_id: std::option::Option<std::string::String>,
/// <p>The version number of the schema.</p>
#[doc(hidden)]
pub schema_version_number: std::option::Option<crate::model::SchemaVersionNumber>,
}
impl GetSchemaVersionInput {
/// <p>This is a wrapper structure to contain schema identity fields. The structure contains:</p>
/// <ul>
/// <li> <p>SchemaId$SchemaArn: The Amazon Resource Name (ARN) of the schema. Either <code>SchemaArn</code> or <code>SchemaName</code> and <code>RegistryName</code> has to be provided.</p> </li>
/// <li> <p>SchemaId$SchemaName: The name of the schema. Either <code>SchemaArn</code> or <code>SchemaName</code> and <code>RegistryName</code> has to be provided.</p> </li>
/// </ul>
pub fn schema_id(&self) -> std::option::Option<&crate::model::SchemaId> {
self.schema_id.as_ref()
}
/// <p>The <code>SchemaVersionId</code> of the schema version. This field is required for fetching by schema ID. Either this or the <code>SchemaId</code> wrapper has to be provided.</p>
pub fn schema_version_id(&self) -> std::option::Option<&str> {
self.schema_version_id.as_deref()
}
/// <p>The version number of the schema.</p>
pub fn schema_version_number(&self) -> std::option::Option<&crate::model::SchemaVersionNumber> {
self.schema_version_number.as_ref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetSchemaByDefinitionInput {
/// <p>This is a wrapper structure to contain schema identity fields. The structure contains:</p>
/// <ul>
/// <li> <p>SchemaId$SchemaArn: The Amazon Resource Name (ARN) of the schema. One of <code>SchemaArn</code> or <code>SchemaName</code> has to be provided.</p> </li>
/// <li> <p>SchemaId$SchemaName: The name of the schema. One of <code>SchemaArn</code> or <code>SchemaName</code> has to be provided.</p> </li>
/// </ul>
#[doc(hidden)]
pub schema_id: std::option::Option<crate::model::SchemaId>,
/// <p>The definition of the schema for which schema details are required.</p>
#[doc(hidden)]
pub schema_definition: std::option::Option<std::string::String>,
}
impl GetSchemaByDefinitionInput {
/// <p>This is a wrapper structure to contain schema identity fields. The structure contains:</p>
/// <ul>
/// <li> <p>SchemaId$SchemaArn: The Amazon Resource Name (ARN) of the schema. One of <code>SchemaArn</code> or <code>SchemaName</code> has to be provided.</p> </li>
/// <li> <p>SchemaId$SchemaName: The name of the schema. One of <code>SchemaArn</code> or <code>SchemaName</code> has to be provided.</p> </li>
/// </ul>
pub fn schema_id(&self) -> std::option::Option<&crate::model::SchemaId> {
self.schema_id.as_ref()
}
/// <p>The definition of the schema for which schema details are required.</p>
pub fn schema_definition(&self) -> std::option::Option<&str> {
self.schema_definition.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetSchemaInput {
/// <p>This is a wrapper structure to contain schema identity fields. The structure contains:</p>
/// <ul>
/// <li> <p>SchemaId$SchemaArn: The Amazon Resource Name (ARN) of the schema. Either <code>SchemaArn</code> or <code>SchemaName</code> and <code>RegistryName</code> has to be provided.</p> </li>
/// <li> <p>SchemaId$SchemaName: The name of the schema. Either <code>SchemaArn</code> or <code>SchemaName</code> and <code>RegistryName</code> has to be provided.</p> </li>
/// </ul>
#[doc(hidden)]
pub schema_id: std::option::Option<crate::model::SchemaId>,
}
impl GetSchemaInput {
/// <p>This is a wrapper structure to contain schema identity fields. The structure contains:</p>
/// <ul>
/// <li> <p>SchemaId$SchemaArn: The Amazon Resource Name (ARN) of the schema. Either <code>SchemaArn</code> or <code>SchemaName</code> and <code>RegistryName</code> has to be provided.</p> </li>
/// <li> <p>SchemaId$SchemaName: The name of the schema. Either <code>SchemaArn</code> or <code>SchemaName</code> and <code>RegistryName</code> has to be provided.</p> </li>
/// </ul>
pub fn schema_id(&self) -> std::option::Option<&crate::model::SchemaId> {
self.schema_id.as_ref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetResourcePolicyInput {
/// <p>The ARN of the Glue resource for which to retrieve the resource policy. If not supplied, the Data Catalog resource policy is returned. Use <code>GetResourcePolicies</code> to view all existing resource policies. For more information see <a href="https://docs.aws.amazon.com/glue/latest/dg/glue-specifying-resource-arns.html">Specifying Glue Resource ARNs</a>. </p>
#[doc(hidden)]
pub resource_arn: std::option::Option<std::string::String>,
}
impl GetResourcePolicyInput {
/// <p>The ARN of the Glue resource for which to retrieve the resource policy. If not supplied, the Data Catalog resource policy is returned. Use <code>GetResourcePolicies</code> to view all existing resource policies. For more information see <a href="https://docs.aws.amazon.com/glue/latest/dg/glue-specifying-resource-arns.html">Specifying Glue Resource ARNs</a>. </p>
pub fn resource_arn(&self) -> std::option::Option<&str> {
self.resource_arn.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetResourcePoliciesInput {
/// <p>A continuation token, if this is a continuation request.</p>
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
/// <p>The maximum size of a list to return.</p>
#[doc(hidden)]
pub max_results: std::option::Option<i32>,
}
impl GetResourcePoliciesInput {
/// <p>A continuation token, if this is a continuation request.</p>
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
/// <p>The maximum size of a list to return.</p>
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetRegistryInput {
/// <p>This is a wrapper structure that may contain the registry name and Amazon Resource Name (ARN).</p>
#[doc(hidden)]
pub registry_id: std::option::Option<crate::model::RegistryId>,
}
impl GetRegistryInput {
/// <p>This is a wrapper structure that may contain the registry name and Amazon Resource Name (ARN).</p>
pub fn registry_id(&self) -> std::option::Option<&crate::model::RegistryId> {
self.registry_id.as_ref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetPlanInput {
/// <p>The list of mappings from a source table to target tables.</p>
#[doc(hidden)]
pub mapping: std::option::Option<std::vec::Vec<crate::model::MappingEntry>>,
/// <p>The source table.</p>
#[doc(hidden)]
pub source: std::option::Option<crate::model::CatalogEntry>,
/// <p>The target tables.</p>
#[doc(hidden)]
pub sinks: std::option::Option<std::vec::Vec<crate::model::CatalogEntry>>,
/// <p>The parameters for the mapping.</p>
#[doc(hidden)]
pub location: std::option::Option<crate::model::Location>,
/// <p>The programming language of the code to perform the mapping.</p>
#[doc(hidden)]
pub language: std::option::Option<crate::model::Language>,
/// <p>A map to hold additional optional key-value parameters.</p>
/// <p>Currently, these key-value pairs are supported:</p>
/// <ul>
/// <li> <p> <code>inferSchema</code> — Specifies whether to set <code>inferSchema</code> to true or false for the default script generated by an Glue job. For example, to set <code>inferSchema</code> to true, pass the following key value pair:</p> <p> <code>--additional-plan-options-map '{"inferSchema":"true"}'</code> </p> </li>
/// </ul>
#[doc(hidden)]
pub additional_plan_options_map:
std::option::Option<std::collections::HashMap<std::string::String, std::string::String>>,
}
impl GetPlanInput {
/// <p>The list of mappings from a source table to target tables.</p>
pub fn mapping(&self) -> std::option::Option<&[crate::model::MappingEntry]> {
self.mapping.as_deref()
}
/// <p>The source table.</p>
pub fn source(&self) -> std::option::Option<&crate::model::CatalogEntry> {
self.source.as_ref()
}
/// <p>The target tables.</p>
pub fn sinks(&self) -> std::option::Option<&[crate::model::CatalogEntry]> {
self.sinks.as_deref()
}
/// <p>The parameters for the mapping.</p>
pub fn location(&self) -> std::option::Option<&crate::model::Location> {
self.location.as_ref()
}
/// <p>The programming language of the code to perform the mapping.</p>
pub fn language(&self) -> std::option::Option<&crate::model::Language> {
self.language.as_ref()
}
/// <p>A map to hold additional optional key-value parameters.</p>
/// <p>Currently, these key-value pairs are supported:</p>
/// <ul>
/// <li> <p> <code>inferSchema</code> — Specifies whether to set <code>inferSchema</code> to true or false for the default script generated by an Glue job. For example, to set <code>inferSchema</code> to true, pass the following key value pair:</p> <p> <code>--additional-plan-options-map '{"inferSchema":"true"}'</code> </p> </li>
/// </ul>
pub fn additional_plan_options_map(
&self,
) -> std::option::Option<&std::collections::HashMap<std::string::String, std::string::String>>
{
self.additional_plan_options_map.as_ref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetPartitionsInput {
/// <p>The ID of the Data Catalog where the partitions in question reside. If none is provided, the Amazon Web Services account ID is used by default.</p>
#[doc(hidden)]
pub catalog_id: std::option::Option<std::string::String>,
/// <p>The name of the catalog database where the partitions reside.</p>
#[doc(hidden)]
pub database_name: std::option::Option<std::string::String>,
/// <p>The name of the partitions' table.</p>
#[doc(hidden)]
pub table_name: std::option::Option<std::string::String>,
/// <p>An expression that filters the partitions to be returned.</p>
/// <p>The expression uses SQL syntax similar to the SQL <code>WHERE</code> filter clause. The SQL statement parser <a href="http://jsqlparser.sourceforge.net/home.php">JSQLParser</a> parses the expression. </p>
/// <p> <i>Operators</i>: The following are the operators that you can use in the <code>Expression</code> API call:</p>
/// <dl>
/// <dt>
/// =
/// </dt>
/// <dd>
/// <p>Checks whether the values of the two operands are equal; if yes, then the condition becomes true.</p>
/// <p>Example: Assume 'variable a' holds 10 and 'variable b' holds 20. </p>
/// <p>(a = b) is not true.</p>
/// </dd>
/// <dt>
/// < >
/// </dt>
/// <dd>
/// <p>Checks whether the values of two operands are equal; if the values are not equal, then the condition becomes true.</p>
/// <p>Example: (a < > b) is true.</p>
/// </dd>
/// <dt>
/// >
/// </dt>
/// <dd>
/// <p>Checks whether the value of the left operand is greater than the value of the right operand; if yes, then the condition becomes true.</p>
/// <p>Example: (a > b) is not true.</p>
/// </dd>
/// <dt>
/// <
/// </dt>
/// <dd>
/// <p>Checks whether the value of the left operand is less than the value of the right operand; if yes, then the condition becomes true.</p>
/// <p>Example: (a < b) is true.</p>
/// </dd>
/// <dt>
/// >=
/// </dt>
/// <dd>
/// <p>Checks whether the value of the left operand is greater than or equal to the value of the right operand; if yes, then the condition becomes true.</p>
/// <p>Example: (a >= b) is not true.</p>
/// </dd>
/// <dt>
/// <=
/// </dt>
/// <dd>
/// <p>Checks whether the value of the left operand is less than or equal to the value of the right operand; if yes, then the condition becomes true.</p>
/// <p>Example: (a <= b) is true.</p>
/// </dd>
/// <dt>
/// AND, OR, IN, BETWEEN, LIKE, NOT, IS NULL
/// </dt>
/// <dd>
/// <p>Logical operators.</p>
/// </dd>
/// </dl>
/// <p> <i>Supported Partition Key Types</i>: The following are the supported partition keys.</p>
/// <ul>
/// <li> <p> <code>string</code> </p> </li>
/// <li> <p> <code>date</code> </p> </li>
/// <li> <p> <code>timestamp</code> </p> </li>
/// <li> <p> <code>int</code> </p> </li>
/// <li> <p> <code>bigint</code> </p> </li>
/// <li> <p> <code>long</code> </p> </li>
/// <li> <p> <code>tinyint</code> </p> </li>
/// <li> <p> <code>smallint</code> </p> </li>
/// <li> <p> <code>decimal</code> </p> </li>
/// </ul>
/// <p>If an type is encountered that is not valid, an exception is thrown. </p>
/// <p>The following list shows the valid operators on each type. When you define a crawler, the <code>partitionKey</code> type is created as a <code>STRING</code>, to be compatible with the catalog partitions. </p>
/// <p> <i>Sample API Call</i>: </p>
#[doc(hidden)]
pub expression: std::option::Option<std::string::String>,
/// <p>A continuation token, if this is not the first call to retrieve these partitions.</p>
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
/// <p>The segment of the table's partitions to scan in this request.</p>
#[doc(hidden)]
pub segment: std::option::Option<crate::model::Segment>,
/// <p>The maximum number of partitions to return in a single response.</p>
#[doc(hidden)]
pub max_results: std::option::Option<i32>,
/// <p>When true, specifies not returning the partition column schema. Useful when you are interested only in other partition attributes such as partition values or location. This approach avoids the problem of a large response by not returning duplicate data.</p>
#[doc(hidden)]
pub exclude_column_schema: std::option::Option<bool>,
/// <p>The transaction ID at which to read the partition contents.</p>
#[doc(hidden)]
pub transaction_id: std::option::Option<std::string::String>,
/// <p>The time as of when to read the partition contents. If not set, the most recent transaction commit time will be used. Cannot be specified along with <code>TransactionId</code>.</p>
#[doc(hidden)]
pub query_as_of_time: std::option::Option<aws_smithy_types::DateTime>,
}
impl GetPartitionsInput {
/// <p>The ID of the Data Catalog where the partitions in question reside. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(&self) -> std::option::Option<&str> {
self.catalog_id.as_deref()
}
/// <p>The name of the catalog database where the partitions reside.</p>
pub fn database_name(&self) -> std::option::Option<&str> {
self.database_name.as_deref()
}
/// <p>The name of the partitions' table.</p>
pub fn table_name(&self) -> std::option::Option<&str> {
self.table_name.as_deref()
}
/// <p>An expression that filters the partitions to be returned.</p>
/// <p>The expression uses SQL syntax similar to the SQL <code>WHERE</code> filter clause. The SQL statement parser <a href="http://jsqlparser.sourceforge.net/home.php">JSQLParser</a> parses the expression. </p>
/// <p> <i>Operators</i>: The following are the operators that you can use in the <code>Expression</code> API call:</p>
/// <dl>
/// <dt>
/// =
/// </dt>
/// <dd>
/// <p>Checks whether the values of the two operands are equal; if yes, then the condition becomes true.</p>
/// <p>Example: Assume 'variable a' holds 10 and 'variable b' holds 20. </p>
/// <p>(a = b) is not true.</p>
/// </dd>
/// <dt>
/// < >
/// </dt>
/// <dd>
/// <p>Checks whether the values of two operands are equal; if the values are not equal, then the condition becomes true.</p>
/// <p>Example: (a < > b) is true.</p>
/// </dd>
/// <dt>
/// >
/// </dt>
/// <dd>
/// <p>Checks whether the value of the left operand is greater than the value of the right operand; if yes, then the condition becomes true.</p>
/// <p>Example: (a > b) is not true.</p>
/// </dd>
/// <dt>
/// <
/// </dt>
/// <dd>
/// <p>Checks whether the value of the left operand is less than the value of the right operand; if yes, then the condition becomes true.</p>
/// <p>Example: (a < b) is true.</p>
/// </dd>
/// <dt>
/// >=
/// </dt>
/// <dd>
/// <p>Checks whether the value of the left operand is greater than or equal to the value of the right operand; if yes, then the condition becomes true.</p>
/// <p>Example: (a >= b) is not true.</p>
/// </dd>
/// <dt>
/// <=
/// </dt>
/// <dd>
/// <p>Checks whether the value of the left operand is less than or equal to the value of the right operand; if yes, then the condition becomes true.</p>
/// <p>Example: (a <= b) is true.</p>
/// </dd>
/// <dt>
/// AND, OR, IN, BETWEEN, LIKE, NOT, IS NULL
/// </dt>
/// <dd>
/// <p>Logical operators.</p>
/// </dd>
/// </dl>
/// <p> <i>Supported Partition Key Types</i>: The following are the supported partition keys.</p>
/// <ul>
/// <li> <p> <code>string</code> </p> </li>
/// <li> <p> <code>date</code> </p> </li>
/// <li> <p> <code>timestamp</code> </p> </li>
/// <li> <p> <code>int</code> </p> </li>
/// <li> <p> <code>bigint</code> </p> </li>
/// <li> <p> <code>long</code> </p> </li>
/// <li> <p> <code>tinyint</code> </p> </li>
/// <li> <p> <code>smallint</code> </p> </li>
/// <li> <p> <code>decimal</code> </p> </li>
/// </ul>
/// <p>If an type is encountered that is not valid, an exception is thrown. </p>
/// <p>The following list shows the valid operators on each type. When you define a crawler, the <code>partitionKey</code> type is created as a <code>STRING</code>, to be compatible with the catalog partitions. </p>
/// <p> <i>Sample API Call</i>: </p>
pub fn expression(&self) -> std::option::Option<&str> {
self.expression.as_deref()
}
/// <p>A continuation token, if this is not the first call to retrieve these partitions.</p>
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
/// <p>The segment of the table's partitions to scan in this request.</p>
pub fn segment(&self) -> std::option::Option<&crate::model::Segment> {
self.segment.as_ref()
}
/// <p>The maximum number of partitions to return in a single response.</p>
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
/// <p>When true, specifies not returning the partition column schema. Useful when you are interested only in other partition attributes such as partition values or location. This approach avoids the problem of a large response by not returning duplicate data.</p>
pub fn exclude_column_schema(&self) -> std::option::Option<bool> {
self.exclude_column_schema
}
/// <p>The transaction ID at which to read the partition contents.</p>
pub fn transaction_id(&self) -> std::option::Option<&str> {
self.transaction_id.as_deref()
}
/// <p>The time as of when to read the partition contents. If not set, the most recent transaction commit time will be used. Cannot be specified along with <code>TransactionId</code>.</p>
pub fn query_as_of_time(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
self.query_as_of_time.as_ref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetPartitionIndexesInput {
/// <p>The catalog ID where the table resides.</p>
#[doc(hidden)]
pub catalog_id: std::option::Option<std::string::String>,
/// <p>Specifies the name of a database from which you want to retrieve partition indexes.</p>
#[doc(hidden)]
pub database_name: std::option::Option<std::string::String>,
/// <p>Specifies the name of a table for which you want to retrieve the partition indexes.</p>
#[doc(hidden)]
pub table_name: std::option::Option<std::string::String>,
/// <p>A continuation token, included if this is a continuation call.</p>
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
}
impl GetPartitionIndexesInput {
/// <p>The catalog ID where the table resides.</p>
pub fn catalog_id(&self) -> std::option::Option<&str> {
self.catalog_id.as_deref()
}
/// <p>Specifies the name of a database from which you want to retrieve partition indexes.</p>
pub fn database_name(&self) -> std::option::Option<&str> {
self.database_name.as_deref()
}
/// <p>Specifies the name of a table for which you want to retrieve the partition indexes.</p>
pub fn table_name(&self) -> std::option::Option<&str> {
self.table_name.as_deref()
}
/// <p>A continuation token, included if this is a continuation call.</p>
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetPartitionInput {
/// <p>The ID of the Data Catalog where the partition in question resides. If none is provided, the Amazon Web Services account ID is used by default.</p>
#[doc(hidden)]
pub catalog_id: std::option::Option<std::string::String>,
/// <p>The name of the catalog database where the partition resides.</p>
#[doc(hidden)]
pub database_name: std::option::Option<std::string::String>,
/// <p>The name of the partition's table.</p>
#[doc(hidden)]
pub table_name: std::option::Option<std::string::String>,
/// <p>The values that define the partition.</p>
#[doc(hidden)]
pub partition_values: std::option::Option<std::vec::Vec<std::string::String>>,
}
impl GetPartitionInput {
/// <p>The ID of the Data Catalog where the partition in question resides. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(&self) -> std::option::Option<&str> {
self.catalog_id.as_deref()
}
/// <p>The name of the catalog database where the partition resides.</p>
pub fn database_name(&self) -> std::option::Option<&str> {
self.database_name.as_deref()
}
/// <p>The name of the partition's table.</p>
pub fn table_name(&self) -> std::option::Option<&str> {
self.table_name.as_deref()
}
/// <p>The values that define the partition.</p>
pub fn partition_values(&self) -> std::option::Option<&[std::string::String]> {
self.partition_values.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetMlTransformsInput {
/// <p>A paginated token to offset the results.</p>
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
/// <p>The maximum number of results to return.</p>
#[doc(hidden)]
pub max_results: std::option::Option<i32>,
/// <p>The filter transformation criteria.</p>
#[doc(hidden)]
pub filter: std::option::Option<crate::model::TransformFilterCriteria>,
/// <p>The sorting criteria.</p>
#[doc(hidden)]
pub sort: std::option::Option<crate::model::TransformSortCriteria>,
}
impl GetMlTransformsInput {
/// <p>A paginated token to offset the results.</p>
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
/// <p>The maximum number of results to return.</p>
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
/// <p>The filter transformation criteria.</p>
pub fn filter(&self) -> std::option::Option<&crate::model::TransformFilterCriteria> {
self.filter.as_ref()
}
/// <p>The sorting criteria.</p>
pub fn sort(&self) -> std::option::Option<&crate::model::TransformSortCriteria> {
self.sort.as_ref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetMlTransformInput {
/// <p>The unique identifier of the transform, generated at the time that the transform was created.</p>
#[doc(hidden)]
pub transform_id: std::option::Option<std::string::String>,
}
impl GetMlTransformInput {
/// <p>The unique identifier of the transform, generated at the time that the transform was created.</p>
pub fn transform_id(&self) -> std::option::Option<&str> {
self.transform_id.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetMlTaskRunsInput {
/// <p>The unique identifier of the machine learning transform.</p>
#[doc(hidden)]
pub transform_id: std::option::Option<std::string::String>,
/// <p>A token for pagination of the results. The default is empty.</p>
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
/// <p>The maximum number of results to return. </p>
#[doc(hidden)]
pub max_results: std::option::Option<i32>,
/// <p>The filter criteria, in the <code>TaskRunFilterCriteria</code> structure, for the task run.</p>
#[doc(hidden)]
pub filter: std::option::Option<crate::model::TaskRunFilterCriteria>,
/// <p>The sorting criteria, in the <code>TaskRunSortCriteria</code> structure, for the task run.</p>
#[doc(hidden)]
pub sort: std::option::Option<crate::model::TaskRunSortCriteria>,
}
impl GetMlTaskRunsInput {
/// <p>The unique identifier of the machine learning transform.</p>
pub fn transform_id(&self) -> std::option::Option<&str> {
self.transform_id.as_deref()
}
/// <p>A token for pagination of the results. The default is empty.</p>
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
/// <p>The maximum number of results to return. </p>
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
/// <p>The filter criteria, in the <code>TaskRunFilterCriteria</code> structure, for the task run.</p>
pub fn filter(&self) -> std::option::Option<&crate::model::TaskRunFilterCriteria> {
self.filter.as_ref()
}
/// <p>The sorting criteria, in the <code>TaskRunSortCriteria</code> structure, for the task run.</p>
pub fn sort(&self) -> std::option::Option<&crate::model::TaskRunSortCriteria> {
self.sort.as_ref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetMlTaskRunInput {
/// <p>The unique identifier of the machine learning transform.</p>
#[doc(hidden)]
pub transform_id: std::option::Option<std::string::String>,
/// <p>The unique identifier of the task run.</p>
#[doc(hidden)]
pub task_run_id: std::option::Option<std::string::String>,
}
impl GetMlTaskRunInput {
/// <p>The unique identifier of the machine learning transform.</p>
pub fn transform_id(&self) -> std::option::Option<&str> {
self.transform_id.as_deref()
}
/// <p>The unique identifier of the task run.</p>
pub fn task_run_id(&self) -> std::option::Option<&str> {
self.task_run_id.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetMappingInput {
/// <p>Specifies the source table.</p>
#[doc(hidden)]
pub source: std::option::Option<crate::model::CatalogEntry>,
/// <p>A list of target tables.</p>
#[doc(hidden)]
pub sinks: std::option::Option<std::vec::Vec<crate::model::CatalogEntry>>,
/// <p>Parameters for the mapping.</p>
#[doc(hidden)]
pub location: std::option::Option<crate::model::Location>,
}
impl GetMappingInput {
/// <p>Specifies the source table.</p>
pub fn source(&self) -> std::option::Option<&crate::model::CatalogEntry> {
self.source.as_ref()
}
/// <p>A list of target tables.</p>
pub fn sinks(&self) -> std::option::Option<&[crate::model::CatalogEntry]> {
self.sinks.as_deref()
}
/// <p>Parameters for the mapping.</p>
pub fn location(&self) -> std::option::Option<&crate::model::Location> {
self.location.as_ref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetJobsInput {
/// <p>A continuation token, if this is a continuation call.</p>
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
/// <p>The maximum size of the response.</p>
#[doc(hidden)]
pub max_results: std::option::Option<i32>,
}
impl GetJobsInput {
/// <p>A continuation token, if this is a continuation call.</p>
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
/// <p>The maximum size of the response.</p>
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetJobRunsInput {
/// <p>The name of the job definition for which to retrieve all job runs.</p>
#[doc(hidden)]
pub job_name: std::option::Option<std::string::String>,
/// <p>A continuation token, if this is a continuation call.</p>
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
/// <p>The maximum size of the response.</p>
#[doc(hidden)]
pub max_results: std::option::Option<i32>,
}
impl GetJobRunsInput {
/// <p>The name of the job definition for which to retrieve all job runs.</p>
pub fn job_name(&self) -> std::option::Option<&str> {
self.job_name.as_deref()
}
/// <p>A continuation token, if this is a continuation call.</p>
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
/// <p>The maximum size of the response.</p>
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetJobRunInput {
/// <p>Name of the job definition being run.</p>
#[doc(hidden)]
pub job_name: std::option::Option<std::string::String>,
/// <p>The ID of the job run.</p>
#[doc(hidden)]
pub run_id: std::option::Option<std::string::String>,
/// <p>True if a list of predecessor runs should be returned.</p>
#[doc(hidden)]
pub predecessors_included: bool,
}
impl GetJobRunInput {
/// <p>Name of the job definition being run.</p>
pub fn job_name(&self) -> std::option::Option<&str> {
self.job_name.as_deref()
}
/// <p>The ID of the job run.</p>
pub fn run_id(&self) -> std::option::Option<&str> {
self.run_id.as_deref()
}
/// <p>True if a list of predecessor runs should be returned.</p>
pub fn predecessors_included(&self) -> bool {
self.predecessors_included
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetJobBookmarkInput {
/// <p>The name of the job in question.</p>
#[doc(hidden)]
pub job_name: std::option::Option<std::string::String>,
/// <p>The unique run identifier associated with this job run.</p>
#[doc(hidden)]
pub run_id: std::option::Option<std::string::String>,
}
impl GetJobBookmarkInput {
/// <p>The name of the job in question.</p>
pub fn job_name(&self) -> std::option::Option<&str> {
self.job_name.as_deref()
}
/// <p>The unique run identifier associated with this job run.</p>
pub fn run_id(&self) -> std::option::Option<&str> {
self.run_id.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetJobInput {
/// <p>The name of the job definition to retrieve.</p>
#[doc(hidden)]
pub job_name: std::option::Option<std::string::String>,
}
impl GetJobInput {
/// <p>The name of the job definition to retrieve.</p>
pub fn job_name(&self) -> std::option::Option<&str> {
self.job_name.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetDevEndpointsInput {
/// <p>The maximum size of information to return.</p>
#[doc(hidden)]
pub max_results: std::option::Option<i32>,
/// <p>A continuation token, if this is a continuation call.</p>
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
}
impl GetDevEndpointsInput {
/// <p>The maximum size of information to return.</p>
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
/// <p>A continuation token, if this is a continuation call.</p>
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetDevEndpointInput {
/// <p>Name of the <code>DevEndpoint</code> to retrieve information for.</p>
#[doc(hidden)]
pub endpoint_name: std::option::Option<std::string::String>,
}
impl GetDevEndpointInput {
/// <p>Name of the <code>DevEndpoint</code> to retrieve information for.</p>
pub fn endpoint_name(&self) -> std::option::Option<&str> {
self.endpoint_name.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetDataQualityRulesetEvaluationRunInput {
/// <p>The unique run identifier associated with this run.</p>
#[doc(hidden)]
pub run_id: std::option::Option<std::string::String>,
}
impl GetDataQualityRulesetEvaluationRunInput {
/// <p>The unique run identifier associated with this run.</p>
pub fn run_id(&self) -> std::option::Option<&str> {
self.run_id.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetDataQualityRulesetInput {
/// <p>The name of the ruleset.</p>
#[doc(hidden)]
pub name: std::option::Option<std::string::String>,
}
impl GetDataQualityRulesetInput {
/// <p>The name of the ruleset.</p>
pub fn name(&self) -> std::option::Option<&str> {
self.name.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetDataQualityRuleRecommendationRunInput {
/// <p>The unique run identifier associated with this run.</p>
#[doc(hidden)]
pub run_id: std::option::Option<std::string::String>,
}
impl GetDataQualityRuleRecommendationRunInput {
/// <p>The unique run identifier associated with this run.</p>
pub fn run_id(&self) -> std::option::Option<&str> {
self.run_id.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetDataQualityResultInput {
/// <p>A unique result ID for the data quality result.</p>
#[doc(hidden)]
pub result_id: std::option::Option<std::string::String>,
}
impl GetDataQualityResultInput {
/// <p>A unique result ID for the data quality result.</p>
pub fn result_id(&self) -> std::option::Option<&str> {
self.result_id.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetDataflowGraphInput {
/// <p>The Python script to transform.</p>
#[doc(hidden)]
pub python_script: std::option::Option<std::string::String>,
}
impl GetDataflowGraphInput {
/// <p>The Python script to transform.</p>
pub fn python_script(&self) -> std::option::Option<&str> {
self.python_script.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetDataCatalogEncryptionSettingsInput {
/// <p>The ID of the Data Catalog to retrieve the security configuration for. If none is provided, the Amazon Web Services account ID is used by default.</p>
#[doc(hidden)]
pub catalog_id: std::option::Option<std::string::String>,
}
impl GetDataCatalogEncryptionSettingsInput {
/// <p>The ID of the Data Catalog to retrieve the security configuration for. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(&self) -> std::option::Option<&str> {
self.catalog_id.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetDatabasesInput {
/// <p>The ID of the Data Catalog from which to retrieve <code>Databases</code>. If none is provided, the Amazon Web Services account ID is used by default.</p>
#[doc(hidden)]
pub catalog_id: std::option::Option<std::string::String>,
/// <p>A continuation token, if this is a continuation call.</p>
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
/// <p>The maximum number of databases to return in one response.</p>
#[doc(hidden)]
pub max_results: std::option::Option<i32>,
/// <p>Allows you to specify that you want to list the databases shared with your account. The allowable values are <code>FOREIGN</code> or <code>ALL</code>. </p>
/// <ul>
/// <li> <p>If set to <code>FOREIGN</code>, will list the databases shared with your account. </p> </li>
/// <li> <p>If set to <code>ALL</code>, will list the databases shared with your account, as well as the databases in yor local account. </p> </li>
/// </ul>
#[doc(hidden)]
pub resource_share_type: std::option::Option<crate::model::ResourceShareType>,
}
impl GetDatabasesInput {
/// <p>The ID of the Data Catalog from which to retrieve <code>Databases</code>. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(&self) -> std::option::Option<&str> {
self.catalog_id.as_deref()
}
/// <p>A continuation token, if this is a continuation call.</p>
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
/// <p>The maximum number of databases to return in one response.</p>
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
/// <p>Allows you to specify that you want to list the databases shared with your account. The allowable values are <code>FOREIGN</code> or <code>ALL</code>. </p>
/// <ul>
/// <li> <p>If set to <code>FOREIGN</code>, will list the databases shared with your account. </p> </li>
/// <li> <p>If set to <code>ALL</code>, will list the databases shared with your account, as well as the databases in yor local account. </p> </li>
/// </ul>
pub fn resource_share_type(&self) -> std::option::Option<&crate::model::ResourceShareType> {
self.resource_share_type.as_ref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetDatabaseInput {
/// <p>The ID of the Data Catalog in which the database resides. If none is provided, the Amazon Web Services account ID is used by default.</p>
#[doc(hidden)]
pub catalog_id: std::option::Option<std::string::String>,
/// <p>The name of the database to retrieve. For Hive compatibility, this should be all lowercase.</p>
#[doc(hidden)]
pub name: std::option::Option<std::string::String>,
}
impl GetDatabaseInput {
/// <p>The ID of the Data Catalog in which the database resides. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(&self) -> std::option::Option<&str> {
self.catalog_id.as_deref()
}
/// <p>The name of the database to retrieve. For Hive compatibility, this should be all lowercase.</p>
pub fn name(&self) -> std::option::Option<&str> {
self.name.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetCustomEntityTypeInput {
/// <p>The name of the custom pattern that you want to retrieve.</p>
#[doc(hidden)]
pub name: std::option::Option<std::string::String>,
}
impl GetCustomEntityTypeInput {
/// <p>The name of the custom pattern that you want to retrieve.</p>
pub fn name(&self) -> std::option::Option<&str> {
self.name.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetCrawlersInput {
/// <p>The number of crawlers to return on each call.</p>
#[doc(hidden)]
pub max_results: std::option::Option<i32>,
/// <p>A continuation token, if this is a continuation request.</p>
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
}
impl GetCrawlersInput {
/// <p>The number of crawlers to return on each call.</p>
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
/// <p>A continuation token, if this is a continuation request.</p>
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetCrawlerMetricsInput {
/// <p>A list of the names of crawlers about which to retrieve metrics.</p>
#[doc(hidden)]
pub crawler_name_list: std::option::Option<std::vec::Vec<std::string::String>>,
/// <p>The maximum size of a list to return.</p>
#[doc(hidden)]
pub max_results: std::option::Option<i32>,
/// <p>A continuation token, if this is a continuation call.</p>
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
}
impl GetCrawlerMetricsInput {
/// <p>A list of the names of crawlers about which to retrieve metrics.</p>
pub fn crawler_name_list(&self) -> std::option::Option<&[std::string::String]> {
self.crawler_name_list.as_deref()
}
/// <p>The maximum size of a list to return.</p>
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
/// <p>A continuation token, if this is a continuation call.</p>
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetCrawlerInput {
/// <p>The name of the crawler to retrieve metadata for.</p>
#[doc(hidden)]
pub name: std::option::Option<std::string::String>,
}
impl GetCrawlerInput {
/// <p>The name of the crawler to retrieve metadata for.</p>
pub fn name(&self) -> std::option::Option<&str> {
self.name.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetConnectionsInput {
/// <p>The ID of the Data Catalog in which the connections reside. If none is provided, the Amazon Web Services account ID is used by default.</p>
#[doc(hidden)]
pub catalog_id: std::option::Option<std::string::String>,
/// <p>A filter that controls which connections are returned.</p>
#[doc(hidden)]
pub filter: std::option::Option<crate::model::GetConnectionsFilter>,
/// <p>Allows you to retrieve the connection metadata without returning the password. For instance, the Glue console uses this flag to retrieve the connection, and does not display the password. Set this parameter when the caller might not have permission to use the KMS key to decrypt the password, but it does have permission to access the rest of the connection properties.</p>
#[doc(hidden)]
pub hide_password: bool,
/// <p>A continuation token, if this is a continuation call.</p>
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
/// <p>The maximum number of connections to return in one response.</p>
#[doc(hidden)]
pub max_results: std::option::Option<i32>,
}
impl GetConnectionsInput {
/// <p>The ID of the Data Catalog in which the connections reside. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(&self) -> std::option::Option<&str> {
self.catalog_id.as_deref()
}
/// <p>A filter that controls which connections are returned.</p>
pub fn filter(&self) -> std::option::Option<&crate::model::GetConnectionsFilter> {
self.filter.as_ref()
}
/// <p>Allows you to retrieve the connection metadata without returning the password. For instance, the Glue console uses this flag to retrieve the connection, and does not display the password. Set this parameter when the caller might not have permission to use the KMS key to decrypt the password, but it does have permission to access the rest of the connection properties.</p>
pub fn hide_password(&self) -> bool {
self.hide_password
}
/// <p>A continuation token, if this is a continuation call.</p>
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
/// <p>The maximum number of connections to return in one response.</p>
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetConnectionInput {
/// <p>The ID of the Data Catalog in which the connection resides. If none is provided, the Amazon Web Services account ID is used by default.</p>
#[doc(hidden)]
pub catalog_id: std::option::Option<std::string::String>,
/// <p>The name of the connection definition to retrieve.</p>
#[doc(hidden)]
pub name: std::option::Option<std::string::String>,
/// <p>Allows you to retrieve the connection metadata without returning the password. For instance, the Glue console uses this flag to retrieve the connection, and does not display the password. Set this parameter when the caller might not have permission to use the KMS key to decrypt the password, but it does have permission to access the rest of the connection properties.</p>
#[doc(hidden)]
pub hide_password: bool,
}
impl GetConnectionInput {
/// <p>The ID of the Data Catalog in which the connection resides. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(&self) -> std::option::Option<&str> {
self.catalog_id.as_deref()
}
/// <p>The name of the connection definition to retrieve.</p>
pub fn name(&self) -> std::option::Option<&str> {
self.name.as_deref()
}
/// <p>Allows you to retrieve the connection metadata without returning the password. For instance, the Glue console uses this flag to retrieve the connection, and does not display the password. Set this parameter when the caller might not have permission to use the KMS key to decrypt the password, but it does have permission to access the rest of the connection properties.</p>
pub fn hide_password(&self) -> bool {
self.hide_password
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetColumnStatisticsForTableInput {
/// <p>The ID of the Data Catalog where the partitions in question reside. If none is supplied, the Amazon Web Services account ID is used by default.</p>
#[doc(hidden)]
pub catalog_id: std::option::Option<std::string::String>,
/// <p>The name of the catalog database where the partitions reside.</p>
#[doc(hidden)]
pub database_name: std::option::Option<std::string::String>,
/// <p>The name of the partitions' table.</p>
#[doc(hidden)]
pub table_name: std::option::Option<std::string::String>,
/// <p>A list of the column names.</p>
#[doc(hidden)]
pub column_names: std::option::Option<std::vec::Vec<std::string::String>>,
}
impl GetColumnStatisticsForTableInput {
/// <p>The ID of the Data Catalog where the partitions in question reside. If none is supplied, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(&self) -> std::option::Option<&str> {
self.catalog_id.as_deref()
}
/// <p>The name of the catalog database where the partitions reside.</p>
pub fn database_name(&self) -> std::option::Option<&str> {
self.database_name.as_deref()
}
/// <p>The name of the partitions' table.</p>
pub fn table_name(&self) -> std::option::Option<&str> {
self.table_name.as_deref()
}
/// <p>A list of the column names.</p>
pub fn column_names(&self) -> std::option::Option<&[std::string::String]> {
self.column_names.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetColumnStatisticsForPartitionInput {
/// <p>The ID of the Data Catalog where the partitions in question reside. If none is supplied, the Amazon Web Services account ID is used by default.</p>
#[doc(hidden)]
pub catalog_id: std::option::Option<std::string::String>,
/// <p>The name of the catalog database where the partitions reside.</p>
#[doc(hidden)]
pub database_name: std::option::Option<std::string::String>,
/// <p>The name of the partitions' table.</p>
#[doc(hidden)]
pub table_name: std::option::Option<std::string::String>,
/// <p>A list of partition values identifying the partition.</p>
#[doc(hidden)]
pub partition_values: std::option::Option<std::vec::Vec<std::string::String>>,
/// <p>A list of the column names.</p>
#[doc(hidden)]
pub column_names: std::option::Option<std::vec::Vec<std::string::String>>,
}
impl GetColumnStatisticsForPartitionInput {
/// <p>The ID of the Data Catalog where the partitions in question reside. If none is supplied, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(&self) -> std::option::Option<&str> {
self.catalog_id.as_deref()
}
/// <p>The name of the catalog database where the partitions reside.</p>
pub fn database_name(&self) -> std::option::Option<&str> {
self.database_name.as_deref()
}
/// <p>The name of the partitions' table.</p>
pub fn table_name(&self) -> std::option::Option<&str> {
self.table_name.as_deref()
}
/// <p>A list of partition values identifying the partition.</p>
pub fn partition_values(&self) -> std::option::Option<&[std::string::String]> {
self.partition_values.as_deref()
}
/// <p>A list of the column names.</p>
pub fn column_names(&self) -> std::option::Option<&[std::string::String]> {
self.column_names.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetClassifiersInput {
/// <p>The size of the list to return (optional).</p>
#[doc(hidden)]
pub max_results: std::option::Option<i32>,
/// <p>An optional continuation token.</p>
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
}
impl GetClassifiersInput {
/// <p>The size of the list to return (optional).</p>
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
/// <p>An optional continuation token.</p>
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetClassifierInput {
/// <p>Name of the classifier to retrieve.</p>
#[doc(hidden)]
pub name: std::option::Option<std::string::String>,
}
impl GetClassifierInput {
/// <p>Name of the classifier to retrieve.</p>
pub fn name(&self) -> std::option::Option<&str> {
self.name.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetCatalogImportStatusInput {
/// <p>The ID of the catalog to migrate. Currently, this should be the Amazon Web Services account ID.</p>
#[doc(hidden)]
pub catalog_id: std::option::Option<std::string::String>,
}
impl GetCatalogImportStatusInput {
/// <p>The ID of the catalog to migrate. Currently, this should be the Amazon Web Services account ID.</p>
pub fn catalog_id(&self) -> std::option::Option<&str> {
self.catalog_id.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetBlueprintRunsInput {
/// <p>The name of the blueprint.</p>
#[doc(hidden)]
pub blueprint_name: std::option::Option<std::string::String>,
/// <p>A continuation token, if this is a continuation request.</p>
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
/// <p>The maximum size of a list to return.</p>
#[doc(hidden)]
pub max_results: std::option::Option<i32>,
}
impl GetBlueprintRunsInput {
/// <p>The name of the blueprint.</p>
pub fn blueprint_name(&self) -> std::option::Option<&str> {
self.blueprint_name.as_deref()
}
/// <p>A continuation token, if this is a continuation request.</p>
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
/// <p>The maximum size of a list to return.</p>
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetBlueprintRunInput {
/// <p>The name of the blueprint.</p>
#[doc(hidden)]
pub blueprint_name: std::option::Option<std::string::String>,
/// <p>The run ID for the blueprint run you want to retrieve.</p>
#[doc(hidden)]
pub run_id: std::option::Option<std::string::String>,
}
impl GetBlueprintRunInput {
/// <p>The name of the blueprint.</p>
pub fn blueprint_name(&self) -> std::option::Option<&str> {
self.blueprint_name.as_deref()
}
/// <p>The run ID for the blueprint run you want to retrieve.</p>
pub fn run_id(&self) -> std::option::Option<&str> {
self.run_id.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetBlueprintInput {
/// <p>The name of the blueprint.</p>
#[doc(hidden)]
pub name: std::option::Option<std::string::String>,
/// <p>Specifies whether or not to include the blueprint in the response.</p>
#[doc(hidden)]
pub include_blueprint: std::option::Option<bool>,
/// <p>Specifies whether or not to include the parameter specification.</p>
#[doc(hidden)]
pub include_parameter_spec: std::option::Option<bool>,
}
impl GetBlueprintInput {
/// <p>The name of the blueprint.</p>
pub fn name(&self) -> std::option::Option<&str> {
self.name.as_deref()
}
/// <p>Specifies whether or not to include the blueprint in the response.</p>
pub fn include_blueprint(&self) -> std::option::Option<bool> {
self.include_blueprint
}
/// <p>Specifies whether or not to include the parameter specification.</p>
pub fn include_parameter_spec(&self) -> std::option::Option<bool> {
self.include_parameter_spec
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteWorkflowInput {
/// <p>Name of the workflow to be deleted.</p>
#[doc(hidden)]
pub name: std::option::Option<std::string::String>,
}
impl DeleteWorkflowInput {
/// <p>Name of the workflow to be deleted.</p>
pub fn name(&self) -> std::option::Option<&str> {
self.name.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteUserDefinedFunctionInput {
/// <p>The ID of the Data Catalog where the function to be deleted is located. If none is supplied, the Amazon Web Services account ID is used by default.</p>
#[doc(hidden)]
pub catalog_id: std::option::Option<std::string::String>,
/// <p>The name of the catalog database where the function is located.</p>
#[doc(hidden)]
pub database_name: std::option::Option<std::string::String>,
/// <p>The name of the function definition to be deleted.</p>
#[doc(hidden)]
pub function_name: std::option::Option<std::string::String>,
}
impl DeleteUserDefinedFunctionInput {
/// <p>The ID of the Data Catalog where the function to be deleted is located. If none is supplied, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(&self) -> std::option::Option<&str> {
self.catalog_id.as_deref()
}
/// <p>The name of the catalog database where the function is located.</p>
pub fn database_name(&self) -> std::option::Option<&str> {
self.database_name.as_deref()
}
/// <p>The name of the function definition to be deleted.</p>
pub fn function_name(&self) -> std::option::Option<&str> {
self.function_name.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteTriggerInput {
/// <p>The name of the trigger to delete.</p>
#[doc(hidden)]
pub name: std::option::Option<std::string::String>,
}
impl DeleteTriggerInput {
/// <p>The name of the trigger to delete.</p>
pub fn name(&self) -> std::option::Option<&str> {
self.name.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteTableVersionInput {
/// <p>The ID of the Data Catalog where the tables reside. If none is provided, the Amazon Web Services account ID is used by default.</p>
#[doc(hidden)]
pub catalog_id: std::option::Option<std::string::String>,
/// <p>The database in the catalog in which the table resides. For Hive compatibility, this name is entirely lowercase.</p>
#[doc(hidden)]
pub database_name: std::option::Option<std::string::String>,
/// <p>The name of the table. For Hive compatibility, this name is entirely lowercase.</p>
#[doc(hidden)]
pub table_name: std::option::Option<std::string::String>,
/// <p>The ID of the table version to be deleted. A <code>VersionID</code> is a string representation of an integer. Each version is incremented by 1.</p>
#[doc(hidden)]
pub version_id: std::option::Option<std::string::String>,
}
impl DeleteTableVersionInput {
/// <p>The ID of the Data Catalog where the tables reside. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(&self) -> std::option::Option<&str> {
self.catalog_id.as_deref()
}
/// <p>The database in the catalog in which the table resides. For Hive compatibility, this name is entirely lowercase.</p>
pub fn database_name(&self) -> std::option::Option<&str> {
self.database_name.as_deref()
}
/// <p>The name of the table. For Hive compatibility, this name is entirely lowercase.</p>
pub fn table_name(&self) -> std::option::Option<&str> {
self.table_name.as_deref()
}
/// <p>The ID of the table version to be deleted. A <code>VersionID</code> is a string representation of an integer. Each version is incremented by 1.</p>
pub fn version_id(&self) -> std::option::Option<&str> {
self.version_id.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteTableInput {
/// <p>The ID of the Data Catalog where the table resides. If none is provided, the Amazon Web Services account ID is used by default.</p>
#[doc(hidden)]
pub catalog_id: std::option::Option<std::string::String>,
/// <p>The name of the catalog database in which the table resides. For Hive compatibility, this name is entirely lowercase.</p>
#[doc(hidden)]
pub database_name: std::option::Option<std::string::String>,
/// <p>The name of the table to be deleted. For Hive compatibility, this name is entirely lowercase.</p>
#[doc(hidden)]
pub name: std::option::Option<std::string::String>,
/// <p>The transaction ID at which to delete the table contents.</p>
#[doc(hidden)]
pub transaction_id: std::option::Option<std::string::String>,
}
impl DeleteTableInput {
/// <p>The ID of the Data Catalog where the table resides. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(&self) -> std::option::Option<&str> {
self.catalog_id.as_deref()
}
/// <p>The name of the catalog database in which the table resides. For Hive compatibility, this name is entirely lowercase.</p>
pub fn database_name(&self) -> std::option::Option<&str> {
self.database_name.as_deref()
}
/// <p>The name of the table to be deleted. For Hive compatibility, this name is entirely lowercase.</p>
pub fn name(&self) -> std::option::Option<&str> {
self.name.as_deref()
}
/// <p>The transaction ID at which to delete the table contents.</p>
pub fn transaction_id(&self) -> std::option::Option<&str> {
self.transaction_id.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteSessionInput {
/// <p>The ID of the session to be deleted.</p>
#[doc(hidden)]
pub id: std::option::Option<std::string::String>,
/// <p>The name of the origin of the delete session request.</p>
#[doc(hidden)]
pub request_origin: std::option::Option<std::string::String>,
}
impl DeleteSessionInput {
/// <p>The ID of the session to be deleted.</p>
pub fn id(&self) -> std::option::Option<&str> {
self.id.as_deref()
}
/// <p>The name of the origin of the delete session request.</p>
pub fn request_origin(&self) -> std::option::Option<&str> {
self.request_origin.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteSecurityConfigurationInput {
/// <p>The name of the security configuration to delete.</p>
#[doc(hidden)]
pub name: std::option::Option<std::string::String>,
}
impl DeleteSecurityConfigurationInput {
/// <p>The name of the security configuration to delete.</p>
pub fn name(&self) -> std::option::Option<&str> {
self.name.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteSchemaVersionsInput {
/// <p>This is a wrapper structure that may contain the schema name and Amazon Resource Name (ARN).</p>
#[doc(hidden)]
pub schema_id: std::option::Option<crate::model::SchemaId>,
/// <p>A version range may be supplied which may be of the format:</p>
/// <ul>
/// <li> <p>a single version number, 5</p> </li>
/// <li> <p>a range, 5-8 : deletes versions 5, 6, 7, 8</p> </li>
/// </ul>
#[doc(hidden)]
pub versions: std::option::Option<std::string::String>,
}
impl DeleteSchemaVersionsInput {
/// <p>This is a wrapper structure that may contain the schema name and Amazon Resource Name (ARN).</p>
pub fn schema_id(&self) -> std::option::Option<&crate::model::SchemaId> {
self.schema_id.as_ref()
}
/// <p>A version range may be supplied which may be of the format:</p>
/// <ul>
/// <li> <p>a single version number, 5</p> </li>
/// <li> <p>a range, 5-8 : deletes versions 5, 6, 7, 8</p> </li>
/// </ul>
pub fn versions(&self) -> std::option::Option<&str> {
self.versions.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteSchemaInput {
/// <p>This is a wrapper structure that may contain the schema name and Amazon Resource Name (ARN).</p>
#[doc(hidden)]
pub schema_id: std::option::Option<crate::model::SchemaId>,
}
impl DeleteSchemaInput {
/// <p>This is a wrapper structure that may contain the schema name and Amazon Resource Name (ARN).</p>
pub fn schema_id(&self) -> std::option::Option<&crate::model::SchemaId> {
self.schema_id.as_ref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteResourcePolicyInput {
/// <p>The hash value returned when this policy was set.</p>
#[doc(hidden)]
pub policy_hash_condition: std::option::Option<std::string::String>,
/// <p>The ARN of the Glue resource for the resource policy to be deleted.</p>
#[doc(hidden)]
pub resource_arn: std::option::Option<std::string::String>,
}
impl DeleteResourcePolicyInput {
/// <p>The hash value returned when this policy was set.</p>
pub fn policy_hash_condition(&self) -> std::option::Option<&str> {
self.policy_hash_condition.as_deref()
}
/// <p>The ARN of the Glue resource for the resource policy to be deleted.</p>
pub fn resource_arn(&self) -> std::option::Option<&str> {
self.resource_arn.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteRegistryInput {
/// <p>This is a wrapper structure that may contain the registry name and Amazon Resource Name (ARN).</p>
#[doc(hidden)]
pub registry_id: std::option::Option<crate::model::RegistryId>,
}
impl DeleteRegistryInput {
/// <p>This is a wrapper structure that may contain the registry name and Amazon Resource Name (ARN).</p>
pub fn registry_id(&self) -> std::option::Option<&crate::model::RegistryId> {
self.registry_id.as_ref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeletePartitionIndexInput {
/// <p>The catalog ID where the table resides.</p>
#[doc(hidden)]
pub catalog_id: std::option::Option<std::string::String>,
/// <p>Specifies the name of a database from which you want to delete a partition index.</p>
#[doc(hidden)]
pub database_name: std::option::Option<std::string::String>,
/// <p>Specifies the name of a table from which you want to delete a partition index.</p>
#[doc(hidden)]
pub table_name: std::option::Option<std::string::String>,
/// <p>The name of the partition index to be deleted.</p>
#[doc(hidden)]
pub index_name: std::option::Option<std::string::String>,
}
impl DeletePartitionIndexInput {
/// <p>The catalog ID where the table resides.</p>
pub fn catalog_id(&self) -> std::option::Option<&str> {
self.catalog_id.as_deref()
}
/// <p>Specifies the name of a database from which you want to delete a partition index.</p>
pub fn database_name(&self) -> std::option::Option<&str> {
self.database_name.as_deref()
}
/// <p>Specifies the name of a table from which you want to delete a partition index.</p>
pub fn table_name(&self) -> std::option::Option<&str> {
self.table_name.as_deref()
}
/// <p>The name of the partition index to be deleted.</p>
pub fn index_name(&self) -> std::option::Option<&str> {
self.index_name.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeletePartitionInput {
/// <p>The ID of the Data Catalog where the partition to be deleted resides. If none is provided, the Amazon Web Services account ID is used by default.</p>
#[doc(hidden)]
pub catalog_id: std::option::Option<std::string::String>,
/// <p>The name of the catalog database in which the table in question resides.</p>
#[doc(hidden)]
pub database_name: std::option::Option<std::string::String>,
/// <p>The name of the table that contains the partition to be deleted.</p>
#[doc(hidden)]
pub table_name: std::option::Option<std::string::String>,
/// <p>The values that define the partition.</p>
#[doc(hidden)]
pub partition_values: std::option::Option<std::vec::Vec<std::string::String>>,
}
impl DeletePartitionInput {
/// <p>The ID of the Data Catalog where the partition to be deleted resides. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(&self) -> std::option::Option<&str> {
self.catalog_id.as_deref()
}
/// <p>The name of the catalog database in which the table in question resides.</p>
pub fn database_name(&self) -> std::option::Option<&str> {
self.database_name.as_deref()
}
/// <p>The name of the table that contains the partition to be deleted.</p>
pub fn table_name(&self) -> std::option::Option<&str> {
self.table_name.as_deref()
}
/// <p>The values that define the partition.</p>
pub fn partition_values(&self) -> std::option::Option<&[std::string::String]> {
self.partition_values.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteMlTransformInput {
/// <p>The unique identifier of the transform to delete.</p>
#[doc(hidden)]
pub transform_id: std::option::Option<std::string::String>,
}
impl DeleteMlTransformInput {
/// <p>The unique identifier of the transform to delete.</p>
pub fn transform_id(&self) -> std::option::Option<&str> {
self.transform_id.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteJobInput {
/// <p>The name of the job definition to delete.</p>
#[doc(hidden)]
pub job_name: std::option::Option<std::string::String>,
}
impl DeleteJobInput {
/// <p>The name of the job definition to delete.</p>
pub fn job_name(&self) -> std::option::Option<&str> {
self.job_name.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteDevEndpointInput {
/// <p>The name of the <code>DevEndpoint</code>.</p>
#[doc(hidden)]
pub endpoint_name: std::option::Option<std::string::String>,
}
impl DeleteDevEndpointInput {
/// <p>The name of the <code>DevEndpoint</code>.</p>
pub fn endpoint_name(&self) -> std::option::Option<&str> {
self.endpoint_name.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteDataQualityRulesetInput {
/// <p>A name for the data quality ruleset.</p>
#[doc(hidden)]
pub name: std::option::Option<std::string::String>,
}
impl DeleteDataQualityRulesetInput {
/// <p>A name for the data quality ruleset.</p>
pub fn name(&self) -> std::option::Option<&str> {
self.name.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteDatabaseInput {
/// <p>The ID of the Data Catalog in which the database resides. If none is provided, the Amazon Web Services account ID is used by default.</p>
#[doc(hidden)]
pub catalog_id: std::option::Option<std::string::String>,
/// <p>The name of the database to delete. For Hive compatibility, this must be all lowercase.</p>
#[doc(hidden)]
pub name: std::option::Option<std::string::String>,
}
impl DeleteDatabaseInput {
/// <p>The ID of the Data Catalog in which the database resides. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(&self) -> std::option::Option<&str> {
self.catalog_id.as_deref()
}
/// <p>The name of the database to delete. For Hive compatibility, this must be all lowercase.</p>
pub fn name(&self) -> std::option::Option<&str> {
self.name.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteCustomEntityTypeInput {
/// <p>The name of the custom pattern that you want to delete.</p>
#[doc(hidden)]
pub name: std::option::Option<std::string::String>,
}
impl DeleteCustomEntityTypeInput {
/// <p>The name of the custom pattern that you want to delete.</p>
pub fn name(&self) -> std::option::Option<&str> {
self.name.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteCrawlerInput {
/// <p>The name of the crawler to remove.</p>
#[doc(hidden)]
pub name: std::option::Option<std::string::String>,
}
impl DeleteCrawlerInput {
/// <p>The name of the crawler to remove.</p>
pub fn name(&self) -> std::option::Option<&str> {
self.name.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteConnectionInput {
/// <p>The ID of the Data Catalog in which the connection resides. If none is provided, the Amazon Web Services account ID is used by default.</p>
#[doc(hidden)]
pub catalog_id: std::option::Option<std::string::String>,
/// <p>The name of the connection to delete.</p>
#[doc(hidden)]
pub connection_name: std::option::Option<std::string::String>,
}
impl DeleteConnectionInput {
/// <p>The ID of the Data Catalog in which the connection resides. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(&self) -> std::option::Option<&str> {
self.catalog_id.as_deref()
}
/// <p>The name of the connection to delete.</p>
pub fn connection_name(&self) -> std::option::Option<&str> {
self.connection_name.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteColumnStatisticsForTableInput {
/// <p>The ID of the Data Catalog where the partitions in question reside. If none is supplied, the Amazon Web Services account ID is used by default.</p>
#[doc(hidden)]
pub catalog_id: std::option::Option<std::string::String>,
/// <p>The name of the catalog database where the partitions reside.</p>
#[doc(hidden)]
pub database_name: std::option::Option<std::string::String>,
/// <p>The name of the partitions' table.</p>
#[doc(hidden)]
pub table_name: std::option::Option<std::string::String>,
/// <p>The name of the column.</p>
#[doc(hidden)]
pub column_name: std::option::Option<std::string::String>,
}
impl DeleteColumnStatisticsForTableInput {
/// <p>The ID of the Data Catalog where the partitions in question reside. If none is supplied, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(&self) -> std::option::Option<&str> {
self.catalog_id.as_deref()
}
/// <p>The name of the catalog database where the partitions reside.</p>
pub fn database_name(&self) -> std::option::Option<&str> {
self.database_name.as_deref()
}
/// <p>The name of the partitions' table.</p>
pub fn table_name(&self) -> std::option::Option<&str> {
self.table_name.as_deref()
}
/// <p>The name of the column.</p>
pub fn column_name(&self) -> std::option::Option<&str> {
self.column_name.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteColumnStatisticsForPartitionInput {
/// <p>The ID of the Data Catalog where the partitions in question reside. If none is supplied, the Amazon Web Services account ID is used by default.</p>
#[doc(hidden)]
pub catalog_id: std::option::Option<std::string::String>,
/// <p>The name of the catalog database where the partitions reside.</p>
#[doc(hidden)]
pub database_name: std::option::Option<std::string::String>,
/// <p>The name of the partitions' table.</p>
#[doc(hidden)]
pub table_name: std::option::Option<std::string::String>,
/// <p>A list of partition values identifying the partition.</p>
#[doc(hidden)]
pub partition_values: std::option::Option<std::vec::Vec<std::string::String>>,
/// <p>Name of the column.</p>
#[doc(hidden)]
pub column_name: std::option::Option<std::string::String>,
}
impl DeleteColumnStatisticsForPartitionInput {
/// <p>The ID of the Data Catalog where the partitions in question reside. If none is supplied, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(&self) -> std::option::Option<&str> {
self.catalog_id.as_deref()
}
/// <p>The name of the catalog database where the partitions reside.</p>
pub fn database_name(&self) -> std::option::Option<&str> {
self.database_name.as_deref()
}
/// <p>The name of the partitions' table.</p>
pub fn table_name(&self) -> std::option::Option<&str> {
self.table_name.as_deref()
}
/// <p>A list of partition values identifying the partition.</p>
pub fn partition_values(&self) -> std::option::Option<&[std::string::String]> {
self.partition_values.as_deref()
}
/// <p>Name of the column.</p>
pub fn column_name(&self) -> std::option::Option<&str> {
self.column_name.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteClassifierInput {
/// <p>Name of the classifier to remove.</p>
#[doc(hidden)]
pub name: std::option::Option<std::string::String>,
}
impl DeleteClassifierInput {
/// <p>Name of the classifier to remove.</p>
pub fn name(&self) -> std::option::Option<&str> {
self.name.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteBlueprintInput {
/// <p>The name of the blueprint to delete.</p>
#[doc(hidden)]
pub name: std::option::Option<std::string::String>,
}
impl DeleteBlueprintInput {
/// <p>The name of the blueprint to delete.</p>
pub fn name(&self) -> std::option::Option<&str> {
self.name.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CreateWorkflowInput {
/// <p>The name to be assigned to the workflow. It should be unique within your account.</p>
#[doc(hidden)]
pub name: std::option::Option<std::string::String>,
/// <p>A description of the workflow.</p>
#[doc(hidden)]
pub description: std::option::Option<std::string::String>,
/// <p>A collection of properties to be used as part of each execution of the workflow.</p>
#[doc(hidden)]
pub default_run_properties:
std::option::Option<std::collections::HashMap<std::string::String, std::string::String>>,
/// <p>The tags to be used with this workflow.</p>
#[doc(hidden)]
pub tags:
std::option::Option<std::collections::HashMap<std::string::String, std::string::String>>,
/// <p>You can use this parameter to prevent unwanted multiple updates to data, to control costs, or in some cases, to prevent exceeding the maximum number of concurrent runs of any of the component jobs. If you leave this parameter blank, there is no limit to the number of concurrent workflow runs.</p>
#[doc(hidden)]
pub max_concurrent_runs: std::option::Option<i32>,
}
impl CreateWorkflowInput {
/// <p>The name to be assigned to the workflow. It should be unique within your account.</p>
pub fn name(&self) -> std::option::Option<&str> {
self.name.as_deref()
}
/// <p>A description of the workflow.</p>
pub fn description(&self) -> std::option::Option<&str> {
self.description.as_deref()
}
/// <p>A collection of properties to be used as part of each execution of the workflow.</p>
pub fn default_run_properties(
&self,
) -> std::option::Option<&std::collections::HashMap<std::string::String, std::string::String>>
{
self.default_run_properties.as_ref()
}
/// <p>The tags to be used with this workflow.</p>
pub fn tags(
&self,
) -> std::option::Option<&std::collections::HashMap<std::string::String, std::string::String>>
{
self.tags.as_ref()
}
/// <p>You can use this parameter to prevent unwanted multiple updates to data, to control costs, or in some cases, to prevent exceeding the maximum number of concurrent runs of any of the component jobs. If you leave this parameter blank, there is no limit to the number of concurrent workflow runs.</p>
pub fn max_concurrent_runs(&self) -> std::option::Option<i32> {
self.max_concurrent_runs
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CreateUserDefinedFunctionInput {
/// <p>The ID of the Data Catalog in which to create the function. If none is provided, the Amazon Web Services account ID is used by default.</p>
#[doc(hidden)]
pub catalog_id: std::option::Option<std::string::String>,
/// <p>The name of the catalog database in which to create the function.</p>
#[doc(hidden)]
pub database_name: std::option::Option<std::string::String>,
/// <p>A <code>FunctionInput</code> object that defines the function to create in the Data Catalog.</p>
#[doc(hidden)]
pub function_input: std::option::Option<crate::model::UserDefinedFunctionInput>,
}
impl CreateUserDefinedFunctionInput {
/// <p>The ID of the Data Catalog in which to create the function. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(&self) -> std::option::Option<&str> {
self.catalog_id.as_deref()
}
/// <p>The name of the catalog database in which to create the function.</p>
pub fn database_name(&self) -> std::option::Option<&str> {
self.database_name.as_deref()
}
/// <p>A <code>FunctionInput</code> object that defines the function to create in the Data Catalog.</p>
pub fn function_input(&self) -> std::option::Option<&crate::model::UserDefinedFunctionInput> {
self.function_input.as_ref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CreateTriggerInput {
/// <p>The name of the trigger.</p>
#[doc(hidden)]
pub name: std::option::Option<std::string::String>,
/// <p>The name of the workflow associated with the trigger.</p>
#[doc(hidden)]
pub workflow_name: std::option::Option<std::string::String>,
/// <p>The type of the new trigger.</p>
#[doc(hidden)]
pub r#type: std::option::Option<crate::model::TriggerType>,
/// <p>A <code>cron</code> expression used to specify the schedule (see <a href="https://docs.aws.amazon.com/glue/latest/dg/monitor-data-warehouse-schedule.html">Time-Based Schedules for Jobs and Crawlers</a>. For example, to run something every day at 12:15 UTC, you would specify: <code>cron(15 12 * * ? *)</code>.</p>
/// <p>This field is required when the trigger type is SCHEDULED.</p>
#[doc(hidden)]
pub schedule: std::option::Option<std::string::String>,
/// <p>A predicate to specify when the new trigger should fire.</p>
/// <p>This field is required when the trigger type is <code>CONDITIONAL</code>.</p>
#[doc(hidden)]
pub predicate: std::option::Option<crate::model::Predicate>,
/// <p>The actions initiated by this trigger when it fires.</p>
#[doc(hidden)]
pub actions: std::option::Option<std::vec::Vec<crate::model::Action>>,
/// <p>A description of the new trigger.</p>
#[doc(hidden)]
pub description: std::option::Option<std::string::String>,
/// <p>Set to <code>true</code> to start <code>SCHEDULED</code> and <code>CONDITIONAL</code> triggers when created. True is not supported for <code>ON_DEMAND</code> triggers.</p>
#[doc(hidden)]
pub start_on_creation: bool,
/// <p>The tags to use with this trigger. You may use tags to limit access to the trigger. For more information about tags in Glue, see <a href="https://docs.aws.amazon.com/glue/latest/dg/monitor-tags.html">Amazon Web Services Tags in Glue</a> in the developer guide. </p>
#[doc(hidden)]
pub tags:
std::option::Option<std::collections::HashMap<std::string::String, std::string::String>>,
/// <p>Batch condition that must be met (specified number of events received or batch time window expired) before EventBridge event trigger fires.</p>
#[doc(hidden)]
pub event_batching_condition: std::option::Option<crate::model::EventBatchingCondition>,
}
impl CreateTriggerInput {
/// <p>The name of the trigger.</p>
pub fn name(&self) -> std::option::Option<&str> {
self.name.as_deref()
}
/// <p>The name of the workflow associated with the trigger.</p>
pub fn workflow_name(&self) -> std::option::Option<&str> {
self.workflow_name.as_deref()
}
/// <p>The type of the new trigger.</p>
pub fn r#type(&self) -> std::option::Option<&crate::model::TriggerType> {
self.r#type.as_ref()
}
/// <p>A <code>cron</code> expression used to specify the schedule (see <a href="https://docs.aws.amazon.com/glue/latest/dg/monitor-data-warehouse-schedule.html">Time-Based Schedules for Jobs and Crawlers</a>. For example, to run something every day at 12:15 UTC, you would specify: <code>cron(15 12 * * ? *)</code>.</p>
/// <p>This field is required when the trigger type is SCHEDULED.</p>
pub fn schedule(&self) -> std::option::Option<&str> {
self.schedule.as_deref()
}
/// <p>A predicate to specify when the new trigger should fire.</p>
/// <p>This field is required when the trigger type is <code>CONDITIONAL</code>.</p>
pub fn predicate(&self) -> std::option::Option<&crate::model::Predicate> {
self.predicate.as_ref()
}
/// <p>The actions initiated by this trigger when it fires.</p>
pub fn actions(&self) -> std::option::Option<&[crate::model::Action]> {
self.actions.as_deref()
}
/// <p>A description of the new trigger.</p>
pub fn description(&self) -> std::option::Option<&str> {
self.description.as_deref()
}
/// <p>Set to <code>true</code> to start <code>SCHEDULED</code> and <code>CONDITIONAL</code> triggers when created. True is not supported for <code>ON_DEMAND</code> triggers.</p>
pub fn start_on_creation(&self) -> bool {
self.start_on_creation
}
/// <p>The tags to use with this trigger. You may use tags to limit access to the trigger. For more information about tags in Glue, see <a href="https://docs.aws.amazon.com/glue/latest/dg/monitor-tags.html">Amazon Web Services Tags in Glue</a> in the developer guide. </p>
pub fn tags(
&self,
) -> std::option::Option<&std::collections::HashMap<std::string::String, std::string::String>>
{
self.tags.as_ref()
}
/// <p>Batch condition that must be met (specified number of events received or batch time window expired) before EventBridge event trigger fires.</p>
pub fn event_batching_condition(
&self,
) -> std::option::Option<&crate::model::EventBatchingCondition> {
self.event_batching_condition.as_ref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CreateTableInput {
/// <p>The ID of the Data Catalog in which to create the <code>Table</code>. If none is supplied, the Amazon Web Services account ID is used by default.</p>
#[doc(hidden)]
pub catalog_id: std::option::Option<std::string::String>,
/// <p>The catalog database in which to create the new table. For Hive compatibility, this name is entirely lowercase.</p>
#[doc(hidden)]
pub database_name: std::option::Option<std::string::String>,
/// <p>The <code>TableInput</code> object that defines the metadata table to create in the catalog.</p>
#[doc(hidden)]
pub table_input: std::option::Option<crate::model::TableInput>,
/// <p>A list of partition indexes, <code>PartitionIndex</code> structures, to create in the table.</p>
#[doc(hidden)]
pub partition_indexes: std::option::Option<std::vec::Vec<crate::model::PartitionIndex>>,
/// <p>The ID of the transaction.</p>
#[doc(hidden)]
pub transaction_id: std::option::Option<std::string::String>,
}
impl CreateTableInput {
/// <p>The ID of the Data Catalog in which to create the <code>Table</code>. If none is supplied, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(&self) -> std::option::Option<&str> {
self.catalog_id.as_deref()
}
/// <p>The catalog database in which to create the new table. For Hive compatibility, this name is entirely lowercase.</p>
pub fn database_name(&self) -> std::option::Option<&str> {
self.database_name.as_deref()
}
/// <p>The <code>TableInput</code> object that defines the metadata table to create in the catalog.</p>
pub fn table_input(&self) -> std::option::Option<&crate::model::TableInput> {
self.table_input.as_ref()
}
/// <p>A list of partition indexes, <code>PartitionIndex</code> structures, to create in the table.</p>
pub fn partition_indexes(&self) -> std::option::Option<&[crate::model::PartitionIndex]> {
self.partition_indexes.as_deref()
}
/// <p>The ID of the transaction.</p>
pub fn transaction_id(&self) -> std::option::Option<&str> {
self.transaction_id.as_deref()
}
}
/// <p>Request to create a new session.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CreateSessionInput {
/// <p>The ID of the session request. </p>
#[doc(hidden)]
pub id: std::option::Option<std::string::String>,
/// <p>The description of the session. </p>
#[doc(hidden)]
pub description: std::option::Option<std::string::String>,
/// <p>The IAM Role ARN </p>
#[doc(hidden)]
pub role: std::option::Option<std::string::String>,
/// <p>The <code>SessionCommand</code> that runs the job. </p>
#[doc(hidden)]
pub command: std::option::Option<crate::model::SessionCommand>,
/// <p>The number of seconds before request times out. </p>
#[doc(hidden)]
pub timeout: std::option::Option<i32>,
/// <p>The number of seconds when idle before request times out. </p>
#[doc(hidden)]
pub idle_timeout: std::option::Option<i32>,
/// <p>A map array of key-value pairs. Max is 75 pairs. </p>
#[doc(hidden)]
pub default_arguments:
std::option::Option<std::collections::HashMap<std::string::String, std::string::String>>,
/// <p>The number of connections to use for the session. </p>
#[doc(hidden)]
pub connections: std::option::Option<crate::model::ConnectionsList>,
/// <p>The number of Glue data processing units (DPUs) that can be allocated when the job runs. A DPU is a relative measure of processing power that consists of 4 vCPUs of compute capacity and 16 GB memory. </p>
#[doc(hidden)]
pub max_capacity: std::option::Option<f64>,
/// <p>The number of workers of a defined <code>WorkerType</code> to use for the session. </p>
#[doc(hidden)]
pub number_of_workers: std::option::Option<i32>,
/// <p>The type of predefined worker that is allocated to use for the session. Accepts a value of Standard, G.1X, G.2X, or G.025X.</p>
/// <ul>
/// <li> <p>For the <code>Standard</code> worker type, each worker provides 4 vCPU, 16 GB of memory and a 50GB disk, and 2 executors per worker.</p> </li>
/// <li> <p>For the <code>G.1X</code> worker type, each worker maps to 1 DPU (4 vCPU, 16 GB of memory, 64 GB disk), and provides 1 executor per worker. We recommend this worker type for memory-intensive jobs.</p> </li>
/// <li> <p>For the <code>G.2X</code> worker type, each worker maps to 2 DPU (8 vCPU, 32 GB of memory, 128 GB disk), and provides 1 executor per worker. We recommend this worker type for memory-intensive jobs.</p> </li>
/// <li> <p>For the <code>G.025X</code> worker type, each worker maps to 0.25 DPU (2 vCPU, 4 GB of memory, 64 GB disk), and provides 1 executor per worker. We recommend this worker type for low volume streaming jobs. This worker type is only available for Glue version 3.0 streaming jobs.</p> </li>
/// </ul>
#[doc(hidden)]
pub worker_type: std::option::Option<crate::model::WorkerType>,
/// <p>The name of the SecurityConfiguration structure to be used with the session </p>
#[doc(hidden)]
pub security_configuration: std::option::Option<std::string::String>,
/// <p>The Glue version determines the versions of Apache Spark and Python that Glue supports. The GlueVersion must be greater than 2.0. </p>
#[doc(hidden)]
pub glue_version: std::option::Option<std::string::String>,
/// <p>The map of key value pairs (tags) belonging to the session.</p>
#[doc(hidden)]
pub tags:
std::option::Option<std::collections::HashMap<std::string::String, std::string::String>>,
/// <p>The origin of the request. </p>
#[doc(hidden)]
pub request_origin: std::option::Option<std::string::String>,
}
impl CreateSessionInput {
/// <p>The ID of the session request. </p>
pub fn id(&self) -> std::option::Option<&str> {
self.id.as_deref()
}
/// <p>The description of the session. </p>
pub fn description(&self) -> std::option::Option<&str> {
self.description.as_deref()
}
/// <p>The IAM Role ARN </p>
pub fn role(&self) -> std::option::Option<&str> {
self.role.as_deref()
}
/// <p>The <code>SessionCommand</code> that runs the job. </p>
pub fn command(&self) -> std::option::Option<&crate::model::SessionCommand> {
self.command.as_ref()
}
/// <p>The number of seconds before request times out. </p>
pub fn timeout(&self) -> std::option::Option<i32> {
self.timeout
}
/// <p>The number of seconds when idle before request times out. </p>
pub fn idle_timeout(&self) -> std::option::Option<i32> {
self.idle_timeout
}
/// <p>A map array of key-value pairs. Max is 75 pairs. </p>
pub fn default_arguments(
&self,
) -> std::option::Option<&std::collections::HashMap<std::string::String, std::string::String>>
{
self.default_arguments.as_ref()
}
/// <p>The number of connections to use for the session. </p>
pub fn connections(&self) -> std::option::Option<&crate::model::ConnectionsList> {
self.connections.as_ref()
}
/// <p>The number of Glue data processing units (DPUs) that can be allocated when the job runs. A DPU is a relative measure of processing power that consists of 4 vCPUs of compute capacity and 16 GB memory. </p>
pub fn max_capacity(&self) -> std::option::Option<f64> {
self.max_capacity
}
/// <p>The number of workers of a defined <code>WorkerType</code> to use for the session. </p>
pub fn number_of_workers(&self) -> std::option::Option<i32> {
self.number_of_workers
}
/// <p>The type of predefined worker that is allocated to use for the session. Accepts a value of Standard, G.1X, G.2X, or G.025X.</p>
/// <ul>
/// <li> <p>For the <code>Standard</code> worker type, each worker provides 4 vCPU, 16 GB of memory and a 50GB disk, and 2 executors per worker.</p> </li>
/// <li> <p>For the <code>G.1X</code> worker type, each worker maps to 1 DPU (4 vCPU, 16 GB of memory, 64 GB disk), and provides 1 executor per worker. We recommend this worker type for memory-intensive jobs.</p> </li>
/// <li> <p>For the <code>G.2X</code> worker type, each worker maps to 2 DPU (8 vCPU, 32 GB of memory, 128 GB disk), and provides 1 executor per worker. We recommend this worker type for memory-intensive jobs.</p> </li>
/// <li> <p>For the <code>G.025X</code> worker type, each worker maps to 0.25 DPU (2 vCPU, 4 GB of memory, 64 GB disk), and provides 1 executor per worker. We recommend this worker type for low volume streaming jobs. This worker type is only available for Glue version 3.0 streaming jobs.</p> </li>
/// </ul>
pub fn worker_type(&self) -> std::option::Option<&crate::model::WorkerType> {
self.worker_type.as_ref()
}
/// <p>The name of the SecurityConfiguration structure to be used with the session </p>
pub fn security_configuration(&self) -> std::option::Option<&str> {
self.security_configuration.as_deref()
}
/// <p>The Glue version determines the versions of Apache Spark and Python that Glue supports. The GlueVersion must be greater than 2.0. </p>
pub fn glue_version(&self) -> std::option::Option<&str> {
self.glue_version.as_deref()
}
/// <p>The map of key value pairs (tags) belonging to the session.</p>
pub fn tags(
&self,
) -> std::option::Option<&std::collections::HashMap<std::string::String, std::string::String>>
{
self.tags.as_ref()
}
/// <p>The origin of the request. </p>
pub fn request_origin(&self) -> std::option::Option<&str> {
self.request_origin.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CreateSecurityConfigurationInput {
/// <p>The name for the new security configuration.</p>
#[doc(hidden)]
pub name: std::option::Option<std::string::String>,
/// <p>The encryption configuration for the new security configuration.</p>
#[doc(hidden)]
pub encryption_configuration: std::option::Option<crate::model::EncryptionConfiguration>,
}
impl CreateSecurityConfigurationInput {
/// <p>The name for the new security configuration.</p>
pub fn name(&self) -> std::option::Option<&str> {
self.name.as_deref()
}
/// <p>The encryption configuration for the new security configuration.</p>
pub fn encryption_configuration(
&self,
) -> std::option::Option<&crate::model::EncryptionConfiguration> {
self.encryption_configuration.as_ref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CreateScriptInput {
/// <p>A list of the nodes in the DAG.</p>
#[doc(hidden)]
pub dag_nodes: std::option::Option<std::vec::Vec<crate::model::CodeGenNode>>,
/// <p>A list of the edges in the DAG.</p>
#[doc(hidden)]
pub dag_edges: std::option::Option<std::vec::Vec<crate::model::CodeGenEdge>>,
/// <p>The programming language of the resulting code from the DAG.</p>
#[doc(hidden)]
pub language: std::option::Option<crate::model::Language>,
}
impl CreateScriptInput {
/// <p>A list of the nodes in the DAG.</p>
pub fn dag_nodes(&self) -> std::option::Option<&[crate::model::CodeGenNode]> {
self.dag_nodes.as_deref()
}
/// <p>A list of the edges in the DAG.</p>
pub fn dag_edges(&self) -> std::option::Option<&[crate::model::CodeGenEdge]> {
self.dag_edges.as_deref()
}
/// <p>The programming language of the resulting code from the DAG.</p>
pub fn language(&self) -> std::option::Option<&crate::model::Language> {
self.language.as_ref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CreateSchemaInput {
/// <p> This is a wrapper shape to contain the registry identity fields. If this is not provided, the default registry will be used. The ARN format for the same will be: <code>arn:aws:glue:us-east-2:
/// <customer id>
/// :registry/default-registry:random-5-letter-id
/// </customer></code>.</p>
#[doc(hidden)]
pub registry_id: std::option::Option<crate::model::RegistryId>,
/// <p>Name of the schema to be created of max length of 255, and may only contain letters, numbers, hyphen, underscore, dollar sign, or hash mark. No whitespace.</p>
#[doc(hidden)]
pub schema_name: std::option::Option<std::string::String>,
/// <p>The data format of the schema definition. Currently <code>AVRO</code>, <code>JSON</code> and <code>PROTOBUF</code> are supported.</p>
#[doc(hidden)]
pub data_format: std::option::Option<crate::model::DataFormat>,
/// <p>The compatibility mode of the schema. The possible values are:</p>
/// <ul>
/// <li> <p> <i>NONE</i>: No compatibility mode applies. You can use this choice in development scenarios or if you do not know the compatibility mode that you want to apply to schemas. Any new version added will be accepted without undergoing a compatibility check.</p> </li>
/// <li> <p> <i>DISABLED</i>: This compatibility choice prevents versioning for a particular schema. You can use this choice to prevent future versioning of a schema.</p> </li>
/// <li> <p> <i>BACKWARD</i>: This compatibility choice is recommended as it allows data receivers to read both the current and one previous schema version. This means that for instance, a new schema version cannot drop data fields or change the type of these fields, so they can't be read by readers using the previous version.</p> </li>
/// <li> <p> <i>BACKWARD_ALL</i>: This compatibility choice allows data receivers to read both the current and all previous schema versions. You can use this choice when you need to delete fields or add optional fields, and check compatibility against all previous schema versions. </p> </li>
/// <li> <p> <i>FORWARD</i>: This compatibility choice allows data receivers to read both the current and one next schema version, but not necessarily later versions. You can use this choice when you need to add fields or delete optional fields, but only check compatibility against the last schema version.</p> </li>
/// <li> <p> <i>FORWARD_ALL</i>: This compatibility choice allows data receivers to read written by producers of any new registered schema. You can use this choice when you need to add fields or delete optional fields, and check compatibility against all previous schema versions.</p> </li>
/// <li> <p> <i>FULL</i>: This compatibility choice allows data receivers to read data written by producers using the previous or next version of the schema, but not necessarily earlier or later versions. You can use this choice when you need to add or remove optional fields, but only check compatibility against the last schema version.</p> </li>
/// <li> <p> <i>FULL_ALL</i>: This compatibility choice allows data receivers to read data written by producers using all previous schema versions. You can use this choice when you need to add or remove optional fields, and check compatibility against all previous schema versions.</p> </li>
/// </ul>
#[doc(hidden)]
pub compatibility: std::option::Option<crate::model::Compatibility>,
/// <p>An optional description of the schema. If description is not provided, there will not be any automatic default value for this.</p>
#[doc(hidden)]
pub description: std::option::Option<std::string::String>,
/// <p>Amazon Web Services tags that contain a key value pair and may be searched by console, command line, or API. If specified, follows the Amazon Web Services tags-on-create pattern.</p>
#[doc(hidden)]
pub tags:
std::option::Option<std::collections::HashMap<std::string::String, std::string::String>>,
/// <p>The schema definition using the <code>DataFormat</code> setting for <code>SchemaName</code>.</p>
#[doc(hidden)]
pub schema_definition: std::option::Option<std::string::String>,
}
impl CreateSchemaInput {
/// <p> This is a wrapper shape to contain the registry identity fields. If this is not provided, the default registry will be used. The ARN format for the same will be: <code>arn:aws:glue:us-east-2:
/// <customer id>
/// :registry/default-registry:random-5-letter-id
/// </customer></code>.</p>
pub fn registry_id(&self) -> std::option::Option<&crate::model::RegistryId> {
self.registry_id.as_ref()
}
/// <p>Name of the schema to be created of max length of 255, and may only contain letters, numbers, hyphen, underscore, dollar sign, or hash mark. No whitespace.</p>
pub fn schema_name(&self) -> std::option::Option<&str> {
self.schema_name.as_deref()
}
/// <p>The data format of the schema definition. Currently <code>AVRO</code>, <code>JSON</code> and <code>PROTOBUF</code> are supported.</p>
pub fn data_format(&self) -> std::option::Option<&crate::model::DataFormat> {
self.data_format.as_ref()
}
/// <p>The compatibility mode of the schema. The possible values are:</p>
/// <ul>
/// <li> <p> <i>NONE</i>: No compatibility mode applies. You can use this choice in development scenarios or if you do not know the compatibility mode that you want to apply to schemas. Any new version added will be accepted without undergoing a compatibility check.</p> </li>
/// <li> <p> <i>DISABLED</i>: This compatibility choice prevents versioning for a particular schema. You can use this choice to prevent future versioning of a schema.</p> </li>
/// <li> <p> <i>BACKWARD</i>: This compatibility choice is recommended as it allows data receivers to read both the current and one previous schema version. This means that for instance, a new schema version cannot drop data fields or change the type of these fields, so they can't be read by readers using the previous version.</p> </li>
/// <li> <p> <i>BACKWARD_ALL</i>: This compatibility choice allows data receivers to read both the current and all previous schema versions. You can use this choice when you need to delete fields or add optional fields, and check compatibility against all previous schema versions. </p> </li>
/// <li> <p> <i>FORWARD</i>: This compatibility choice allows data receivers to read both the current and one next schema version, but not necessarily later versions. You can use this choice when you need to add fields or delete optional fields, but only check compatibility against the last schema version.</p> </li>
/// <li> <p> <i>FORWARD_ALL</i>: This compatibility choice allows data receivers to read written by producers of any new registered schema. You can use this choice when you need to add fields or delete optional fields, and check compatibility against all previous schema versions.</p> </li>
/// <li> <p> <i>FULL</i>: This compatibility choice allows data receivers to read data written by producers using the previous or next version of the schema, but not necessarily earlier or later versions. You can use this choice when you need to add or remove optional fields, but only check compatibility against the last schema version.</p> </li>
/// <li> <p> <i>FULL_ALL</i>: This compatibility choice allows data receivers to read data written by producers using all previous schema versions. You can use this choice when you need to add or remove optional fields, and check compatibility against all previous schema versions.</p> </li>
/// </ul>
pub fn compatibility(&self) -> std::option::Option<&crate::model::Compatibility> {
self.compatibility.as_ref()
}
/// <p>An optional description of the schema. If description is not provided, there will not be any automatic default value for this.</p>
pub fn description(&self) -> std::option::Option<&str> {
self.description.as_deref()
}
/// <p>Amazon Web Services tags that contain a key value pair and may be searched by console, command line, or API. If specified, follows the Amazon Web Services tags-on-create pattern.</p>
pub fn tags(
&self,
) -> std::option::Option<&std::collections::HashMap<std::string::String, std::string::String>>
{
self.tags.as_ref()
}
/// <p>The schema definition using the <code>DataFormat</code> setting for <code>SchemaName</code>.</p>
pub fn schema_definition(&self) -> std::option::Option<&str> {
self.schema_definition.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CreateRegistryInput {
/// <p>Name of the registry to be created of max length of 255, and may only contain letters, numbers, hyphen, underscore, dollar sign, or hash mark. No whitespace.</p>
#[doc(hidden)]
pub registry_name: std::option::Option<std::string::String>,
/// <p>A description of the registry. If description is not provided, there will not be any default value for this.</p>
#[doc(hidden)]
pub description: std::option::Option<std::string::String>,
/// <p>Amazon Web Services tags that contain a key value pair and may be searched by console, command line, or API.</p>
#[doc(hidden)]
pub tags:
std::option::Option<std::collections::HashMap<std::string::String, std::string::String>>,
}
impl CreateRegistryInput {
/// <p>Name of the registry to be created of max length of 255, and may only contain letters, numbers, hyphen, underscore, dollar sign, or hash mark. No whitespace.</p>
pub fn registry_name(&self) -> std::option::Option<&str> {
self.registry_name.as_deref()
}
/// <p>A description of the registry. If description is not provided, there will not be any default value for this.</p>
pub fn description(&self) -> std::option::Option<&str> {
self.description.as_deref()
}
/// <p>Amazon Web Services tags that contain a key value pair and may be searched by console, command line, or API.</p>
pub fn tags(
&self,
) -> std::option::Option<&std::collections::HashMap<std::string::String, std::string::String>>
{
self.tags.as_ref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CreatePartitionIndexInput {
/// <p>The catalog ID where the table resides.</p>
#[doc(hidden)]
pub catalog_id: std::option::Option<std::string::String>,
/// <p>Specifies the name of a database in which you want to create a partition index.</p>
#[doc(hidden)]
pub database_name: std::option::Option<std::string::String>,
/// <p>Specifies the name of a table in which you want to create a partition index.</p>
#[doc(hidden)]
pub table_name: std::option::Option<std::string::String>,
/// <p>Specifies a <code>PartitionIndex</code> structure to create a partition index in an existing table.</p>
#[doc(hidden)]
pub partition_index: std::option::Option<crate::model::PartitionIndex>,
}
impl CreatePartitionIndexInput {
/// <p>The catalog ID where the table resides.</p>
pub fn catalog_id(&self) -> std::option::Option<&str> {
self.catalog_id.as_deref()
}
/// <p>Specifies the name of a database in which you want to create a partition index.</p>
pub fn database_name(&self) -> std::option::Option<&str> {
self.database_name.as_deref()
}
/// <p>Specifies the name of a table in which you want to create a partition index.</p>
pub fn table_name(&self) -> std::option::Option<&str> {
self.table_name.as_deref()
}
/// <p>Specifies a <code>PartitionIndex</code> structure to create a partition index in an existing table.</p>
pub fn partition_index(&self) -> std::option::Option<&crate::model::PartitionIndex> {
self.partition_index.as_ref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CreatePartitionInput {
/// <p>The Amazon Web Services account ID of the catalog in which the partition is to be created.</p>
#[doc(hidden)]
pub catalog_id: std::option::Option<std::string::String>,
/// <p>The name of the metadata database in which the partition is to be created.</p>
#[doc(hidden)]
pub database_name: std::option::Option<std::string::String>,
/// <p>The name of the metadata table in which the partition is to be created.</p>
#[doc(hidden)]
pub table_name: std::option::Option<std::string::String>,
/// <p>A <code>PartitionInput</code> structure defining the partition to be created.</p>
#[doc(hidden)]
pub partition_input: std::option::Option<crate::model::PartitionInput>,
}
impl CreatePartitionInput {
/// <p>The Amazon Web Services account ID of the catalog in which the partition is to be created.</p>
pub fn catalog_id(&self) -> std::option::Option<&str> {
self.catalog_id.as_deref()
}
/// <p>The name of the metadata database in which the partition is to be created.</p>
pub fn database_name(&self) -> std::option::Option<&str> {
self.database_name.as_deref()
}
/// <p>The name of the metadata table in which the partition is to be created.</p>
pub fn table_name(&self) -> std::option::Option<&str> {
self.table_name.as_deref()
}
/// <p>A <code>PartitionInput</code> structure defining the partition to be created.</p>
pub fn partition_input(&self) -> std::option::Option<&crate::model::PartitionInput> {
self.partition_input.as_ref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CreateMlTransformInput {
/// <p>The unique name that you give the transform when you create it.</p>
#[doc(hidden)]
pub name: std::option::Option<std::string::String>,
/// <p>A description of the machine learning transform that is being defined. The default is an empty string.</p>
#[doc(hidden)]
pub description: std::option::Option<std::string::String>,
/// <p>A list of Glue table definitions used by the transform.</p>
#[doc(hidden)]
pub input_record_tables: std::option::Option<std::vec::Vec<crate::model::GlueTable>>,
/// <p>The algorithmic parameters that are specific to the transform type used. Conditionally dependent on the transform type.</p>
#[doc(hidden)]
pub parameters: std::option::Option<crate::model::TransformParameters>,
/// <p>The name or Amazon Resource Name (ARN) of the IAM role with the required permissions. The required permissions include both Glue service role permissions to Glue resources, and Amazon S3 permissions required by the transform. </p>
/// <ul>
/// <li> <p>This role needs Glue service role permissions to allow access to resources in Glue. See <a href="https://docs.aws.amazon.com/glue/latest/dg/attach-policy-iam-user.html">Attach a Policy to IAM Users That Access Glue</a>.</p> </li>
/// <li> <p>This role needs permission to your Amazon Simple Storage Service (Amazon S3) sources, targets, temporary directory, scripts, and any libraries used by the task run for this transform.</p> </li>
/// </ul>
#[doc(hidden)]
pub role: std::option::Option<std::string::String>,
/// <p>This value determines which version of Glue this machine learning transform is compatible with. Glue 1.0 is recommended for most customers. If the value is not set, the Glue compatibility defaults to Glue 0.9. For more information, see <a href="https://docs.aws.amazon.com/glue/latest/dg/release-notes.html#release-notes-versions">Glue Versions</a> in the developer guide.</p>
#[doc(hidden)]
pub glue_version: std::option::Option<std::string::String>,
/// <p>The number of Glue data processing units (DPUs) that are allocated to task runs for this transform. You can allocate from 2 to 100 DPUs; the default is 10. A DPU is a relative measure of processing power that consists of 4 vCPUs of compute capacity and 16 GB of memory. For more information, see the <a href="https://aws.amazon.com/glue/pricing/">Glue pricing page</a>. </p>
/// <p> <code>MaxCapacity</code> is a mutually exclusive option with <code>NumberOfWorkers</code> and <code>WorkerType</code>.</p>
/// <ul>
/// <li> <p>If either <code>NumberOfWorkers</code> or <code>WorkerType</code> is set, then <code>MaxCapacity</code> cannot be set.</p> </li>
/// <li> <p>If <code>MaxCapacity</code> is set then neither <code>NumberOfWorkers</code> or <code>WorkerType</code> can be set.</p> </li>
/// <li> <p>If <code>WorkerType</code> is set, then <code>NumberOfWorkers</code> is required (and vice versa).</p> </li>
/// <li> <p> <code>MaxCapacity</code> and <code>NumberOfWorkers</code> must both be at least 1.</p> </li>
/// </ul>
/// <p>When the <code>WorkerType</code> field is set to a value other than <code>Standard</code>, the <code>MaxCapacity</code> field is set automatically and becomes read-only.</p>
/// <p>When the <code>WorkerType</code> field is set to a value other than <code>Standard</code>, the <code>MaxCapacity</code> field is set automatically and becomes read-only.</p>
#[doc(hidden)]
pub max_capacity: std::option::Option<f64>,
/// <p>The type of predefined worker that is allocated when this task runs. Accepts a value of Standard, G.1X, or G.2X.</p>
/// <ul>
/// <li> <p>For the <code>Standard</code> worker type, each worker provides 4 vCPU, 16 GB of memory and a 50GB disk, and 2 executors per worker.</p> </li>
/// <li> <p>For the <code>G.1X</code> worker type, each worker provides 4 vCPU, 16 GB of memory and a 64GB disk, and 1 executor per worker.</p> </li>
/// <li> <p>For the <code>G.2X</code> worker type, each worker provides 8 vCPU, 32 GB of memory and a 128GB disk, and 1 executor per worker.</p> </li>
/// </ul>
/// <p> <code>MaxCapacity</code> is a mutually exclusive option with <code>NumberOfWorkers</code> and <code>WorkerType</code>.</p>
/// <ul>
/// <li> <p>If either <code>NumberOfWorkers</code> or <code>WorkerType</code> is set, then <code>MaxCapacity</code> cannot be set.</p> </li>
/// <li> <p>If <code>MaxCapacity</code> is set then neither <code>NumberOfWorkers</code> or <code>WorkerType</code> can be set.</p> </li>
/// <li> <p>If <code>WorkerType</code> is set, then <code>NumberOfWorkers</code> is required (and vice versa).</p> </li>
/// <li> <p> <code>MaxCapacity</code> and <code>NumberOfWorkers</code> must both be at least 1.</p> </li>
/// </ul>
#[doc(hidden)]
pub worker_type: std::option::Option<crate::model::WorkerType>,
/// <p>The number of workers of a defined <code>workerType</code> that are allocated when this task runs.</p>
/// <p>If <code>WorkerType</code> is set, then <code>NumberOfWorkers</code> is required (and vice versa).</p>
#[doc(hidden)]
pub number_of_workers: std::option::Option<i32>,
/// <p>The timeout of the task run for this transform in minutes. This is the maximum time that a task run for this transform can consume resources before it is terminated and enters <code>TIMEOUT</code> status. The default is 2,880 minutes (48 hours).</p>
#[doc(hidden)]
pub timeout: std::option::Option<i32>,
/// <p>The maximum number of times to retry a task for this transform after a task run fails.</p>
#[doc(hidden)]
pub max_retries: std::option::Option<i32>,
/// <p>The tags to use with this machine learning transform. You may use tags to limit access to the machine learning transform. For more information about tags in Glue, see <a href="https://docs.aws.amazon.com/glue/latest/dg/monitor-tags.html">Amazon Web Services Tags in Glue</a> in the developer guide.</p>
#[doc(hidden)]
pub tags:
std::option::Option<std::collections::HashMap<std::string::String, std::string::String>>,
/// <p>The encryption-at-rest settings of the transform that apply to accessing user data. Machine learning transforms can access user data encrypted in Amazon S3 using KMS.</p>
#[doc(hidden)]
pub transform_encryption: std::option::Option<crate::model::TransformEncryption>,
}
impl CreateMlTransformInput {
/// <p>The unique name that you give the transform when you create it.</p>
pub fn name(&self) -> std::option::Option<&str> {
self.name.as_deref()
}
/// <p>A description of the machine learning transform that is being defined. The default is an empty string.</p>
pub fn description(&self) -> std::option::Option<&str> {
self.description.as_deref()
}
/// <p>A list of Glue table definitions used by the transform.</p>
pub fn input_record_tables(&self) -> std::option::Option<&[crate::model::GlueTable]> {
self.input_record_tables.as_deref()
}
/// <p>The algorithmic parameters that are specific to the transform type used. Conditionally dependent on the transform type.</p>
pub fn parameters(&self) -> std::option::Option<&crate::model::TransformParameters> {
self.parameters.as_ref()
}
/// <p>The name or Amazon Resource Name (ARN) of the IAM role with the required permissions. The required permissions include both Glue service role permissions to Glue resources, and Amazon S3 permissions required by the transform. </p>
/// <ul>
/// <li> <p>This role needs Glue service role permissions to allow access to resources in Glue. See <a href="https://docs.aws.amazon.com/glue/latest/dg/attach-policy-iam-user.html">Attach a Policy to IAM Users That Access Glue</a>.</p> </li>
/// <li> <p>This role needs permission to your Amazon Simple Storage Service (Amazon S3) sources, targets, temporary directory, scripts, and any libraries used by the task run for this transform.</p> </li>
/// </ul>
pub fn role(&self) -> std::option::Option<&str> {
self.role.as_deref()
}
/// <p>This value determines which version of Glue this machine learning transform is compatible with. Glue 1.0 is recommended for most customers. If the value is not set, the Glue compatibility defaults to Glue 0.9. For more information, see <a href="https://docs.aws.amazon.com/glue/latest/dg/release-notes.html#release-notes-versions">Glue Versions</a> in the developer guide.</p>
pub fn glue_version(&self) -> std::option::Option<&str> {
self.glue_version.as_deref()
}
/// <p>The number of Glue data processing units (DPUs) that are allocated to task runs for this transform. You can allocate from 2 to 100 DPUs; the default is 10. A DPU is a relative measure of processing power that consists of 4 vCPUs of compute capacity and 16 GB of memory. For more information, see the <a href="https://aws.amazon.com/glue/pricing/">Glue pricing page</a>. </p>
/// <p> <code>MaxCapacity</code> is a mutually exclusive option with <code>NumberOfWorkers</code> and <code>WorkerType</code>.</p>
/// <ul>
/// <li> <p>If either <code>NumberOfWorkers</code> or <code>WorkerType</code> is set, then <code>MaxCapacity</code> cannot be set.</p> </li>
/// <li> <p>If <code>MaxCapacity</code> is set then neither <code>NumberOfWorkers</code> or <code>WorkerType</code> can be set.</p> </li>
/// <li> <p>If <code>WorkerType</code> is set, then <code>NumberOfWorkers</code> is required (and vice versa).</p> </li>
/// <li> <p> <code>MaxCapacity</code> and <code>NumberOfWorkers</code> must both be at least 1.</p> </li>
/// </ul>
/// <p>When the <code>WorkerType</code> field is set to a value other than <code>Standard</code>, the <code>MaxCapacity</code> field is set automatically and becomes read-only.</p>
/// <p>When the <code>WorkerType</code> field is set to a value other than <code>Standard</code>, the <code>MaxCapacity</code> field is set automatically and becomes read-only.</p>
pub fn max_capacity(&self) -> std::option::Option<f64> {
self.max_capacity
}
/// <p>The type of predefined worker that is allocated when this task runs. Accepts a value of Standard, G.1X, or G.2X.</p>
/// <ul>
/// <li> <p>For the <code>Standard</code> worker type, each worker provides 4 vCPU, 16 GB of memory and a 50GB disk, and 2 executors per worker.</p> </li>
/// <li> <p>For the <code>G.1X</code> worker type, each worker provides 4 vCPU, 16 GB of memory and a 64GB disk, and 1 executor per worker.</p> </li>
/// <li> <p>For the <code>G.2X</code> worker type, each worker provides 8 vCPU, 32 GB of memory and a 128GB disk, and 1 executor per worker.</p> </li>
/// </ul>
/// <p> <code>MaxCapacity</code> is a mutually exclusive option with <code>NumberOfWorkers</code> and <code>WorkerType</code>.</p>
/// <ul>
/// <li> <p>If either <code>NumberOfWorkers</code> or <code>WorkerType</code> is set, then <code>MaxCapacity</code> cannot be set.</p> </li>
/// <li> <p>If <code>MaxCapacity</code> is set then neither <code>NumberOfWorkers</code> or <code>WorkerType</code> can be set.</p> </li>
/// <li> <p>If <code>WorkerType</code> is set, then <code>NumberOfWorkers</code> is required (and vice versa).</p> </li>
/// <li> <p> <code>MaxCapacity</code> and <code>NumberOfWorkers</code> must both be at least 1.</p> </li>
/// </ul>
pub fn worker_type(&self) -> std::option::Option<&crate::model::WorkerType> {
self.worker_type.as_ref()
}
/// <p>The number of workers of a defined <code>workerType</code> that are allocated when this task runs.</p>
/// <p>If <code>WorkerType</code> is set, then <code>NumberOfWorkers</code> is required (and vice versa).</p>
pub fn number_of_workers(&self) -> std::option::Option<i32> {
self.number_of_workers
}
/// <p>The timeout of the task run for this transform in minutes. This is the maximum time that a task run for this transform can consume resources before it is terminated and enters <code>TIMEOUT</code> status. The default is 2,880 minutes (48 hours).</p>
pub fn timeout(&self) -> std::option::Option<i32> {
self.timeout
}
/// <p>The maximum number of times to retry a task for this transform after a task run fails.</p>
pub fn max_retries(&self) -> std::option::Option<i32> {
self.max_retries
}
/// <p>The tags to use with this machine learning transform. You may use tags to limit access to the machine learning transform. For more information about tags in Glue, see <a href="https://docs.aws.amazon.com/glue/latest/dg/monitor-tags.html">Amazon Web Services Tags in Glue</a> in the developer guide.</p>
pub fn tags(
&self,
) -> std::option::Option<&std::collections::HashMap<std::string::String, std::string::String>>
{
self.tags.as_ref()
}
/// <p>The encryption-at-rest settings of the transform that apply to accessing user data. Machine learning transforms can access user data encrypted in Amazon S3 using KMS.</p>
pub fn transform_encryption(&self) -> std::option::Option<&crate::model::TransformEncryption> {
self.transform_encryption.as_ref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateJobInput {
/// <p>The name you assign to this job definition. It must be unique in your account.</p>
#[doc(hidden)]
pub name: std::option::Option<std::string::String>,
/// <p>Description of the job being defined.</p>
#[doc(hidden)]
pub description: std::option::Option<std::string::String>,
/// <p>This field is reserved for future use.</p>
#[doc(hidden)]
pub log_uri: std::option::Option<std::string::String>,
/// <p>The name or Amazon Resource Name (ARN) of the IAM role associated with this job.</p>
#[doc(hidden)]
pub role: std::option::Option<std::string::String>,
/// <p>An <code>ExecutionProperty</code> specifying the maximum number of concurrent runs allowed for this job.</p>
#[doc(hidden)]
pub execution_property: std::option::Option<crate::model::ExecutionProperty>,
/// <p>The <code>JobCommand</code> that runs this job.</p>
#[doc(hidden)]
pub command: std::option::Option<crate::model::JobCommand>,
/// <p>The default arguments for this job.</p>
/// <p>You can specify arguments here that your own job-execution script consumes, as well as arguments that Glue itself consumes.</p>
/// <p>Job arguments may be logged. Do not pass plaintext secrets as arguments. Retrieve secrets from a Glue Connection, Secrets Manager or other secret management mechanism if you intend to keep them within the Job. </p>
/// <p>For information about how to specify and consume your own Job arguments, see the <a href="https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-python-calling.html">Calling Glue APIs in Python</a> topic in the developer guide.</p>
/// <p>For information about the key-value pairs that Glue consumes to set up your job, see the <a href="https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html">Special Parameters Used by Glue</a> topic in the developer guide.</p>
#[doc(hidden)]
pub default_arguments:
std::option::Option<std::collections::HashMap<std::string::String, std::string::String>>,
/// <p>Non-overridable arguments for this job, specified as name-value pairs.</p>
#[doc(hidden)]
pub non_overridable_arguments:
std::option::Option<std::collections::HashMap<std::string::String, std::string::String>>,
/// <p>The connections used for this job.</p>
#[doc(hidden)]
pub connections: std::option::Option<crate::model::ConnectionsList>,
/// <p>The maximum number of times to retry this job if it fails.</p>
#[doc(hidden)]
pub max_retries: i32,
/// <p>This parameter is deprecated. Use <code>MaxCapacity</code> instead.</p>
/// <p>The number of Glue data processing units (DPUs) to allocate to this Job. You can allocate a minimum of 2 DPUs; the default is 10. A DPU is a relative measure of processing power that consists of 4 vCPUs of compute capacity and 16 GB of memory. For more information, see the <a href="https://aws.amazon.com/glue/pricing/">Glue pricing page</a>.</p>
#[deprecated(note = "This property is deprecated, use MaxCapacity instead.")]
#[doc(hidden)]
pub allocated_capacity: i32,
/// <p>The job timeout in minutes. This is the maximum time that a job run can consume resources before it is terminated and enters <code>TIMEOUT</code> status. The default is 2,880 minutes (48 hours).</p>
#[doc(hidden)]
pub timeout: std::option::Option<i32>,
/// <p>For Glue version 1.0 or earlier jobs, using the standard worker type, the number of Glue data processing units (DPUs) that can be allocated when this job runs. A DPU is a relative measure of processing power that consists of 4 vCPUs of compute capacity and 16 GB of memory. For more information, see the <a href="https://aws.amazon.com/glue/pricing/">Glue pricing page</a>.</p>
/// <p>Do not set <code>Max Capacity</code> if using <code>WorkerType</code> and <code>NumberOfWorkers</code>.</p>
/// <p>The value that can be allocated for <code>MaxCapacity</code> depends on whether you are running a Python shell job or an Apache Spark ETL job:</p>
/// <ul>
/// <li> <p>When you specify a Python shell job (<code>JobCommand.Name</code>="pythonshell"), you can allocate either 0.0625 or 1 DPU. The default is 0.0625 DPU.</p> </li>
/// <li> <p>When you specify an Apache Spark ETL job (<code>JobCommand.Name</code>="glueetl") or Apache Spark streaming ETL job (<code>JobCommand.Name</code>="gluestreaming"), you can allocate a minimum of 2 DPUs. The default is 10 DPUs. This job type cannot have a fractional DPU allocation.</p> </li>
/// </ul>
/// <p>For Glue version 2.0 jobs, you cannot instead specify a <code>Maximum capacity</code>. Instead, you should specify a <code>Worker type</code> and the <code>Number of workers</code>.</p>
#[doc(hidden)]
pub max_capacity: std::option::Option<f64>,
/// <p>The name of the <code>SecurityConfiguration</code> structure to be used with this job.</p>
#[doc(hidden)]
pub security_configuration: std::option::Option<std::string::String>,
/// <p>The tags to use with this job. You may use tags to limit access to the job. For more information about tags in Glue, see <a href="https://docs.aws.amazon.com/glue/latest/dg/monitor-tags.html">Amazon Web Services Tags in Glue</a> in the developer guide.</p>
#[doc(hidden)]
pub tags:
std::option::Option<std::collections::HashMap<std::string::String, std::string::String>>,
/// <p>Specifies configuration properties of a job notification.</p>
#[doc(hidden)]
pub notification_property: std::option::Option<crate::model::NotificationProperty>,
/// <p>Glue version determines the versions of Apache Spark and Python that Glue supports. The Python version indicates the version supported for jobs of type Spark. </p>
/// <p>For more information about the available Glue versions and corresponding Spark and Python versions, see <a href="https://docs.aws.amazon.com/glue/latest/dg/add-job.html">Glue version</a> in the developer guide.</p>
/// <p>Jobs that are created without specifying a Glue version default to Glue 0.9.</p>
#[doc(hidden)]
pub glue_version: std::option::Option<std::string::String>,
/// <p>The number of workers of a defined <code>workerType</code> that are allocated when a job runs.</p>
#[doc(hidden)]
pub number_of_workers: std::option::Option<i32>,
/// <p>The type of predefined worker that is allocated when a job runs. Accepts a value of Standard, G.1X, G.2X, or G.025X.</p>
/// <ul>
/// <li> <p>For the <code>Standard</code> worker type, each worker provides 4 vCPU, 16 GB of memory and a 50GB disk, and 2 executors per worker.</p> </li>
/// <li> <p>For the <code>G.1X</code> worker type, each worker maps to 1 DPU (4 vCPU, 16 GB of memory, 64 GB disk), and provides 1 executor per worker. We recommend this worker type for memory-intensive jobs.</p> </li>
/// <li> <p>For the <code>G.2X</code> worker type, each worker maps to 2 DPU (8 vCPU, 32 GB of memory, 128 GB disk), and provides 1 executor per worker. We recommend this worker type for memory-intensive jobs.</p> </li>
/// <li> <p>For the <code>G.025X</code> worker type, each worker maps to 0.25 DPU (2 vCPU, 4 GB of memory, 64 GB disk), and provides 1 executor per worker. We recommend this worker type for low volume streaming jobs. This worker type is only available for Glue version 3.0 streaming jobs.</p> </li>
/// </ul>
#[doc(hidden)]
pub worker_type: std::option::Option<crate::model::WorkerType>,
/// <p>The representation of a directed acyclic graph on which both the Glue Studio visual component and Glue Studio code generation is based.</p>
#[doc(hidden)]
pub code_gen_configuration_nodes: std::option::Option<
std::collections::HashMap<std::string::String, crate::model::CodeGenConfigurationNode>,
>,
/// <p>Indicates whether the job is run with a standard or flexible execution class. The standard execution-class is ideal for time-sensitive workloads that require fast job startup and dedicated resources.</p>
/// <p>The flexible execution class is appropriate for time-insensitive jobs whose start and completion times may vary. </p>
/// <p>Only jobs with Glue version 3.0 and above and command type <code>glueetl</code> will be allowed to set <code>ExecutionClass</code> to <code>FLEX</code>. The flexible execution class is available for Spark jobs.</p>
#[doc(hidden)]
pub execution_class: std::option::Option<crate::model::ExecutionClass>,
/// <p>The details for a source control configuration for a job, allowing synchronization of job artifacts to or from a remote repository.</p>
#[doc(hidden)]
pub source_control_details: std::option::Option<crate::model::SourceControlDetails>,
}
impl CreateJobInput {
/// <p>The name you assign to this job definition. It must be unique in your account.</p>
pub fn name(&self) -> std::option::Option<&str> {
self.name.as_deref()
}
/// <p>Description of the job being defined.</p>
pub fn description(&self) -> std::option::Option<&str> {
self.description.as_deref()
}
/// <p>This field is reserved for future use.</p>
pub fn log_uri(&self) -> std::option::Option<&str> {
self.log_uri.as_deref()
}
/// <p>The name or Amazon Resource Name (ARN) of the IAM role associated with this job.</p>
pub fn role(&self) -> std::option::Option<&str> {
self.role.as_deref()
}
/// <p>An <code>ExecutionProperty</code> specifying the maximum number of concurrent runs allowed for this job.</p>
pub fn execution_property(&self) -> std::option::Option<&crate::model::ExecutionProperty> {
self.execution_property.as_ref()
}
/// <p>The <code>JobCommand</code> that runs this job.</p>
pub fn command(&self) -> std::option::Option<&crate::model::JobCommand> {
self.command.as_ref()
}
/// <p>The default arguments for this job.</p>
/// <p>You can specify arguments here that your own job-execution script consumes, as well as arguments that Glue itself consumes.</p>
/// <p>Job arguments may be logged. Do not pass plaintext secrets as arguments. Retrieve secrets from a Glue Connection, Secrets Manager or other secret management mechanism if you intend to keep them within the Job. </p>
/// <p>For information about how to specify and consume your own Job arguments, see the <a href="https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-python-calling.html">Calling Glue APIs in Python</a> topic in the developer guide.</p>
/// <p>For information about the key-value pairs that Glue consumes to set up your job, see the <a href="https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html">Special Parameters Used by Glue</a> topic in the developer guide.</p>
pub fn default_arguments(
&self,
) -> std::option::Option<&std::collections::HashMap<std::string::String, std::string::String>>
{
self.default_arguments.as_ref()
}
/// <p>Non-overridable arguments for this job, specified as name-value pairs.</p>
pub fn non_overridable_arguments(
&self,
) -> std::option::Option<&std::collections::HashMap<std::string::String, std::string::String>>
{
self.non_overridable_arguments.as_ref()
}
/// <p>The connections used for this job.</p>
pub fn connections(&self) -> std::option::Option<&crate::model::ConnectionsList> {
self.connections.as_ref()
}
/// <p>The maximum number of times to retry this job if it fails.</p>
pub fn max_retries(&self) -> i32 {
self.max_retries
}
/// <p>This parameter is deprecated. Use <code>MaxCapacity</code> instead.</p>
/// <p>The number of Glue data processing units (DPUs) to allocate to this Job. You can allocate a minimum of 2 DPUs; the default is 10. A DPU is a relative measure of processing power that consists of 4 vCPUs of compute capacity and 16 GB of memory. For more information, see the <a href="https://aws.amazon.com/glue/pricing/">Glue pricing page</a>.</p>
#[deprecated(note = "This property is deprecated, use MaxCapacity instead.")]
pub fn allocated_capacity(&self) -> i32 {
self.allocated_capacity
}
/// <p>The job timeout in minutes. This is the maximum time that a job run can consume resources before it is terminated and enters <code>TIMEOUT</code> status. The default is 2,880 minutes (48 hours).</p>
pub fn timeout(&self) -> std::option::Option<i32> {
self.timeout
}
/// <p>For Glue version 1.0 or earlier jobs, using the standard worker type, the number of Glue data processing units (DPUs) that can be allocated when this job runs. A DPU is a relative measure of processing power that consists of 4 vCPUs of compute capacity and 16 GB of memory. For more information, see the <a href="https://aws.amazon.com/glue/pricing/">Glue pricing page</a>.</p>
/// <p>Do not set <code>Max Capacity</code> if using <code>WorkerType</code> and <code>NumberOfWorkers</code>.</p>
/// <p>The value that can be allocated for <code>MaxCapacity</code> depends on whether you are running a Python shell job or an Apache Spark ETL job:</p>
/// <ul>
/// <li> <p>When you specify a Python shell job (<code>JobCommand.Name</code>="pythonshell"), you can allocate either 0.0625 or 1 DPU. The default is 0.0625 DPU.</p> </li>
/// <li> <p>When you specify an Apache Spark ETL job (<code>JobCommand.Name</code>="glueetl") or Apache Spark streaming ETL job (<code>JobCommand.Name</code>="gluestreaming"), you can allocate a minimum of 2 DPUs. The default is 10 DPUs. This job type cannot have a fractional DPU allocation.</p> </li>
/// </ul>
/// <p>For Glue version 2.0 jobs, you cannot instead specify a <code>Maximum capacity</code>. Instead, you should specify a <code>Worker type</code> and the <code>Number of workers</code>.</p>
pub fn max_capacity(&self) -> std::option::Option<f64> {
self.max_capacity
}
/// <p>The name of the <code>SecurityConfiguration</code> structure to be used with this job.</p>
pub fn security_configuration(&self) -> std::option::Option<&str> {
self.security_configuration.as_deref()
}
/// <p>The tags to use with this job. You may use tags to limit access to the job. For more information about tags in Glue, see <a href="https://docs.aws.amazon.com/glue/latest/dg/monitor-tags.html">Amazon Web Services Tags in Glue</a> in the developer guide.</p>
pub fn tags(
&self,
) -> std::option::Option<&std::collections::HashMap<std::string::String, std::string::String>>
{
self.tags.as_ref()
}
/// <p>Specifies configuration properties of a job notification.</p>
pub fn notification_property(
&self,
) -> std::option::Option<&crate::model::NotificationProperty> {
self.notification_property.as_ref()
}
/// <p>Glue version determines the versions of Apache Spark and Python that Glue supports. The Python version indicates the version supported for jobs of type Spark. </p>
/// <p>For more information about the available Glue versions and corresponding Spark and Python versions, see <a href="https://docs.aws.amazon.com/glue/latest/dg/add-job.html">Glue version</a> in the developer guide.</p>
/// <p>Jobs that are created without specifying a Glue version default to Glue 0.9.</p>
pub fn glue_version(&self) -> std::option::Option<&str> {
self.glue_version.as_deref()
}
/// <p>The number of workers of a defined <code>workerType</code> that are allocated when a job runs.</p>
pub fn number_of_workers(&self) -> std::option::Option<i32> {
self.number_of_workers
}
/// <p>The type of predefined worker that is allocated when a job runs. Accepts a value of Standard, G.1X, G.2X, or G.025X.</p>
/// <ul>
/// <li> <p>For the <code>Standard</code> worker type, each worker provides 4 vCPU, 16 GB of memory and a 50GB disk, and 2 executors per worker.</p> </li>
/// <li> <p>For the <code>G.1X</code> worker type, each worker maps to 1 DPU (4 vCPU, 16 GB of memory, 64 GB disk), and provides 1 executor per worker. We recommend this worker type for memory-intensive jobs.</p> </li>
/// <li> <p>For the <code>G.2X</code> worker type, each worker maps to 2 DPU (8 vCPU, 32 GB of memory, 128 GB disk), and provides 1 executor per worker. We recommend this worker type for memory-intensive jobs.</p> </li>
/// <li> <p>For the <code>G.025X</code> worker type, each worker maps to 0.25 DPU (2 vCPU, 4 GB of memory, 64 GB disk), and provides 1 executor per worker. We recommend this worker type for low volume streaming jobs. This worker type is only available for Glue version 3.0 streaming jobs.</p> </li>
/// </ul>
pub fn worker_type(&self) -> std::option::Option<&crate::model::WorkerType> {
self.worker_type.as_ref()
}
/// <p>The representation of a directed acyclic graph on which both the Glue Studio visual component and Glue Studio code generation is based.</p>
pub fn code_gen_configuration_nodes(
&self,
) -> std::option::Option<
&std::collections::HashMap<std::string::String, crate::model::CodeGenConfigurationNode>,
> {
self.code_gen_configuration_nodes.as_ref()
}
/// <p>Indicates whether the job is run with a standard or flexible execution class. The standard execution-class is ideal for time-sensitive workloads that require fast job startup and dedicated resources.</p>
/// <p>The flexible execution class is appropriate for time-insensitive jobs whose start and completion times may vary. </p>
/// <p>Only jobs with Glue version 3.0 and above and command type <code>glueetl</code> will be allowed to set <code>ExecutionClass</code> to <code>FLEX</code>. The flexible execution class is available for Spark jobs.</p>
pub fn execution_class(&self) -> std::option::Option<&crate::model::ExecutionClass> {
self.execution_class.as_ref()
}
/// <p>The details for a source control configuration for a job, allowing synchronization of job artifacts to or from a remote repository.</p>
pub fn source_control_details(
&self,
) -> std::option::Option<&crate::model::SourceControlDetails> {
self.source_control_details.as_ref()
}
}
impl std::fmt::Debug for CreateJobInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("CreateJobInput");
formatter.field("name", &self.name);
formatter.field("description", &self.description);
formatter.field("log_uri", &self.log_uri);
formatter.field("role", &self.role);
formatter.field("execution_property", &self.execution_property);
formatter.field("command", &self.command);
formatter.field("default_arguments", &self.default_arguments);
formatter.field("non_overridable_arguments", &self.non_overridable_arguments);
formatter.field("connections", &self.connections);
formatter.field("max_retries", &self.max_retries);
formatter.field("allocated_capacity", &self.allocated_capacity);
formatter.field("timeout", &self.timeout);
formatter.field("max_capacity", &self.max_capacity);
formatter.field("security_configuration", &self.security_configuration);
formatter.field("tags", &self.tags);
formatter.field("notification_property", &self.notification_property);
formatter.field("glue_version", &self.glue_version);
formatter.field("number_of_workers", &self.number_of_workers);
formatter.field("worker_type", &self.worker_type);
formatter.field(
"code_gen_configuration_nodes",
&"*** Sensitive Data Redacted ***",
);
formatter.field("execution_class", &self.execution_class);
formatter.field("source_control_details", &self.source_control_details);
formatter.finish()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CreateDevEndpointInput {
/// <p>The name to be assigned to the new <code>DevEndpoint</code>.</p>
#[doc(hidden)]
pub endpoint_name: std::option::Option<std::string::String>,
/// <p>The IAM role for the <code>DevEndpoint</code>.</p>
#[doc(hidden)]
pub role_arn: std::option::Option<std::string::String>,
/// <p>Security group IDs for the security groups to be used by the new <code>DevEndpoint</code>.</p>
#[doc(hidden)]
pub security_group_ids: std::option::Option<std::vec::Vec<std::string::String>>,
/// <p>The subnet ID for the new <code>DevEndpoint</code> to use.</p>
#[doc(hidden)]
pub subnet_id: std::option::Option<std::string::String>,
/// <p>The public key to be used by this <code>DevEndpoint</code> for authentication. This attribute is provided for backward compatibility because the recommended attribute to use is public keys.</p>
#[doc(hidden)]
pub public_key: std::option::Option<std::string::String>,
/// <p>A list of public keys to be used by the development endpoints for authentication. The use of this attribute is preferred over a single public key because the public keys allow you to have a different private key per client.</p> <note>
/// <p>If you previously created an endpoint with a public key, you must remove that key to be able to set a list of public keys. Call the <code>UpdateDevEndpoint</code> API with the public key content in the <code>deletePublicKeys</code> attribute, and the list of new keys in the <code>addPublicKeys</code> attribute.</p>
/// </note>
#[doc(hidden)]
pub public_keys: std::option::Option<std::vec::Vec<std::string::String>>,
/// <p>The number of Glue Data Processing Units (DPUs) to allocate to this <code>DevEndpoint</code>.</p>
#[doc(hidden)]
pub number_of_nodes: i32,
/// <p>The type of predefined worker that is allocated to the development endpoint. Accepts a value of Standard, G.1X, or G.2X.</p>
/// <ul>
/// <li> <p>For the <code>Standard</code> worker type, each worker provides 4 vCPU, 16 GB of memory and a 50GB disk, and 2 executors per worker.</p> </li>
/// <li> <p>For the <code>G.1X</code> worker type, each worker maps to 1 DPU (4 vCPU, 16 GB of memory, 64 GB disk), and provides 1 executor per worker. We recommend this worker type for memory-intensive jobs.</p> </li>
/// <li> <p>For the <code>G.2X</code> worker type, each worker maps to 2 DPU (8 vCPU, 32 GB of memory, 128 GB disk), and provides 1 executor per worker. We recommend this worker type for memory-intensive jobs.</p> </li>
/// </ul>
/// <p>Known issue: when a development endpoint is created with the <code>G.2X</code> <code>WorkerType</code> configuration, the Spark drivers for the development endpoint will run on 4 vCPU, 16 GB of memory, and a 64 GB disk. </p>
#[doc(hidden)]
pub worker_type: std::option::Option<crate::model::WorkerType>,
/// <p>Glue version determines the versions of Apache Spark and Python that Glue supports. The Python version indicates the version supported for running your ETL scripts on development endpoints. </p>
/// <p>For more information about the available Glue versions and corresponding Spark and Python versions, see <a href="https://docs.aws.amazon.com/glue/latest/dg/add-job.html">Glue version</a> in the developer guide.</p>
/// <p>Development endpoints that are created without specifying a Glue version default to Glue 0.9.</p>
/// <p>You can specify a version of Python support for development endpoints by using the <code>Arguments</code> parameter in the <code>CreateDevEndpoint</code> or <code>UpdateDevEndpoint</code> APIs. If no arguments are provided, the version defaults to Python 2.</p>
#[doc(hidden)]
pub glue_version: std::option::Option<std::string::String>,
/// <p>The number of workers of a defined <code>workerType</code> that are allocated to the development endpoint.</p>
/// <p>The maximum number of workers you can define are 299 for <code>G.1X</code>, and 149 for <code>G.2X</code>. </p>
#[doc(hidden)]
pub number_of_workers: std::option::Option<i32>,
/// <p>The paths to one or more Python libraries in an Amazon S3 bucket that should be loaded in your <code>DevEndpoint</code>. Multiple values must be complete paths separated by a comma.</p> <note>
/// <p>You can only use pure Python libraries with a <code>DevEndpoint</code>. Libraries that rely on C extensions, such as the <a href="http://pandas.pydata.org/">pandas</a> Python data analysis library, are not yet supported.</p>
/// </note>
#[doc(hidden)]
pub extra_python_libs_s3_path: std::option::Option<std::string::String>,
/// <p>The path to one or more Java <code>.jar</code> files in an S3 bucket that should be loaded in your <code>DevEndpoint</code>.</p>
#[doc(hidden)]
pub extra_jars_s3_path: std::option::Option<std::string::String>,
/// <p>The name of the <code>SecurityConfiguration</code> structure to be used with this <code>DevEndpoint</code>.</p>
#[doc(hidden)]
pub security_configuration: std::option::Option<std::string::String>,
/// <p>The tags to use with this DevEndpoint. You may use tags to limit access to the DevEndpoint. For more information about tags in Glue, see <a href="https://docs.aws.amazon.com/glue/latest/dg/monitor-tags.html">Amazon Web Services Tags in Glue</a> in the developer guide.</p>
#[doc(hidden)]
pub tags:
std::option::Option<std::collections::HashMap<std::string::String, std::string::String>>,
/// <p>A map of arguments used to configure the <code>DevEndpoint</code>.</p>
#[doc(hidden)]
pub arguments:
std::option::Option<std::collections::HashMap<std::string::String, std::string::String>>,
}
impl CreateDevEndpointInput {
/// <p>The name to be assigned to the new <code>DevEndpoint</code>.</p>
pub fn endpoint_name(&self) -> std::option::Option<&str> {
self.endpoint_name.as_deref()
}
/// <p>The IAM role for the <code>DevEndpoint</code>.</p>
pub fn role_arn(&self) -> std::option::Option<&str> {
self.role_arn.as_deref()
}
/// <p>Security group IDs for the security groups to be used by the new <code>DevEndpoint</code>.</p>
pub fn security_group_ids(&self) -> std::option::Option<&[std::string::String]> {
self.security_group_ids.as_deref()
}
/// <p>The subnet ID for the new <code>DevEndpoint</code> to use.</p>
pub fn subnet_id(&self) -> std::option::Option<&str> {
self.subnet_id.as_deref()
}
/// <p>The public key to be used by this <code>DevEndpoint</code> for authentication. This attribute is provided for backward compatibility because the recommended attribute to use is public keys.</p>
pub fn public_key(&self) -> std::option::Option<&str> {
self.public_key.as_deref()
}
/// <p>A list of public keys to be used by the development endpoints for authentication. The use of this attribute is preferred over a single public key because the public keys allow you to have a different private key per client.</p> <note>
/// <p>If you previously created an endpoint with a public key, you must remove that key to be able to set a list of public keys. Call the <code>UpdateDevEndpoint</code> API with the public key content in the <code>deletePublicKeys</code> attribute, and the list of new keys in the <code>addPublicKeys</code> attribute.</p>
/// </note>
pub fn public_keys(&self) -> std::option::Option<&[std::string::String]> {
self.public_keys.as_deref()
}
/// <p>The number of Glue Data Processing Units (DPUs) to allocate to this <code>DevEndpoint</code>.</p>
pub fn number_of_nodes(&self) -> i32 {
self.number_of_nodes
}
/// <p>The type of predefined worker that is allocated to the development endpoint. Accepts a value of Standard, G.1X, or G.2X.</p>
/// <ul>
/// <li> <p>For the <code>Standard</code> worker type, each worker provides 4 vCPU, 16 GB of memory and a 50GB disk, and 2 executors per worker.</p> </li>
/// <li> <p>For the <code>G.1X</code> worker type, each worker maps to 1 DPU (4 vCPU, 16 GB of memory, 64 GB disk), and provides 1 executor per worker. We recommend this worker type for memory-intensive jobs.</p> </li>
/// <li> <p>For the <code>G.2X</code> worker type, each worker maps to 2 DPU (8 vCPU, 32 GB of memory, 128 GB disk), and provides 1 executor per worker. We recommend this worker type for memory-intensive jobs.</p> </li>
/// </ul>
/// <p>Known issue: when a development endpoint is created with the <code>G.2X</code> <code>WorkerType</code> configuration, the Spark drivers for the development endpoint will run on 4 vCPU, 16 GB of memory, and a 64 GB disk. </p>
pub fn worker_type(&self) -> std::option::Option<&crate::model::WorkerType> {
self.worker_type.as_ref()
}
/// <p>Glue version determines the versions of Apache Spark and Python that Glue supports. The Python version indicates the version supported for running your ETL scripts on development endpoints. </p>
/// <p>For more information about the available Glue versions and corresponding Spark and Python versions, see <a href="https://docs.aws.amazon.com/glue/latest/dg/add-job.html">Glue version</a> in the developer guide.</p>
/// <p>Development endpoints that are created without specifying a Glue version default to Glue 0.9.</p>
/// <p>You can specify a version of Python support for development endpoints by using the <code>Arguments</code> parameter in the <code>CreateDevEndpoint</code> or <code>UpdateDevEndpoint</code> APIs. If no arguments are provided, the version defaults to Python 2.</p>
pub fn glue_version(&self) -> std::option::Option<&str> {
self.glue_version.as_deref()
}
/// <p>The number of workers of a defined <code>workerType</code> that are allocated to the development endpoint.</p>
/// <p>The maximum number of workers you can define are 299 for <code>G.1X</code>, and 149 for <code>G.2X</code>. </p>
pub fn number_of_workers(&self) -> std::option::Option<i32> {
self.number_of_workers
}
/// <p>The paths to one or more Python libraries in an Amazon S3 bucket that should be loaded in your <code>DevEndpoint</code>. Multiple values must be complete paths separated by a comma.</p> <note>
/// <p>You can only use pure Python libraries with a <code>DevEndpoint</code>. Libraries that rely on C extensions, such as the <a href="http://pandas.pydata.org/">pandas</a> Python data analysis library, are not yet supported.</p>
/// </note>
pub fn extra_python_libs_s3_path(&self) -> std::option::Option<&str> {
self.extra_python_libs_s3_path.as_deref()
}
/// <p>The path to one or more Java <code>.jar</code> files in an S3 bucket that should be loaded in your <code>DevEndpoint</code>.</p>
pub fn extra_jars_s3_path(&self) -> std::option::Option<&str> {
self.extra_jars_s3_path.as_deref()
}
/// <p>The name of the <code>SecurityConfiguration</code> structure to be used with this <code>DevEndpoint</code>.</p>
pub fn security_configuration(&self) -> std::option::Option<&str> {
self.security_configuration.as_deref()
}
/// <p>The tags to use with this DevEndpoint. You may use tags to limit access to the DevEndpoint. For more information about tags in Glue, see <a href="https://docs.aws.amazon.com/glue/latest/dg/monitor-tags.html">Amazon Web Services Tags in Glue</a> in the developer guide.</p>
pub fn tags(
&self,
) -> std::option::Option<&std::collections::HashMap<std::string::String, std::string::String>>
{
self.tags.as_ref()
}
/// <p>A map of arguments used to configure the <code>DevEndpoint</code>.</p>
pub fn arguments(
&self,
) -> std::option::Option<&std::collections::HashMap<std::string::String, std::string::String>>
{
self.arguments.as_ref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CreateDataQualityRulesetInput {
/// <p>A unique name for the data quality ruleset.</p>
#[doc(hidden)]
pub name: std::option::Option<std::string::String>,
/// <p>A description of the data quality ruleset.</p>
#[doc(hidden)]
pub description: std::option::Option<std::string::String>,
/// <p>A Data Quality Definition Language (DQDL) ruleset. For more information, see the Glue developer guide.</p>
#[doc(hidden)]
pub ruleset: std::option::Option<std::string::String>,
/// <p>A list of tags applied to the data quality ruleset.</p>
#[doc(hidden)]
pub tags:
std::option::Option<std::collections::HashMap<std::string::String, std::string::String>>,
/// <p>A target table associated with the data quality ruleset.</p>
#[doc(hidden)]
pub target_table: std::option::Option<crate::model::DataQualityTargetTable>,
/// <p>Used for idempotency and is recommended to be set to a random ID (such as a UUID) to avoid creating or starting multiple instances of the same resource.</p>
#[doc(hidden)]
pub client_token: std::option::Option<std::string::String>,
}
impl CreateDataQualityRulesetInput {
/// <p>A unique name for the data quality ruleset.</p>
pub fn name(&self) -> std::option::Option<&str> {
self.name.as_deref()
}
/// <p>A description of the data quality ruleset.</p>
pub fn description(&self) -> std::option::Option<&str> {
self.description.as_deref()
}
/// <p>A Data Quality Definition Language (DQDL) ruleset. For more information, see the Glue developer guide.</p>
pub fn ruleset(&self) -> std::option::Option<&str> {
self.ruleset.as_deref()
}
/// <p>A list of tags applied to the data quality ruleset.</p>
pub fn tags(
&self,
) -> std::option::Option<&std::collections::HashMap<std::string::String, std::string::String>>
{
self.tags.as_ref()
}
/// <p>A target table associated with the data quality ruleset.</p>
pub fn target_table(&self) -> std::option::Option<&crate::model::DataQualityTargetTable> {
self.target_table.as_ref()
}
/// <p>Used for idempotency and is recommended to be set to a random ID (such as a UUID) to avoid creating or starting multiple instances of the same resource.</p>
pub fn client_token(&self) -> std::option::Option<&str> {
self.client_token.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CreateDatabaseInput {
/// <p>The ID of the Data Catalog in which to create the database. If none is provided, the Amazon Web Services account ID is used by default.</p>
#[doc(hidden)]
pub catalog_id: std::option::Option<std::string::String>,
/// <p>The metadata for the database.</p>
#[doc(hidden)]
pub database_input: std::option::Option<crate::model::DatabaseInput>,
/// <p>The tags you assign to the database.</p>
#[doc(hidden)]
pub tags:
std::option::Option<std::collections::HashMap<std::string::String, std::string::String>>,
}
impl CreateDatabaseInput {
/// <p>The ID of the Data Catalog in which to create the database. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(&self) -> std::option::Option<&str> {
self.catalog_id.as_deref()
}
/// <p>The metadata for the database.</p>
pub fn database_input(&self) -> std::option::Option<&crate::model::DatabaseInput> {
self.database_input.as_ref()
}
/// <p>The tags you assign to the database.</p>
pub fn tags(
&self,
) -> std::option::Option<&std::collections::HashMap<std::string::String, std::string::String>>
{
self.tags.as_ref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CreateCustomEntityTypeInput {
/// <p>A name for the custom pattern that allows it to be retrieved or deleted later. This name must be unique per Amazon Web Services account.</p>
#[doc(hidden)]
pub name: std::option::Option<std::string::String>,
/// <p>A regular expression string that is used for detecting sensitive data in a custom pattern.</p>
#[doc(hidden)]
pub regex_string: std::option::Option<std::string::String>,
/// <p>A list of context words. If none of these context words are found within the vicinity of the regular expression the data will not be detected as sensitive data.</p>
/// <p>If no context words are passed only a regular expression is checked.</p>
#[doc(hidden)]
pub context_words: std::option::Option<std::vec::Vec<std::string::String>>,
}
impl CreateCustomEntityTypeInput {
/// <p>A name for the custom pattern that allows it to be retrieved or deleted later. This name must be unique per Amazon Web Services account.</p>
pub fn name(&self) -> std::option::Option<&str> {
self.name.as_deref()
}
/// <p>A regular expression string that is used for detecting sensitive data in a custom pattern.</p>
pub fn regex_string(&self) -> std::option::Option<&str> {
self.regex_string.as_deref()
}
/// <p>A list of context words. If none of these context words are found within the vicinity of the regular expression the data will not be detected as sensitive data.</p>
/// <p>If no context words are passed only a regular expression is checked.</p>
pub fn context_words(&self) -> std::option::Option<&[std::string::String]> {
self.context_words.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CreateCrawlerInput {
/// <p>Name of the new crawler.</p>
#[doc(hidden)]
pub name: std::option::Option<std::string::String>,
/// <p>The IAM role or Amazon Resource Name (ARN) of an IAM role used by the new crawler to access customer resources.</p>
#[doc(hidden)]
pub role: std::option::Option<std::string::String>,
/// <p>The Glue database where results are written, such as: <code>arn:aws:daylight:us-east-1::database/sometable/*</code>.</p>
#[doc(hidden)]
pub database_name: std::option::Option<std::string::String>,
/// <p>A description of the new crawler.</p>
#[doc(hidden)]
pub description: std::option::Option<std::string::String>,
/// <p>A list of collection of targets to crawl.</p>
#[doc(hidden)]
pub targets: std::option::Option<crate::model::CrawlerTargets>,
/// <p>A <code>cron</code> expression used to specify the schedule (see <a href="https://docs.aws.amazon.com/glue/latest/dg/monitor-data-warehouse-schedule.html">Time-Based Schedules for Jobs and Crawlers</a>. For example, to run something every day at 12:15 UTC, you would specify: <code>cron(15 12 * * ? *)</code>.</p>
#[doc(hidden)]
pub schedule: std::option::Option<std::string::String>,
/// <p>A list of custom classifiers that the user has registered. By default, all built-in classifiers are included in a crawl, but these custom classifiers always override the default classifiers for a given classification.</p>
#[doc(hidden)]
pub classifiers: std::option::Option<std::vec::Vec<std::string::String>>,
/// <p>The table prefix used for catalog tables that are created.</p>
#[doc(hidden)]
pub table_prefix: std::option::Option<std::string::String>,
/// <p>The policy for the crawler's update and deletion behavior.</p>
#[doc(hidden)]
pub schema_change_policy: std::option::Option<crate::model::SchemaChangePolicy>,
/// <p>A policy that specifies whether to crawl the entire dataset again, or to crawl only folders that were added since the last crawler run.</p>
#[doc(hidden)]
pub recrawl_policy: std::option::Option<crate::model::RecrawlPolicy>,
/// <p>Specifies data lineage configuration settings for the crawler.</p>
#[doc(hidden)]
pub lineage_configuration: std::option::Option<crate::model::LineageConfiguration>,
/// <p>Specifies Lake Formation configuration settings for the crawler.</p>
#[doc(hidden)]
pub lake_formation_configuration: std::option::Option<crate::model::LakeFormationConfiguration>,
/// <p>Crawler configuration information. This versioned JSON string allows users to specify aspects of a crawler's behavior. For more information, see <a href="https://docs.aws.amazon.com/glue/latest/dg/crawler-configuration.html">Setting crawler configuration options</a>.</p>
#[doc(hidden)]
pub configuration: std::option::Option<std::string::String>,
/// <p>The name of the <code>SecurityConfiguration</code> structure to be used by this crawler.</p>
#[doc(hidden)]
pub crawler_security_configuration: std::option::Option<std::string::String>,
/// <p>The tags to use with this crawler request. You may use tags to limit access to the crawler. For more information about tags in Glue, see <a href="https://docs.aws.amazon.com/glue/latest/dg/monitor-tags.html">Amazon Web Services Tags in Glue</a> in the developer guide.</p>
#[doc(hidden)]
pub tags:
std::option::Option<std::collections::HashMap<std::string::String, std::string::String>>,
}
impl CreateCrawlerInput {
/// <p>Name of the new crawler.</p>
pub fn name(&self) -> std::option::Option<&str> {
self.name.as_deref()
}
/// <p>The IAM role or Amazon Resource Name (ARN) of an IAM role used by the new crawler to access customer resources.</p>
pub fn role(&self) -> std::option::Option<&str> {
self.role.as_deref()
}
/// <p>The Glue database where results are written, such as: <code>arn:aws:daylight:us-east-1::database/sometable/*</code>.</p>
pub fn database_name(&self) -> std::option::Option<&str> {
self.database_name.as_deref()
}
/// <p>A description of the new crawler.</p>
pub fn description(&self) -> std::option::Option<&str> {
self.description.as_deref()
}
/// <p>A list of collection of targets to crawl.</p>
pub fn targets(&self) -> std::option::Option<&crate::model::CrawlerTargets> {
self.targets.as_ref()
}
/// <p>A <code>cron</code> expression used to specify the schedule (see <a href="https://docs.aws.amazon.com/glue/latest/dg/monitor-data-warehouse-schedule.html">Time-Based Schedules for Jobs and Crawlers</a>. For example, to run something every day at 12:15 UTC, you would specify: <code>cron(15 12 * * ? *)</code>.</p>
pub fn schedule(&self) -> std::option::Option<&str> {
self.schedule.as_deref()
}
/// <p>A list of custom classifiers that the user has registered. By default, all built-in classifiers are included in a crawl, but these custom classifiers always override the default classifiers for a given classification.</p>
pub fn classifiers(&self) -> std::option::Option<&[std::string::String]> {
self.classifiers.as_deref()
}
/// <p>The table prefix used for catalog tables that are created.</p>
pub fn table_prefix(&self) -> std::option::Option<&str> {
self.table_prefix.as_deref()
}
/// <p>The policy for the crawler's update and deletion behavior.</p>
pub fn schema_change_policy(&self) -> std::option::Option<&crate::model::SchemaChangePolicy> {
self.schema_change_policy.as_ref()
}
/// <p>A policy that specifies whether to crawl the entire dataset again, or to crawl only folders that were added since the last crawler run.</p>
pub fn recrawl_policy(&self) -> std::option::Option<&crate::model::RecrawlPolicy> {
self.recrawl_policy.as_ref()
}
/// <p>Specifies data lineage configuration settings for the crawler.</p>
pub fn lineage_configuration(
&self,
) -> std::option::Option<&crate::model::LineageConfiguration> {
self.lineage_configuration.as_ref()
}
/// <p>Specifies Lake Formation configuration settings for the crawler.</p>
pub fn lake_formation_configuration(
&self,
) -> std::option::Option<&crate::model::LakeFormationConfiguration> {
self.lake_formation_configuration.as_ref()
}
/// <p>Crawler configuration information. This versioned JSON string allows users to specify aspects of a crawler's behavior. For more information, see <a href="https://docs.aws.amazon.com/glue/latest/dg/crawler-configuration.html">Setting crawler configuration options</a>.</p>
pub fn configuration(&self) -> std::option::Option<&str> {
self.configuration.as_deref()
}
/// <p>The name of the <code>SecurityConfiguration</code> structure to be used by this crawler.</p>
pub fn crawler_security_configuration(&self) -> std::option::Option<&str> {
self.crawler_security_configuration.as_deref()
}
/// <p>The tags to use with this crawler request. You may use tags to limit access to the crawler. For more information about tags in Glue, see <a href="https://docs.aws.amazon.com/glue/latest/dg/monitor-tags.html">Amazon Web Services Tags in Glue</a> in the developer guide.</p>
pub fn tags(
&self,
) -> std::option::Option<&std::collections::HashMap<std::string::String, std::string::String>>
{
self.tags.as_ref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CreateConnectionInput {
/// <p>The ID of the Data Catalog in which to create the connection. If none is provided, the Amazon Web Services account ID is used by default.</p>
#[doc(hidden)]
pub catalog_id: std::option::Option<std::string::String>,
/// <p>A <code>ConnectionInput</code> object defining the connection to create.</p>
#[doc(hidden)]
pub connection_input: std::option::Option<crate::model::ConnectionInput>,
/// <p>The tags you assign to the connection.</p>
#[doc(hidden)]
pub tags:
std::option::Option<std::collections::HashMap<std::string::String, std::string::String>>,
}
impl CreateConnectionInput {
/// <p>The ID of the Data Catalog in which to create the connection. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(&self) -> std::option::Option<&str> {
self.catalog_id.as_deref()
}
/// <p>A <code>ConnectionInput</code> object defining the connection to create.</p>
pub fn connection_input(&self) -> std::option::Option<&crate::model::ConnectionInput> {
self.connection_input.as_ref()
}
/// <p>The tags you assign to the connection.</p>
pub fn tags(
&self,
) -> std::option::Option<&std::collections::HashMap<std::string::String, std::string::String>>
{
self.tags.as_ref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CreateClassifierInput {
/// <p>A <code>GrokClassifier</code> object specifying the classifier to create.</p>
#[doc(hidden)]
pub grok_classifier: std::option::Option<crate::model::CreateGrokClassifierRequest>,
/// <p>An <code>XMLClassifier</code> object specifying the classifier to create.</p>
#[doc(hidden)]
pub xml_classifier: std::option::Option<crate::model::CreateXmlClassifierRequest>,
/// <p>A <code>JsonClassifier</code> object specifying the classifier to create.</p>
#[doc(hidden)]
pub json_classifier: std::option::Option<crate::model::CreateJsonClassifierRequest>,
/// <p>A <code>CsvClassifier</code> object specifying the classifier to create.</p>
#[doc(hidden)]
pub csv_classifier: std::option::Option<crate::model::CreateCsvClassifierRequest>,
}
impl CreateClassifierInput {
/// <p>A <code>GrokClassifier</code> object specifying the classifier to create.</p>
pub fn grok_classifier(
&self,
) -> std::option::Option<&crate::model::CreateGrokClassifierRequest> {
self.grok_classifier.as_ref()
}
/// <p>An <code>XMLClassifier</code> object specifying the classifier to create.</p>
pub fn xml_classifier(&self) -> std::option::Option<&crate::model::CreateXmlClassifierRequest> {
self.xml_classifier.as_ref()
}
/// <p>A <code>JsonClassifier</code> object specifying the classifier to create.</p>
pub fn json_classifier(
&self,
) -> std::option::Option<&crate::model::CreateJsonClassifierRequest> {
self.json_classifier.as_ref()
}
/// <p>A <code>CsvClassifier</code> object specifying the classifier to create.</p>
pub fn csv_classifier(&self) -> std::option::Option<&crate::model::CreateCsvClassifierRequest> {
self.csv_classifier.as_ref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CreateBlueprintInput {
/// <p>The name of the blueprint.</p>
#[doc(hidden)]
pub name: std::option::Option<std::string::String>,
/// <p>A description of the blueprint.</p>
#[doc(hidden)]
pub description: std::option::Option<std::string::String>,
/// <p>Specifies a path in Amazon S3 where the blueprint is published.</p>
#[doc(hidden)]
pub blueprint_location: std::option::Option<std::string::String>,
/// <p>The tags to be applied to this blueprint.</p>
#[doc(hidden)]
pub tags:
std::option::Option<std::collections::HashMap<std::string::String, std::string::String>>,
}
impl CreateBlueprintInput {
/// <p>The name of the blueprint.</p>
pub fn name(&self) -> std::option::Option<&str> {
self.name.as_deref()
}
/// <p>A description of the blueprint.</p>
pub fn description(&self) -> std::option::Option<&str> {
self.description.as_deref()
}
/// <p>Specifies a path in Amazon S3 where the blueprint is published.</p>
pub fn blueprint_location(&self) -> std::option::Option<&str> {
self.blueprint_location.as_deref()
}
/// <p>The tags to be applied to this blueprint.</p>
pub fn tags(
&self,
) -> std::option::Option<&std::collections::HashMap<std::string::String, std::string::String>>
{
self.tags.as_ref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CheckSchemaVersionValidityInput {
/// <p>The data format of the schema definition. Currently <code>AVRO</code>, <code>JSON</code> and <code>PROTOBUF</code> are supported.</p>
#[doc(hidden)]
pub data_format: std::option::Option<crate::model::DataFormat>,
/// <p>The definition of the schema that has to be validated.</p>
#[doc(hidden)]
pub schema_definition: std::option::Option<std::string::String>,
}
impl CheckSchemaVersionValidityInput {
/// <p>The data format of the schema definition. Currently <code>AVRO</code>, <code>JSON</code> and <code>PROTOBUF</code> are supported.</p>
pub fn data_format(&self) -> std::option::Option<&crate::model::DataFormat> {
self.data_format.as_ref()
}
/// <p>The definition of the schema that has to be validated.</p>
pub fn schema_definition(&self) -> std::option::Option<&str> {
self.schema_definition.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CancelStatementInput {
/// <p>The Session ID of the statement to be cancelled.</p>
#[doc(hidden)]
pub session_id: std::option::Option<std::string::String>,
/// <p>The ID of the statement to be cancelled.</p>
#[doc(hidden)]
pub id: i32,
/// <p>The origin of the request to cancel the statement.</p>
#[doc(hidden)]
pub request_origin: std::option::Option<std::string::String>,
}
impl CancelStatementInput {
/// <p>The Session ID of the statement to be cancelled.</p>
pub fn session_id(&self) -> std::option::Option<&str> {
self.session_id.as_deref()
}
/// <p>The ID of the statement to be cancelled.</p>
pub fn id(&self) -> i32 {
self.id
}
/// <p>The origin of the request to cancel the statement.</p>
pub fn request_origin(&self) -> std::option::Option<&str> {
self.request_origin.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CancelMlTaskRunInput {
/// <p>The unique identifier of the machine learning transform.</p>
#[doc(hidden)]
pub transform_id: std::option::Option<std::string::String>,
/// <p>A unique identifier for the task run.</p>
#[doc(hidden)]
pub task_run_id: std::option::Option<std::string::String>,
}
impl CancelMlTaskRunInput {
/// <p>The unique identifier of the machine learning transform.</p>
pub fn transform_id(&self) -> std::option::Option<&str> {
self.transform_id.as_deref()
}
/// <p>A unique identifier for the task run.</p>
pub fn task_run_id(&self) -> std::option::Option<&str> {
self.task_run_id.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CancelDataQualityRulesetEvaluationRunInput {
/// <p>The unique run identifier associated with this run.</p>
#[doc(hidden)]
pub run_id: std::option::Option<std::string::String>,
}
impl CancelDataQualityRulesetEvaluationRunInput {
/// <p>The unique run identifier associated with this run.</p>
pub fn run_id(&self) -> std::option::Option<&str> {
self.run_id.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CancelDataQualityRuleRecommendationRunInput {
/// <p>The unique run identifier associated with this run.</p>
#[doc(hidden)]
pub run_id: std::option::Option<std::string::String>,
}
impl CancelDataQualityRuleRecommendationRunInput {
/// <p>The unique run identifier associated with this run.</p>
pub fn run_id(&self) -> std::option::Option<&str> {
self.run_id.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct BatchUpdatePartitionInput {
/// <p>The ID of the catalog in which the partition is to be updated. Currently, this should be the Amazon Web Services account ID.</p>
#[doc(hidden)]
pub catalog_id: std::option::Option<std::string::String>,
/// <p>The name of the metadata database in which the partition is to be updated.</p>
#[doc(hidden)]
pub database_name: std::option::Option<std::string::String>,
/// <p>The name of the metadata table in which the partition is to be updated.</p>
#[doc(hidden)]
pub table_name: std::option::Option<std::string::String>,
/// <p>A list of up to 100 <code>BatchUpdatePartitionRequestEntry</code> objects to update.</p>
#[doc(hidden)]
pub entries: std::option::Option<std::vec::Vec<crate::model::BatchUpdatePartitionRequestEntry>>,
}
impl BatchUpdatePartitionInput {
/// <p>The ID of the catalog in which the partition is to be updated. Currently, this should be the Amazon Web Services account ID.</p>
pub fn catalog_id(&self) -> std::option::Option<&str> {
self.catalog_id.as_deref()
}
/// <p>The name of the metadata database in which the partition is to be updated.</p>
pub fn database_name(&self) -> std::option::Option<&str> {
self.database_name.as_deref()
}
/// <p>The name of the metadata table in which the partition is to be updated.</p>
pub fn table_name(&self) -> std::option::Option<&str> {
self.table_name.as_deref()
}
/// <p>A list of up to 100 <code>BatchUpdatePartitionRequestEntry</code> objects to update.</p>
pub fn entries(
&self,
) -> std::option::Option<&[crate::model::BatchUpdatePartitionRequestEntry]> {
self.entries.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct BatchStopJobRunInput {
/// <p>The name of the job definition for which to stop job runs.</p>
#[doc(hidden)]
pub job_name: std::option::Option<std::string::String>,
/// <p>A list of the <code>JobRunIds</code> that should be stopped for that job definition.</p>
#[doc(hidden)]
pub job_run_ids: std::option::Option<std::vec::Vec<std::string::String>>,
}
impl BatchStopJobRunInput {
/// <p>The name of the job definition for which to stop job runs.</p>
pub fn job_name(&self) -> std::option::Option<&str> {
self.job_name.as_deref()
}
/// <p>A list of the <code>JobRunIds</code> that should be stopped for that job definition.</p>
pub fn job_run_ids(&self) -> std::option::Option<&[std::string::String]> {
self.job_run_ids.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct BatchGetWorkflowsInput {
/// <p>A list of workflow names, which may be the names returned from the <code>ListWorkflows</code> operation.</p>
#[doc(hidden)]
pub names: std::option::Option<std::vec::Vec<std::string::String>>,
/// <p>Specifies whether to include a graph when returning the workflow resource metadata.</p>
#[doc(hidden)]
pub include_graph: std::option::Option<bool>,
}
impl BatchGetWorkflowsInput {
/// <p>A list of workflow names, which may be the names returned from the <code>ListWorkflows</code> operation.</p>
pub fn names(&self) -> std::option::Option<&[std::string::String]> {
self.names.as_deref()
}
/// <p>Specifies whether to include a graph when returning the workflow resource metadata.</p>
pub fn include_graph(&self) -> std::option::Option<bool> {
self.include_graph
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct BatchGetTriggersInput {
/// <p>A list of trigger names, which may be the names returned from the <code>ListTriggers</code> operation.</p>
#[doc(hidden)]
pub trigger_names: std::option::Option<std::vec::Vec<std::string::String>>,
}
impl BatchGetTriggersInput {
/// <p>A list of trigger names, which may be the names returned from the <code>ListTriggers</code> operation.</p>
pub fn trigger_names(&self) -> std::option::Option<&[std::string::String]> {
self.trigger_names.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct BatchGetPartitionInput {
/// <p>The ID of the Data Catalog where the partitions in question reside. If none is supplied, the Amazon Web Services account ID is used by default.</p>
#[doc(hidden)]
pub catalog_id: std::option::Option<std::string::String>,
/// <p>The name of the catalog database where the partitions reside.</p>
#[doc(hidden)]
pub database_name: std::option::Option<std::string::String>,
/// <p>The name of the partitions' table.</p>
#[doc(hidden)]
pub table_name: std::option::Option<std::string::String>,
/// <p>A list of partition values identifying the partitions to retrieve.</p>
#[doc(hidden)]
pub partitions_to_get: std::option::Option<std::vec::Vec<crate::model::PartitionValueList>>,
}
impl BatchGetPartitionInput {
/// <p>The ID of the Data Catalog where the partitions in question reside. If none is supplied, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(&self) -> std::option::Option<&str> {
self.catalog_id.as_deref()
}
/// <p>The name of the catalog database where the partitions reside.</p>
pub fn database_name(&self) -> std::option::Option<&str> {
self.database_name.as_deref()
}
/// <p>The name of the partitions' table.</p>
pub fn table_name(&self) -> std::option::Option<&str> {
self.table_name.as_deref()
}
/// <p>A list of partition values identifying the partitions to retrieve.</p>
pub fn partitions_to_get(&self) -> std::option::Option<&[crate::model::PartitionValueList]> {
self.partitions_to_get.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct BatchGetJobsInput {
/// <p>A list of job names, which might be the names returned from the <code>ListJobs</code> operation.</p>
#[doc(hidden)]
pub job_names: std::option::Option<std::vec::Vec<std::string::String>>,
}
impl BatchGetJobsInput {
/// <p>A list of job names, which might be the names returned from the <code>ListJobs</code> operation.</p>
pub fn job_names(&self) -> std::option::Option<&[std::string::String]> {
self.job_names.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct BatchGetDevEndpointsInput {
/// <p>The list of <code>DevEndpoint</code> names, which might be the names returned from the <code>ListDevEndpoint</code> operation.</p>
#[doc(hidden)]
pub dev_endpoint_names: std::option::Option<std::vec::Vec<std::string::String>>,
}
impl BatchGetDevEndpointsInput {
/// <p>The list of <code>DevEndpoint</code> names, which might be the names returned from the <code>ListDevEndpoint</code> operation.</p>
pub fn dev_endpoint_names(&self) -> std::option::Option<&[std::string::String]> {
self.dev_endpoint_names.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct BatchGetDataQualityResultInput {
/// <p>A list of unique result IDs for the data quality results.</p>
#[doc(hidden)]
pub result_ids: std::option::Option<std::vec::Vec<std::string::String>>,
}
impl BatchGetDataQualityResultInput {
/// <p>A list of unique result IDs for the data quality results.</p>
pub fn result_ids(&self) -> std::option::Option<&[std::string::String]> {
self.result_ids.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct BatchGetCustomEntityTypesInput {
/// <p>A list of names of the custom patterns that you want to retrieve.</p>
#[doc(hidden)]
pub names: std::option::Option<std::vec::Vec<std::string::String>>,
}
impl BatchGetCustomEntityTypesInput {
/// <p>A list of names of the custom patterns that you want to retrieve.</p>
pub fn names(&self) -> std::option::Option<&[std::string::String]> {
self.names.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct BatchGetCrawlersInput {
/// <p>A list of crawler names, which might be the names returned from the <code>ListCrawlers</code> operation.</p>
#[doc(hidden)]
pub crawler_names: std::option::Option<std::vec::Vec<std::string::String>>,
}
impl BatchGetCrawlersInput {
/// <p>A list of crawler names, which might be the names returned from the <code>ListCrawlers</code> operation.</p>
pub fn crawler_names(&self) -> std::option::Option<&[std::string::String]> {
self.crawler_names.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct BatchGetBlueprintsInput {
/// <p>A list of blueprint names.</p>
#[doc(hidden)]
pub names: std::option::Option<std::vec::Vec<std::string::String>>,
/// <p>Specifies whether or not to include the blueprint in the response.</p>
#[doc(hidden)]
pub include_blueprint: std::option::Option<bool>,
/// <p>Specifies whether or not to include the parameters, as a JSON string, for the blueprint in the response.</p>
#[doc(hidden)]
pub include_parameter_spec: std::option::Option<bool>,
}
impl BatchGetBlueprintsInput {
/// <p>A list of blueprint names.</p>
pub fn names(&self) -> std::option::Option<&[std::string::String]> {
self.names.as_deref()
}
/// <p>Specifies whether or not to include the blueprint in the response.</p>
pub fn include_blueprint(&self) -> std::option::Option<bool> {
self.include_blueprint
}
/// <p>Specifies whether or not to include the parameters, as a JSON string, for the blueprint in the response.</p>
pub fn include_parameter_spec(&self) -> std::option::Option<bool> {
self.include_parameter_spec
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct BatchDeleteTableVersionInput {
/// <p>The ID of the Data Catalog where the tables reside. If none is provided, the Amazon Web Services account ID is used by default.</p>
#[doc(hidden)]
pub catalog_id: std::option::Option<std::string::String>,
/// <p>The database in the catalog in which the table resides. For Hive compatibility, this name is entirely lowercase.</p>
#[doc(hidden)]
pub database_name: std::option::Option<std::string::String>,
/// <p>The name of the table. For Hive compatibility, this name is entirely lowercase.</p>
#[doc(hidden)]
pub table_name: std::option::Option<std::string::String>,
/// <p>A list of the IDs of versions to be deleted. A <code>VersionId</code> is a string representation of an integer. Each version is incremented by 1.</p>
#[doc(hidden)]
pub version_ids: std::option::Option<std::vec::Vec<std::string::String>>,
}
impl BatchDeleteTableVersionInput {
/// <p>The ID of the Data Catalog where the tables reside. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(&self) -> std::option::Option<&str> {
self.catalog_id.as_deref()
}
/// <p>The database in the catalog in which the table resides. For Hive compatibility, this name is entirely lowercase.</p>
pub fn database_name(&self) -> std::option::Option<&str> {
self.database_name.as_deref()
}
/// <p>The name of the table. For Hive compatibility, this name is entirely lowercase.</p>
pub fn table_name(&self) -> std::option::Option<&str> {
self.table_name.as_deref()
}
/// <p>A list of the IDs of versions to be deleted. A <code>VersionId</code> is a string representation of an integer. Each version is incremented by 1.</p>
pub fn version_ids(&self) -> std::option::Option<&[std::string::String]> {
self.version_ids.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct BatchDeleteTableInput {
/// <p>The ID of the Data Catalog where the table resides. If none is provided, the Amazon Web Services account ID is used by default.</p>
#[doc(hidden)]
pub catalog_id: std::option::Option<std::string::String>,
/// <p>The name of the catalog database in which the tables to delete reside. For Hive compatibility, this name is entirely lowercase.</p>
#[doc(hidden)]
pub database_name: std::option::Option<std::string::String>,
/// <p>A list of the table to delete.</p>
#[doc(hidden)]
pub tables_to_delete: std::option::Option<std::vec::Vec<std::string::String>>,
/// <p>The transaction ID at which to delete the table contents.</p>
#[doc(hidden)]
pub transaction_id: std::option::Option<std::string::String>,
}
impl BatchDeleteTableInput {
/// <p>The ID of the Data Catalog where the table resides. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(&self) -> std::option::Option<&str> {
self.catalog_id.as_deref()
}
/// <p>The name of the catalog database in which the tables to delete reside. For Hive compatibility, this name is entirely lowercase.</p>
pub fn database_name(&self) -> std::option::Option<&str> {
self.database_name.as_deref()
}
/// <p>A list of the table to delete.</p>
pub fn tables_to_delete(&self) -> std::option::Option<&[std::string::String]> {
self.tables_to_delete.as_deref()
}
/// <p>The transaction ID at which to delete the table contents.</p>
pub fn transaction_id(&self) -> std::option::Option<&str> {
self.transaction_id.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct BatchDeletePartitionInput {
/// <p>The ID of the Data Catalog where the partition to be deleted resides. If none is provided, the Amazon Web Services account ID is used by default.</p>
#[doc(hidden)]
pub catalog_id: std::option::Option<std::string::String>,
/// <p>The name of the catalog database in which the table in question resides.</p>
#[doc(hidden)]
pub database_name: std::option::Option<std::string::String>,
/// <p>The name of the table that contains the partitions to be deleted.</p>
#[doc(hidden)]
pub table_name: std::option::Option<std::string::String>,
/// <p>A list of <code>PartitionInput</code> structures that define the partitions to be deleted.</p>
#[doc(hidden)]
pub partitions_to_delete: std::option::Option<std::vec::Vec<crate::model::PartitionValueList>>,
}
impl BatchDeletePartitionInput {
/// <p>The ID of the Data Catalog where the partition to be deleted resides. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(&self) -> std::option::Option<&str> {
self.catalog_id.as_deref()
}
/// <p>The name of the catalog database in which the table in question resides.</p>
pub fn database_name(&self) -> std::option::Option<&str> {
self.database_name.as_deref()
}
/// <p>The name of the table that contains the partitions to be deleted.</p>
pub fn table_name(&self) -> std::option::Option<&str> {
self.table_name.as_deref()
}
/// <p>A list of <code>PartitionInput</code> structures that define the partitions to be deleted.</p>
pub fn partitions_to_delete(&self) -> std::option::Option<&[crate::model::PartitionValueList]> {
self.partitions_to_delete.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct BatchDeleteConnectionInput {
/// <p>The ID of the Data Catalog in which the connections reside. If none is provided, the Amazon Web Services account ID is used by default.</p>
#[doc(hidden)]
pub catalog_id: std::option::Option<std::string::String>,
/// <p>A list of names of the connections to delete.</p>
#[doc(hidden)]
pub connection_name_list: std::option::Option<std::vec::Vec<std::string::String>>,
}
impl BatchDeleteConnectionInput {
/// <p>The ID of the Data Catalog in which the connections reside. If none is provided, the Amazon Web Services account ID is used by default.</p>
pub fn catalog_id(&self) -> std::option::Option<&str> {
self.catalog_id.as_deref()
}
/// <p>A list of names of the connections to delete.</p>
pub fn connection_name_list(&self) -> std::option::Option<&[std::string::String]> {
self.connection_name_list.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct BatchCreatePartitionInput {
/// <p>The ID of the catalog in which the partition is to be created. Currently, this should be the Amazon Web Services account ID.</p>
#[doc(hidden)]
pub catalog_id: std::option::Option<std::string::String>,
/// <p>The name of the metadata database in which the partition is to be created.</p>
#[doc(hidden)]
pub database_name: std::option::Option<std::string::String>,
/// <p>The name of the metadata table in which the partition is to be created.</p>
#[doc(hidden)]
pub table_name: std::option::Option<std::string::String>,
/// <p>A list of <code>PartitionInput</code> structures that define the partitions to be created.</p>
#[doc(hidden)]
pub partition_input_list: std::option::Option<std::vec::Vec<crate::model::PartitionInput>>,
}
impl BatchCreatePartitionInput {
/// <p>The ID of the catalog in which the partition is to be created. Currently, this should be the Amazon Web Services account ID.</p>
pub fn catalog_id(&self) -> std::option::Option<&str> {
self.catalog_id.as_deref()
}
/// <p>The name of the metadata database in which the partition is to be created.</p>
pub fn database_name(&self) -> std::option::Option<&str> {
self.database_name.as_deref()
}
/// <p>The name of the metadata table in which the partition is to be created.</p>
pub fn table_name(&self) -> std::option::Option<&str> {
self.table_name.as_deref()
}
/// <p>A list of <code>PartitionInput</code> structures that define the partitions to be created.</p>
pub fn partition_input_list(&self) -> std::option::Option<&[crate::model::PartitionInput]> {
self.partition_input_list.as_deref()
}
}