pub fn serialize_structure_crate_input_add_lf_tags_to_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AddLfTagsToResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.catalog_id {
object.key("CatalogId").string(var_1.as_str());
}
if let Some(var_2) = &input.lf_tags {
let mut array_3 = object.key("LFTags").start_array();
for item_4 in var_2 {
{
#[allow(unused_mut)]
let mut object_5 = array_3.value().start_object();
crate::json_ser::serialize_structure_crate_model_lf_tag_pair(
&mut object_5,
item_4,
)?;
object_5.finish();
}
}
array_3.finish();
}
if let Some(var_6) = &input.resource {
#[allow(unused_mut)]
let mut object_7 = object.key("Resource").start_object();
crate::json_ser::serialize_structure_crate_model_resource(&mut object_7, var_6)?;
object_7.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_assume_decorated_role_with_saml_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AssumeDecoratedRoleWithSamlInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_8) = &input.duration_seconds {
object.key("DurationSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_8).into()),
);
}
if let Some(var_9) = &input.principal_arn {
object.key("PrincipalArn").string(var_9.as_str());
}
if let Some(var_10) = &input.role_arn {
object.key("RoleArn").string(var_10.as_str());
}
if let Some(var_11) = &input.saml_assertion {
object.key("SAMLAssertion").string(var_11.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_batch_grant_permissions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchGrantPermissionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_12) = &input.catalog_id {
object.key("CatalogId").string(var_12.as_str());
}
if let Some(var_13) = &input.entries {
let mut array_14 = object.key("Entries").start_array();
for item_15 in var_13 {
{
#[allow(unused_mut)]
let mut object_16 = array_14.value().start_object();
crate::json_ser::serialize_structure_crate_model_batch_permissions_request_entry(
&mut object_16,
item_15,
)?;
object_16.finish();
}
}
array_14.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_batch_revoke_permissions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchRevokePermissionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_17) = &input.catalog_id {
object.key("CatalogId").string(var_17.as_str());
}
if let Some(var_18) = &input.entries {
let mut array_19 = object.key("Entries").start_array();
for item_20 in var_18 {
{
#[allow(unused_mut)]
let mut object_21 = array_19.value().start_object();
crate::json_ser::serialize_structure_crate_model_batch_permissions_request_entry(
&mut object_21,
item_20,
)?;
object_21.finish();
}
}
array_19.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_cancel_transaction_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CancelTransactionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_22) = &input.transaction_id {
object.key("TransactionId").string(var_22.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_commit_transaction_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CommitTransactionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_23) = &input.transaction_id {
object.key("TransactionId").string(var_23.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_data_cells_filter_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateDataCellsFilterInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_24) = &input.table_data {
#[allow(unused_mut)]
let mut object_25 = object.key("TableData").start_object();
crate::json_ser::serialize_structure_crate_model_data_cells_filter(&mut object_25, var_24)?;
object_25.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_lf_tag_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateLfTagInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_26) = &input.catalog_id {
object.key("CatalogId").string(var_26.as_str());
}
if let Some(var_27) = &input.tag_key {
object.key("TagKey").string(var_27.as_str());
}
if let Some(var_28) = &input.tag_values {
let mut array_29 = object.key("TagValues").start_array();
for item_30 in var_28 {
{
array_29.value().string(item_30.as_str());
}
}
array_29.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_data_cells_filter_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteDataCellsFilterInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_31) = &input.database_name {
object.key("DatabaseName").string(var_31.as_str());
}
if let Some(var_32) = &input.name {
object.key("Name").string(var_32.as_str());
}
if let Some(var_33) = &input.table_catalog_id {
object.key("TableCatalogId").string(var_33.as_str());
}
if let Some(var_34) = &input.table_name {
object.key("TableName").string(var_34.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_lf_tag_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteLfTagInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_35) = &input.catalog_id {
object.key("CatalogId").string(var_35.as_str());
}
if let Some(var_36) = &input.tag_key {
object.key("TagKey").string(var_36.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_objects_on_cancel_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteObjectsOnCancelInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_37) = &input.catalog_id {
object.key("CatalogId").string(var_37.as_str());
}
if let Some(var_38) = &input.database_name {
object.key("DatabaseName").string(var_38.as_str());
}
if let Some(var_39) = &input.objects {
let mut array_40 = object.key("Objects").start_array();
for item_41 in var_39 {
{
#[allow(unused_mut)]
let mut object_42 = array_40.value().start_object();
crate::json_ser::serialize_structure_crate_model_virtual_object(
&mut object_42,
item_41,
)?;
object_42.finish();
}
}
array_40.finish();
}
if let Some(var_43) = &input.table_name {
object.key("TableName").string(var_43.as_str());
}
if let Some(var_44) = &input.transaction_id {
object.key("TransactionId").string(var_44.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_deregister_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeregisterResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_45) = &input.resource_arn {
object.key("ResourceArn").string(var_45.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_46) = &input.resource_arn {
object.key("ResourceArn").string(var_46.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_transaction_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeTransactionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_47) = &input.transaction_id {
object.key("TransactionId").string(var_47.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_extend_transaction_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ExtendTransactionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_48) = &input.transaction_id {
object.key("TransactionId").string(var_48.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_data_lake_settings_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetDataLakeSettingsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_49) = &input.catalog_id {
object.key("CatalogId").string(var_49.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_effective_permissions_for_path_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetEffectivePermissionsForPathInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_50) = &input.catalog_id {
object.key("CatalogId").string(var_50.as_str());
}
if let Some(var_51) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_51).into()),
);
}
if let Some(var_52) = &input.next_token {
object.key("NextToken").string(var_52.as_str());
}
if let Some(var_53) = &input.resource_arn {
object.key("ResourceArn").string(var_53.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_lf_tag_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetLfTagInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_54) = &input.catalog_id {
object.key("CatalogId").string(var_54.as_str());
}
if let Some(var_55) = &input.tag_key {
object.key("TagKey").string(var_55.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_query_state_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetQueryStateInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_56) = &input.query_id {
object.key("QueryId").string(var_56.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_query_statistics_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetQueryStatisticsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_57) = &input.query_id {
object.key("QueryId").string(var_57.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_resource_lf_tags_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetResourceLfTagsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_58) = &input.catalog_id {
object.key("CatalogId").string(var_58.as_str());
}
if let Some(var_59) = &input.resource {
#[allow(unused_mut)]
let mut object_60 = object.key("Resource").start_object();
crate::json_ser::serialize_structure_crate_model_resource(&mut object_60, var_59)?;
object_60.finish();
}
if let Some(var_61) = &input.show_assigned_lf_tags {
object.key("ShowAssignedLFTags").boolean(*var_61);
}
Ok(())
}
pub fn serialize_structure_crate_input_get_table_objects_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetTableObjectsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_62) = &input.catalog_id {
object.key("CatalogId").string(var_62.as_str());
}
if let Some(var_63) = &input.database_name {
object.key("DatabaseName").string(var_63.as_str());
}
if let Some(var_64) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_64).into()),
);
}
if let Some(var_65) = &input.next_token {
object.key("NextToken").string(var_65.as_str());
}
if let Some(var_66) = &input.partition_predicate {
object.key("PartitionPredicate").string(var_66.as_str());
}
if let Some(var_67) = &input.query_as_of_time {
object
.key("QueryAsOfTime")
.date_time(var_67, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_68) = &input.table_name {
object.key("TableName").string(var_68.as_str());
}
if let Some(var_69) = &input.transaction_id {
object.key("TransactionId").string(var_69.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_temporary_glue_partition_credentials_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetTemporaryGluePartitionCredentialsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_70) = &input.audit_context {
#[allow(unused_mut)]
let mut object_71 = object.key("AuditContext").start_object();
crate::json_ser::serialize_structure_crate_model_audit_context(&mut object_71, var_70)?;
object_71.finish();
}
if let Some(var_72) = &input.duration_seconds {
object.key("DurationSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_72).into()),
);
}
if let Some(var_73) = &input.partition {
#[allow(unused_mut)]
let mut object_74 = object.key("Partition").start_object();
crate::json_ser::serialize_structure_crate_model_partition_value_list(
&mut object_74,
var_73,
)?;
object_74.finish();
}
if let Some(var_75) = &input.permissions {
let mut array_76 = object.key("Permissions").start_array();
for item_77 in var_75 {
{
array_76.value().string(item_77.as_str());
}
}
array_76.finish();
}
if let Some(var_78) = &input.supported_permission_types {
let mut array_79 = object.key("SupportedPermissionTypes").start_array();
for item_80 in var_78 {
{
array_79.value().string(item_80.as_str());
}
}
array_79.finish();
}
if let Some(var_81) = &input.table_arn {
object.key("TableArn").string(var_81.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_temporary_glue_table_credentials_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetTemporaryGlueTableCredentialsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_82) = &input.audit_context {
#[allow(unused_mut)]
let mut object_83 = object.key("AuditContext").start_object();
crate::json_ser::serialize_structure_crate_model_audit_context(&mut object_83, var_82)?;
object_83.finish();
}
if let Some(var_84) = &input.duration_seconds {
object.key("DurationSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_84).into()),
);
}
if let Some(var_85) = &input.permissions {
let mut array_86 = object.key("Permissions").start_array();
for item_87 in var_85 {
{
array_86.value().string(item_87.as_str());
}
}
array_86.finish();
}
if let Some(var_88) = &input.supported_permission_types {
let mut array_89 = object.key("SupportedPermissionTypes").start_array();
for item_90 in var_88 {
{
array_89.value().string(item_90.as_str());
}
}
array_89.finish();
}
if let Some(var_91) = &input.table_arn {
object.key("TableArn").string(var_91.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_work_unit_results_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetWorkUnitResultsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_92) = &input.query_id {
object.key("QueryId").string(var_92.as_str());
}
{
object.key("WorkUnitId").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.work_unit_id).into()),
);
}
if let Some(var_93) = &input.work_unit_token {
object.key("WorkUnitToken").string(var_93.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_work_units_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetWorkUnitsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_94) = &input.next_token {
object.key("NextToken").string(var_94.as_str());
}
if let Some(var_95) = &input.page_size {
object.key("PageSize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_95).into()),
);
}
if let Some(var_96) = &input.query_id {
object.key("QueryId").string(var_96.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_grant_permissions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GrantPermissionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_97) = &input.catalog_id {
object.key("CatalogId").string(var_97.as_str());
}
if let Some(var_98) = &input.permissions {
let mut array_99 = object.key("Permissions").start_array();
for item_100 in var_98 {
{
array_99.value().string(item_100.as_str());
}
}
array_99.finish();
}
if let Some(var_101) = &input.permissions_with_grant_option {
let mut array_102 = object.key("PermissionsWithGrantOption").start_array();
for item_103 in var_101 {
{
array_102.value().string(item_103.as_str());
}
}
array_102.finish();
}
if let Some(var_104) = &input.principal {
#[allow(unused_mut)]
let mut object_105 = object.key("Principal").start_object();
crate::json_ser::serialize_structure_crate_model_data_lake_principal(
&mut object_105,
var_104,
)?;
object_105.finish();
}
if let Some(var_106) = &input.resource {
#[allow(unused_mut)]
let mut object_107 = object.key("Resource").start_object();
crate::json_ser::serialize_structure_crate_model_resource(&mut object_107, var_106)?;
object_107.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_data_cells_filter_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListDataCellsFilterInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_108) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_108).into()),
);
}
if let Some(var_109) = &input.next_token {
object.key("NextToken").string(var_109.as_str());
}
if let Some(var_110) = &input.table {
#[allow(unused_mut)]
let mut object_111 = object.key("Table").start_object();
crate::json_ser::serialize_structure_crate_model_table_resource(&mut object_111, var_110)?;
object_111.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_lf_tags_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListLfTagsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_112) = &input.catalog_id {
object.key("CatalogId").string(var_112.as_str());
}
if let Some(var_113) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_113).into()),
);
}
if let Some(var_114) = &input.next_token {
object.key("NextToken").string(var_114.as_str());
}
if let Some(var_115) = &input.resource_share_type {
object.key("ResourceShareType").string(var_115.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_permissions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListPermissionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_116) = &input.catalog_id {
object.key("CatalogId").string(var_116.as_str());
}
if let Some(var_117) = &input.include_related {
object.key("IncludeRelated").string(var_117.as_str());
}
if let Some(var_118) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_118).into()),
);
}
if let Some(var_119) = &input.next_token {
object.key("NextToken").string(var_119.as_str());
}
if let Some(var_120) = &input.principal {
#[allow(unused_mut)]
let mut object_121 = object.key("Principal").start_object();
crate::json_ser::serialize_structure_crate_model_data_lake_principal(
&mut object_121,
var_120,
)?;
object_121.finish();
}
if let Some(var_122) = &input.resource {
#[allow(unused_mut)]
let mut object_123 = object.key("Resource").start_object();
crate::json_ser::serialize_structure_crate_model_resource(&mut object_123, var_122)?;
object_123.finish();
}
if let Some(var_124) = &input.resource_type {
object.key("ResourceType").string(var_124.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_resources_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListResourcesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_125) = &input.filter_condition_list {
let mut array_126 = object.key("FilterConditionList").start_array();
for item_127 in var_125 {
{
#[allow(unused_mut)]
let mut object_128 = array_126.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter_condition(
&mut object_128,
item_127,
)?;
object_128.finish();
}
}
array_126.finish();
}
if let Some(var_129) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_129).into()),
);
}
if let Some(var_130) = &input.next_token {
object.key("NextToken").string(var_130.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_table_storage_optimizers_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListTableStorageOptimizersInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_131) = &input.catalog_id {
object.key("CatalogId").string(var_131.as_str());
}
if let Some(var_132) = &input.database_name {
object.key("DatabaseName").string(var_132.as_str());
}
if let Some(var_133) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_133).into()),
);
}
if let Some(var_134) = &input.next_token {
object.key("NextToken").string(var_134.as_str());
}
if let Some(var_135) = &input.storage_optimizer_type {
object.key("StorageOptimizerType").string(var_135.as_str());
}
if let Some(var_136) = &input.table_name {
object.key("TableName").string(var_136.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_transactions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListTransactionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_137) = &input.catalog_id {
object.key("CatalogId").string(var_137.as_str());
}
if let Some(var_138) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_138).into()),
);
}
if let Some(var_139) = &input.next_token {
object.key("NextToken").string(var_139.as_str());
}
if let Some(var_140) = &input.status_filter {
object.key("StatusFilter").string(var_140.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_put_data_lake_settings_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutDataLakeSettingsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_141) = &input.catalog_id {
object.key("CatalogId").string(var_141.as_str());
}
if let Some(var_142) = &input.data_lake_settings {
#[allow(unused_mut)]
let mut object_143 = object.key("DataLakeSettings").start_object();
crate::json_ser::serialize_structure_crate_model_data_lake_settings(
&mut object_143,
var_142,
)?;
object_143.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_register_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RegisterResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_144) = &input.resource_arn {
object.key("ResourceArn").string(var_144.as_str());
}
if let Some(var_145) = &input.role_arn {
object.key("RoleArn").string(var_145.as_str());
}
if let Some(var_146) = &input.use_service_linked_role {
object.key("UseServiceLinkedRole").boolean(*var_146);
}
Ok(())
}
pub fn serialize_structure_crate_input_remove_lf_tags_from_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RemoveLfTagsFromResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_147) = &input.catalog_id {
object.key("CatalogId").string(var_147.as_str());
}
if let Some(var_148) = &input.lf_tags {
let mut array_149 = object.key("LFTags").start_array();
for item_150 in var_148 {
{
#[allow(unused_mut)]
let mut object_151 = array_149.value().start_object();
crate::json_ser::serialize_structure_crate_model_lf_tag_pair(
&mut object_151,
item_150,
)?;
object_151.finish();
}
}
array_149.finish();
}
if let Some(var_152) = &input.resource {
#[allow(unused_mut)]
let mut object_153 = object.key("Resource").start_object();
crate::json_ser::serialize_structure_crate_model_resource(&mut object_153, var_152)?;
object_153.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_revoke_permissions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RevokePermissionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_154) = &input.catalog_id {
object.key("CatalogId").string(var_154.as_str());
}
if let Some(var_155) = &input.permissions {
let mut array_156 = object.key("Permissions").start_array();
for item_157 in var_155 {
{
array_156.value().string(item_157.as_str());
}
}
array_156.finish();
}
if let Some(var_158) = &input.permissions_with_grant_option {
let mut array_159 = object.key("PermissionsWithGrantOption").start_array();
for item_160 in var_158 {
{
array_159.value().string(item_160.as_str());
}
}
array_159.finish();
}
if let Some(var_161) = &input.principal {
#[allow(unused_mut)]
let mut object_162 = object.key("Principal").start_object();
crate::json_ser::serialize_structure_crate_model_data_lake_principal(
&mut object_162,
var_161,
)?;
object_162.finish();
}
if let Some(var_163) = &input.resource {
#[allow(unused_mut)]
let mut object_164 = object.key("Resource").start_object();
crate::json_ser::serialize_structure_crate_model_resource(&mut object_164, var_163)?;
object_164.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_search_databases_by_lf_tags_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::SearchDatabasesByLfTagsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_165) = &input.catalog_id {
object.key("CatalogId").string(var_165.as_str());
}
if let Some(var_166) = &input.expression {
let mut array_167 = object.key("Expression").start_array();
for item_168 in var_166 {
{
#[allow(unused_mut)]
let mut object_169 = array_167.value().start_object();
crate::json_ser::serialize_structure_crate_model_lf_tag(&mut object_169, item_168)?;
object_169.finish();
}
}
array_167.finish();
}
if let Some(var_170) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_170).into()),
);
}
if let Some(var_171) = &input.next_token {
object.key("NextToken").string(var_171.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_search_tables_by_lf_tags_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::SearchTablesByLfTagsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_172) = &input.catalog_id {
object.key("CatalogId").string(var_172.as_str());
}
if let Some(var_173) = &input.expression {
let mut array_174 = object.key("Expression").start_array();
for item_175 in var_173 {
{
#[allow(unused_mut)]
let mut object_176 = array_174.value().start_object();
crate::json_ser::serialize_structure_crate_model_lf_tag(&mut object_176, item_175)?;
object_176.finish();
}
}
array_174.finish();
}
if let Some(var_177) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_177).into()),
);
}
if let Some(var_178) = &input.next_token {
object.key("NextToken").string(var_178.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_start_query_planning_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartQueryPlanningInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_179) = &input.query_planning_context {
#[allow(unused_mut)]
let mut object_180 = object.key("QueryPlanningContext").start_object();
crate::json_ser::serialize_structure_crate_model_query_planning_context(
&mut object_180,
var_179,
)?;
object_180.finish();
}
if let Some(var_181) = &input.query_string {
object.key("QueryString").string(var_181.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_start_transaction_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartTransactionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_182) = &input.transaction_type {
object.key("TransactionType").string(var_182.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_lf_tag_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateLfTagInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_183) = &input.catalog_id {
object.key("CatalogId").string(var_183.as_str());
}
if let Some(var_184) = &input.tag_key {
object.key("TagKey").string(var_184.as_str());
}
if let Some(var_185) = &input.tag_values_to_add {
let mut array_186 = object.key("TagValuesToAdd").start_array();
for item_187 in var_185 {
{
array_186.value().string(item_187.as_str());
}
}
array_186.finish();
}
if let Some(var_188) = &input.tag_values_to_delete {
let mut array_189 = object.key("TagValuesToDelete").start_array();
for item_190 in var_188 {
{
array_189.value().string(item_190.as_str());
}
}
array_189.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_191) = &input.resource_arn {
object.key("ResourceArn").string(var_191.as_str());
}
if let Some(var_192) = &input.role_arn {
object.key("RoleArn").string(var_192.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_table_objects_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateTableObjectsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_193) = &input.catalog_id {
object.key("CatalogId").string(var_193.as_str());
}
if let Some(var_194) = &input.database_name {
object.key("DatabaseName").string(var_194.as_str());
}
if let Some(var_195) = &input.table_name {
object.key("TableName").string(var_195.as_str());
}
if let Some(var_196) = &input.transaction_id {
object.key("TransactionId").string(var_196.as_str());
}
if let Some(var_197) = &input.write_operations {
let mut array_198 = object.key("WriteOperations").start_array();
for item_199 in var_197 {
{
#[allow(unused_mut)]
let mut object_200 = array_198.value().start_object();
crate::json_ser::serialize_structure_crate_model_write_operation(
&mut object_200,
item_199,
)?;
object_200.finish();
}
}
array_198.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_table_storage_optimizer_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateTableStorageOptimizerInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_201) = &input.catalog_id {
object.key("CatalogId").string(var_201.as_str());
}
if let Some(var_202) = &input.database_name {
object.key("DatabaseName").string(var_202.as_str());
}
if let Some(var_203) = &input.storage_optimizer_config {
#[allow(unused_mut)]
let mut object_204 = object.key("StorageOptimizerConfig").start_object();
for (key_205, value_206) in var_203 {
{
#[allow(unused_mut)]
let mut object_207 = object_204.key(key_205.as_str()).start_object();
for (key_208, value_209) in value_206 {
{
object_207.key(key_208.as_str()).string(value_209.as_str());
}
}
object_207.finish();
}
}
object_204.finish();
}
if let Some(var_210) = &input.table_name {
object.key("TableName").string(var_210.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_lf_tag_pair(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LfTagPair,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_211) = &input.catalog_id {
object.key("CatalogId").string(var_211.as_str());
}
if let Some(var_212) = &input.tag_key {
object.key("TagKey").string(var_212.as_str());
}
if let Some(var_213) = &input.tag_values {
let mut array_214 = object.key("TagValues").start_array();
for item_215 in var_213 {
{
array_214.value().string(item_215.as_str());
}
}
array_214.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_resource(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Resource,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_216) = &input.catalog {
#[allow(unused_mut)]
let mut object_217 = object.key("Catalog").start_object();
crate::json_ser::serialize_structure_crate_model_catalog_resource(
&mut object_217,
var_216,
)?;
object_217.finish();
}
if let Some(var_218) = &input.database {
#[allow(unused_mut)]
let mut object_219 = object.key("Database").start_object();
crate::json_ser::serialize_structure_crate_model_database_resource(
&mut object_219,
var_218,
)?;
object_219.finish();
}
if let Some(var_220) = &input.table {
#[allow(unused_mut)]
let mut object_221 = object.key("Table").start_object();
crate::json_ser::serialize_structure_crate_model_table_resource(&mut object_221, var_220)?;
object_221.finish();
}
if let Some(var_222) = &input.table_with_columns {
#[allow(unused_mut)]
let mut object_223 = object.key("TableWithColumns").start_object();
crate::json_ser::serialize_structure_crate_model_table_with_columns_resource(
&mut object_223,
var_222,
)?;
object_223.finish();
}
if let Some(var_224) = &input.data_location {
#[allow(unused_mut)]
let mut object_225 = object.key("DataLocation").start_object();
crate::json_ser::serialize_structure_crate_model_data_location_resource(
&mut object_225,
var_224,
)?;
object_225.finish();
}
if let Some(var_226) = &input.data_cells_filter {
#[allow(unused_mut)]
let mut object_227 = object.key("DataCellsFilter").start_object();
crate::json_ser::serialize_structure_crate_model_data_cells_filter_resource(
&mut object_227,
var_226,
)?;
object_227.finish();
}
if let Some(var_228) = &input.lf_tag {
#[allow(unused_mut)]
let mut object_229 = object.key("LFTag").start_object();
crate::json_ser::serialize_structure_crate_model_lf_tag_key_resource(
&mut object_229,
var_228,
)?;
object_229.finish();
}
if let Some(var_230) = &input.lf_tag_policy {
#[allow(unused_mut)]
let mut object_231 = object.key("LFTagPolicy").start_object();
crate::json_ser::serialize_structure_crate_model_lf_tag_policy_resource(
&mut object_231,
var_230,
)?;
object_231.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_batch_permissions_request_entry(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BatchPermissionsRequestEntry,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_232) = &input.id {
object.key("Id").string(var_232.as_str());
}
if let Some(var_233) = &input.principal {
#[allow(unused_mut)]
let mut object_234 = object.key("Principal").start_object();
crate::json_ser::serialize_structure_crate_model_data_lake_principal(
&mut object_234,
var_233,
)?;
object_234.finish();
}
if let Some(var_235) = &input.resource {
#[allow(unused_mut)]
let mut object_236 = object.key("Resource").start_object();
crate::json_ser::serialize_structure_crate_model_resource(&mut object_236, var_235)?;
object_236.finish();
}
if let Some(var_237) = &input.permissions {
let mut array_238 = object.key("Permissions").start_array();
for item_239 in var_237 {
{
array_238.value().string(item_239.as_str());
}
}
array_238.finish();
}
if let Some(var_240) = &input.permissions_with_grant_option {
let mut array_241 = object.key("PermissionsWithGrantOption").start_array();
for item_242 in var_240 {
{
array_241.value().string(item_242.as_str());
}
}
array_241.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_data_cells_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DataCellsFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_243) = &input.table_catalog_id {
object.key("TableCatalogId").string(var_243.as_str());
}
if let Some(var_244) = &input.database_name {
object.key("DatabaseName").string(var_244.as_str());
}
if let Some(var_245) = &input.table_name {
object.key("TableName").string(var_245.as_str());
}
if let Some(var_246) = &input.name {
object.key("Name").string(var_246.as_str());
}
if let Some(var_247) = &input.row_filter {
#[allow(unused_mut)]
let mut object_248 = object.key("RowFilter").start_object();
crate::json_ser::serialize_structure_crate_model_row_filter(&mut object_248, var_247)?;
object_248.finish();
}
if let Some(var_249) = &input.column_names {
let mut array_250 = object.key("ColumnNames").start_array();
for item_251 in var_249 {
{
array_250.value().string(item_251.as_str());
}
}
array_250.finish();
}
if let Some(var_252) = &input.column_wildcard {
#[allow(unused_mut)]
let mut object_253 = object.key("ColumnWildcard").start_object();
crate::json_ser::serialize_structure_crate_model_column_wildcard(&mut object_253, var_252)?;
object_253.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_virtual_object(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::VirtualObject,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_254) = &input.uri {
object.key("Uri").string(var_254.as_str());
}
if let Some(var_255) = &input.e_tag {
object.key("ETag").string(var_255.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_audit_context(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AuditContext,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_256) = &input.additional_audit_context {
object
.key("AdditionalAuditContext")
.string(var_256.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_partition_value_list(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PartitionValueList,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_257) = &input.values {
let mut array_258 = object.key("Values").start_array();
for item_259 in var_257 {
{
array_258.value().string(item_259.as_str());
}
}
array_258.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_data_lake_principal(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DataLakePrincipal,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_260) = &input.data_lake_principal_identifier {
object
.key("DataLakePrincipalIdentifier")
.string(var_260.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_table_resource(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TableResource,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_261) = &input.catalog_id {
object.key("CatalogId").string(var_261.as_str());
}
if let Some(var_262) = &input.database_name {
object.key("DatabaseName").string(var_262.as_str());
}
if let Some(var_263) = &input.name {
object.key("Name").string(var_263.as_str());
}
if let Some(var_264) = &input.table_wildcard {
#[allow(unused_mut)]
let mut object_265 = object.key("TableWildcard").start_object();
crate::json_ser::serialize_structure_crate_model_table_wildcard(&mut object_265, var_264)?;
object_265.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_filter_condition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FilterCondition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_266) = &input.field {
object.key("Field").string(var_266.as_str());
}
if let Some(var_267) = &input.comparison_operator {
object.key("ComparisonOperator").string(var_267.as_str());
}
if let Some(var_268) = &input.string_value_list {
let mut array_269 = object.key("StringValueList").start_array();
for item_270 in var_268 {
{
array_269.value().string(item_270.as_str());
}
}
array_269.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_data_lake_settings(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DataLakeSettings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_271) = &input.data_lake_admins {
let mut array_272 = object.key("DataLakeAdmins").start_array();
for item_273 in var_271 {
{
#[allow(unused_mut)]
let mut object_274 = array_272.value().start_object();
crate::json_ser::serialize_structure_crate_model_data_lake_principal(
&mut object_274,
item_273,
)?;
object_274.finish();
}
}
array_272.finish();
}
if let Some(var_275) = &input.create_database_default_permissions {
let mut array_276 = object.key("CreateDatabaseDefaultPermissions").start_array();
for item_277 in var_275 {
{
#[allow(unused_mut)]
let mut object_278 = array_276.value().start_object();
crate::json_ser::serialize_structure_crate_model_principal_permissions(
&mut object_278,
item_277,
)?;
object_278.finish();
}
}
array_276.finish();
}
if let Some(var_279) = &input.create_table_default_permissions {
let mut array_280 = object.key("CreateTableDefaultPermissions").start_array();
for item_281 in var_279 {
{
#[allow(unused_mut)]
let mut object_282 = array_280.value().start_object();
crate::json_ser::serialize_structure_crate_model_principal_permissions(
&mut object_282,
item_281,
)?;
object_282.finish();
}
}
array_280.finish();
}
if let Some(var_283) = &input.parameters {
#[allow(unused_mut)]
let mut object_284 = object.key("Parameters").start_object();
for (key_285, value_286) in var_283 {
{
object_284.key(key_285.as_str()).string(value_286.as_str());
}
}
object_284.finish();
}
if let Some(var_287) = &input.trusted_resource_owners {
let mut array_288 = object.key("TrustedResourceOwners").start_array();
for item_289 in var_287 {
{
array_288.value().string(item_289.as_str());
}
}
array_288.finish();
}
if let Some(var_290) = &input.allow_external_data_filtering {
object.key("AllowExternalDataFiltering").boolean(*var_290);
}
if let Some(var_291) = &input.external_data_filtering_allow_list {
let mut array_292 = object.key("ExternalDataFilteringAllowList").start_array();
for item_293 in var_291 {
{
#[allow(unused_mut)]
let mut object_294 = array_292.value().start_object();
crate::json_ser::serialize_structure_crate_model_data_lake_principal(
&mut object_294,
item_293,
)?;
object_294.finish();
}
}
array_292.finish();
}
if let Some(var_295) = &input.authorized_session_tag_value_list {
let mut array_296 = object.key("AuthorizedSessionTagValueList").start_array();
for item_297 in var_295 {
{
array_296.value().string(item_297.as_str());
}
}
array_296.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_lf_tag(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LfTag,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_298) = &input.tag_key {
object.key("TagKey").string(var_298.as_str());
}
if let Some(var_299) = &input.tag_values {
let mut array_300 = object.key("TagValues").start_array();
for item_301 in var_299 {
{
array_300.value().string(item_301.as_str());
}
}
array_300.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_query_planning_context(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::QueryPlanningContext,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_302) = &input.catalog_id {
object.key("CatalogId").string(var_302.as_str());
}
if let Some(var_303) = &input.database_name {
object.key("DatabaseName").string(var_303.as_str());
}
if let Some(var_304) = &input.query_as_of_time {
object
.key("QueryAsOfTime")
.date_time(var_304, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_305) = &input.query_parameters {
#[allow(unused_mut)]
let mut object_306 = object.key("QueryParameters").start_object();
for (key_307, value_308) in var_305 {
{
object_306.key(key_307.as_str()).string(value_308.as_str());
}
}
object_306.finish();
}
if let Some(var_309) = &input.transaction_id {
object.key("TransactionId").string(var_309.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_write_operation(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::WriteOperation,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_310) = &input.add_object {
#[allow(unused_mut)]
let mut object_311 = object.key("AddObject").start_object();
crate::json_ser::serialize_structure_crate_model_add_object_input(
&mut object_311,
var_310,
)?;
object_311.finish();
}
if let Some(var_312) = &input.delete_object {
#[allow(unused_mut)]
let mut object_313 = object.key("DeleteObject").start_object();
crate::json_ser::serialize_structure_crate_model_delete_object_input(
&mut object_313,
var_312,
)?;
object_313.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_catalog_resource(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CatalogResource,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
let (_, _) = (object, input);
Ok(())
}
pub fn serialize_structure_crate_model_database_resource(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DatabaseResource,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_314) = &input.catalog_id {
object.key("CatalogId").string(var_314.as_str());
}
if let Some(var_315) = &input.name {
object.key("Name").string(var_315.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_table_with_columns_resource(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TableWithColumnsResource,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_316) = &input.catalog_id {
object.key("CatalogId").string(var_316.as_str());
}
if let Some(var_317) = &input.database_name {
object.key("DatabaseName").string(var_317.as_str());
}
if let Some(var_318) = &input.name {
object.key("Name").string(var_318.as_str());
}
if let Some(var_319) = &input.column_names {
let mut array_320 = object.key("ColumnNames").start_array();
for item_321 in var_319 {
{
array_320.value().string(item_321.as_str());
}
}
array_320.finish();
}
if let Some(var_322) = &input.column_wildcard {
#[allow(unused_mut)]
let mut object_323 = object.key("ColumnWildcard").start_object();
crate::json_ser::serialize_structure_crate_model_column_wildcard(&mut object_323, var_322)?;
object_323.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_data_location_resource(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DataLocationResource,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_324) = &input.catalog_id {
object.key("CatalogId").string(var_324.as_str());
}
if let Some(var_325) = &input.resource_arn {
object.key("ResourceArn").string(var_325.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_data_cells_filter_resource(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DataCellsFilterResource,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_326) = &input.table_catalog_id {
object.key("TableCatalogId").string(var_326.as_str());
}
if let Some(var_327) = &input.database_name {
object.key("DatabaseName").string(var_327.as_str());
}
if let Some(var_328) = &input.table_name {
object.key("TableName").string(var_328.as_str());
}
if let Some(var_329) = &input.name {
object.key("Name").string(var_329.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_lf_tag_key_resource(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LfTagKeyResource,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_330) = &input.catalog_id {
object.key("CatalogId").string(var_330.as_str());
}
if let Some(var_331) = &input.tag_key {
object.key("TagKey").string(var_331.as_str());
}
if let Some(var_332) = &input.tag_values {
let mut array_333 = object.key("TagValues").start_array();
for item_334 in var_332 {
{
array_333.value().string(item_334.as_str());
}
}
array_333.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_lf_tag_policy_resource(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LfTagPolicyResource,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_335) = &input.catalog_id {
object.key("CatalogId").string(var_335.as_str());
}
if let Some(var_336) = &input.resource_type {
object.key("ResourceType").string(var_336.as_str());
}
if let Some(var_337) = &input.expression {
let mut array_338 = object.key("Expression").start_array();
for item_339 in var_337 {
{
#[allow(unused_mut)]
let mut object_340 = array_338.value().start_object();
crate::json_ser::serialize_structure_crate_model_lf_tag(&mut object_340, item_339)?;
object_340.finish();
}
}
array_338.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_row_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RowFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_341) = &input.filter_expression {
object.key("FilterExpression").string(var_341.as_str());
}
if let Some(var_342) = &input.all_rows_wildcard {
#[allow(unused_mut)]
let mut object_343 = object.key("AllRowsWildcard").start_object();
crate::json_ser::serialize_structure_crate_model_all_rows_wildcard(
&mut object_343,
var_342,
)?;
object_343.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_column_wildcard(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ColumnWildcard,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_344) = &input.excluded_column_names {
let mut array_345 = object.key("ExcludedColumnNames").start_array();
for item_346 in var_344 {
{
array_345.value().string(item_346.as_str());
}
}
array_345.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_table_wildcard(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TableWildcard,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
let (_, _) = (object, input);
Ok(())
}
pub fn serialize_structure_crate_model_principal_permissions(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PrincipalPermissions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_347) = &input.principal {
#[allow(unused_mut)]
let mut object_348 = object.key("Principal").start_object();
crate::json_ser::serialize_structure_crate_model_data_lake_principal(
&mut object_348,
var_347,
)?;
object_348.finish();
}
if let Some(var_349) = &input.permissions {
let mut array_350 = object.key("Permissions").start_array();
for item_351 in var_349 {
{
array_350.value().string(item_351.as_str());
}
}
array_350.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_add_object_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AddObjectInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_352) = &input.uri {
object.key("Uri").string(var_352.as_str());
}
if let Some(var_353) = &input.e_tag {
object.key("ETag").string(var_353.as_str());
}
{
object.key("Size").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.size).into()),
);
}
if let Some(var_354) = &input.partition_values {
let mut array_355 = object.key("PartitionValues").start_array();
for item_356 in var_354 {
{
array_355.value().string(item_356.as_str());
}
}
array_355.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_delete_object_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DeleteObjectInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_357) = &input.uri {
object.key("Uri").string(var_357.as_str());
}
if let Some(var_358) = &input.e_tag {
object.key("ETag").string(var_358.as_str());
}
if let Some(var_359) = &input.partition_values {
let mut array_360 = object.key("PartitionValues").start_array();
for item_361 in var_359 {
{
array_360.value().string(item_361.as_str());
}
}
array_360.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_all_rows_wildcard(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AllRowsWildcard,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
let (_, _) = (object, input);
Ok(())
}