pub fn serialize_structure_crate_input_batch_get_schema_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchGetSchemaInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.names {
let mut array_2 = object.key("names").start_array();
for item_3 in var_1 {
{
array_2.value().string(item_3.as_str());
}
}
array_2.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_collaboration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateCollaborationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_4) = &input.creator_display_name {
object.key("creatorDisplayName").string(var_4.as_str());
}
if let Some(var_5) = &input.creator_member_abilities {
let mut array_6 = object.key("creatorMemberAbilities").start_array();
for item_7 in var_5 {
{
array_6.value().string(item_7.as_str());
}
}
array_6.finish();
}
if let Some(var_8) = &input.data_encryption_metadata {
#[allow(unused_mut)]
let mut object_9 = object.key("dataEncryptionMetadata").start_object();
crate::json_ser::serialize_structure_crate_model_data_encryption_metadata(
&mut object_9,
var_8,
)?;
object_9.finish();
}
if let Some(var_10) = &input.description {
object.key("description").string(var_10.as_str());
}
if let Some(var_11) = &input.members {
let mut array_12 = object.key("members").start_array();
for item_13 in var_11 {
{
#[allow(unused_mut)]
let mut object_14 = array_12.value().start_object();
crate::json_ser::serialize_structure_crate_model_member_specification(
&mut object_14,
item_13,
)?;
object_14.finish();
}
}
array_12.finish();
}
if let Some(var_15) = &input.name {
object.key("name").string(var_15.as_str());
}
if let Some(var_16) = &input.query_log_status {
object.key("queryLogStatus").string(var_16.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_configured_table_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateConfiguredTableInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_17) = &input.allowed_columns {
let mut array_18 = object.key("allowedColumns").start_array();
for item_19 in var_17 {
{
array_18.value().string(item_19.as_str());
}
}
array_18.finish();
}
if let Some(var_20) = &input.analysis_method {
object.key("analysisMethod").string(var_20.as_str());
}
if let Some(var_21) = &input.description {
object.key("description").string(var_21.as_str());
}
if let Some(var_22) = &input.name {
object.key("name").string(var_22.as_str());
}
if let Some(var_23) = &input.table_reference {
#[allow(unused_mut)]
let mut object_24 = object.key("tableReference").start_object();
crate::json_ser::serialize_union_crate_model_table_reference(&mut object_24, var_23)?;
object_24.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_configured_table_analysis_rule_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateConfiguredTableAnalysisRuleInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_25) = &input.analysis_rule_policy {
#[allow(unused_mut)]
let mut object_26 = object.key("analysisRulePolicy").start_object();
crate::json_ser::serialize_union_crate_model_configured_table_analysis_rule_policy(
&mut object_26,
var_25,
)?;
object_26.finish();
}
if let Some(var_27) = &input.analysis_rule_type {
object.key("analysisRuleType").string(var_27.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_configured_table_association_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateConfiguredTableAssociationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_28) = &input.configured_table_identifier {
object
.key("configuredTableIdentifier")
.string(var_28.as_str());
}
if let Some(var_29) = &input.description {
object.key("description").string(var_29.as_str());
}
if let Some(var_30) = &input.name {
object.key("name").string(var_30.as_str());
}
if let Some(var_31) = &input.role_arn {
object.key("roleArn").string(var_31.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_membership_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateMembershipInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_32) = &input.collaboration_identifier {
object
.key("collaborationIdentifier")
.string(var_32.as_str());
}
if let Some(var_33) = &input.query_log_status {
object.key("queryLogStatus").string(var_33.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_start_protected_query_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartProtectedQueryInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_34) = &input.result_configuration {
#[allow(unused_mut)]
let mut object_35 = object.key("resultConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_protected_query_result_configuration(
&mut object_35,
var_34,
)?;
object_35.finish();
}
if let Some(var_36) = &input.sql_parameters {
#[allow(unused_mut)]
let mut object_37 = object.key("sqlParameters").start_object();
crate::json_ser::serialize_structure_crate_model_protected_query_sql_parameters(
&mut object_37,
var_36,
)?;
object_37.finish();
}
if let Some(var_38) = &input.r#type {
object.key("type").string(var_38.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_collaboration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateCollaborationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_39) = &input.description {
object.key("description").string(var_39.as_str());
}
if let Some(var_40) = &input.name {
object.key("name").string(var_40.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_configured_table_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateConfiguredTableInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_41) = &input.description {
object.key("description").string(var_41.as_str());
}
if let Some(var_42) = &input.name {
object.key("name").string(var_42.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_configured_table_analysis_rule_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateConfiguredTableAnalysisRuleInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_43) = &input.analysis_rule_policy {
#[allow(unused_mut)]
let mut object_44 = object.key("analysisRulePolicy").start_object();
crate::json_ser::serialize_union_crate_model_configured_table_analysis_rule_policy(
&mut object_44,
var_43,
)?;
object_44.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_configured_table_association_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateConfiguredTableAssociationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_45) = &input.description {
object.key("description").string(var_45.as_str());
}
if let Some(var_46) = &input.role_arn {
object.key("roleArn").string(var_46.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_membership_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateMembershipInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_47) = &input.query_log_status {
object.key("queryLogStatus").string(var_47.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_protected_query_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateProtectedQueryInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_48) = &input.target_status {
object.key("targetStatus").string(var_48.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_data_encryption_metadata(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DataEncryptionMetadata,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_49) = &input.allow_cleartext {
object.key("allowCleartext").boolean(*var_49);
}
if let Some(var_50) = &input.allow_duplicates {
object.key("allowDuplicates").boolean(*var_50);
}
if let Some(var_51) = &input.allow_joins_on_columns_with_different_names {
object
.key("allowJoinsOnColumnsWithDifferentNames")
.boolean(*var_51);
}
if let Some(var_52) = &input.preserve_nulls {
object.key("preserveNulls").boolean(*var_52);
}
Ok(())
}
pub fn serialize_structure_crate_model_member_specification(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MemberSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_53) = &input.account_id {
object.key("accountId").string(var_53.as_str());
}
if let Some(var_54) = &input.member_abilities {
let mut array_55 = object.key("memberAbilities").start_array();
for item_56 in var_54 {
{
array_55.value().string(item_56.as_str());
}
}
array_55.finish();
}
if let Some(var_57) = &input.display_name {
object.key("displayName").string(var_57.as_str());
}
Ok(())
}
pub fn serialize_union_crate_model_table_reference(
object_24: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TableReference,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
match input {
crate::model::TableReference::Glue(inner) => {
#[allow(unused_mut)]
let mut object_58 = object_24.key("glue").start_object();
crate::json_ser::serialize_structure_crate_model_glue_table_reference(
&mut object_58,
inner,
)?;
object_58.finish();
}
crate::model::TableReference::Unknown => {
return Err(
aws_smithy_http::operation::error::SerializationError::unknown_variant(
"TableReference",
),
)
}
}
Ok(())
}
pub fn serialize_union_crate_model_configured_table_analysis_rule_policy(
object_26: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ConfiguredTableAnalysisRulePolicy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
match input {
crate::model::ConfiguredTableAnalysisRulePolicy::V1(inner) => {
#[allow(unused_mut)]
let mut object_59 = object_26.key("v1").start_object();
crate::json_ser::serialize_union_crate_model_configured_table_analysis_rule_policy_v1(
&mut object_59,
inner,
)?;
object_59.finish();
}
crate::model::ConfiguredTableAnalysisRulePolicy::Unknown => {
return Err(
aws_smithy_http::operation::error::SerializationError::unknown_variant(
"ConfiguredTableAnalysisRulePolicy",
),
)
}
}
Ok(())
}
pub fn serialize_structure_crate_model_protected_query_result_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ProtectedQueryResultConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_60) = &input.output_configuration {
#[allow(unused_mut)]
let mut object_61 = object.key("outputConfiguration").start_object();
crate::json_ser::serialize_union_crate_model_protected_query_output_configuration(
&mut object_61,
var_60,
)?;
object_61.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_protected_query_sql_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ProtectedQuerySqlParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_62) = &input.query_string {
object.key("queryString").string(var_62.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_glue_table_reference(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::GlueTableReference,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_63) = &input.table_name {
object.key("tableName").string(var_63.as_str());
}
if let Some(var_64) = &input.database_name {
object.key("databaseName").string(var_64.as_str());
}
Ok(())
}
pub fn serialize_union_crate_model_configured_table_analysis_rule_policy_v1(
object_59: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ConfiguredTableAnalysisRulePolicyV1,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
match input {
crate::model::ConfiguredTableAnalysisRulePolicyV1::List(inner) => {
#[allow(unused_mut)]
let mut object_65 = object_59.key("list").start_object();
crate::json_ser::serialize_structure_crate_model_analysis_rule_list(
&mut object_65,
inner,
)?;
object_65.finish();
}
crate::model::ConfiguredTableAnalysisRulePolicyV1::Aggregation(inner) => {
#[allow(unused_mut)]
let mut object_66 = object_59.key("aggregation").start_object();
crate::json_ser::serialize_structure_crate_model_analysis_rule_aggregation(
&mut object_66,
inner,
)?;
object_66.finish();
}
crate::model::ConfiguredTableAnalysisRulePolicyV1::Unknown => {
return Err(
aws_smithy_http::operation::error::SerializationError::unknown_variant(
"ConfiguredTableAnalysisRulePolicyV1",
),
)
}
}
Ok(())
}
pub fn serialize_union_crate_model_protected_query_output_configuration(
object_61: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ProtectedQueryOutputConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
match input {
crate::model::ProtectedQueryOutputConfiguration::S3(inner) => {
#[allow(unused_mut)]
let mut object_67 = object_61.key("s3").start_object();
crate::json_ser::serialize_structure_crate_model_protected_query_s3_output_configuration(&mut object_67, inner)?;
object_67.finish();
}
crate::model::ProtectedQueryOutputConfiguration::Unknown => {
return Err(
aws_smithy_http::operation::error::SerializationError::unknown_variant(
"ProtectedQueryOutputConfiguration",
),
)
}
}
Ok(())
}
pub fn serialize_structure_crate_model_analysis_rule_list(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AnalysisRuleList,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_68) = &input.join_columns {
let mut array_69 = object.key("joinColumns").start_array();
for item_70 in var_68 {
{
array_69.value().string(item_70.as_str());
}
}
array_69.finish();
}
if let Some(var_71) = &input.list_columns {
let mut array_72 = object.key("listColumns").start_array();
for item_73 in var_71 {
{
array_72.value().string(item_73.as_str());
}
}
array_72.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_analysis_rule_aggregation(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AnalysisRuleAggregation,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_74) = &input.aggregate_columns {
let mut array_75 = object.key("aggregateColumns").start_array();
for item_76 in var_74 {
{
#[allow(unused_mut)]
let mut object_77 = array_75.value().start_object();
crate::json_ser::serialize_structure_crate_model_aggregate_column(
&mut object_77,
item_76,
)?;
object_77.finish();
}
}
array_75.finish();
}
if let Some(var_78) = &input.join_columns {
let mut array_79 = object.key("joinColumns").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.join_required {
object.key("joinRequired").string(var_81.as_str());
}
if let Some(var_82) = &input.dimension_columns {
let mut array_83 = object.key("dimensionColumns").start_array();
for item_84 in var_82 {
{
array_83.value().string(item_84.as_str());
}
}
array_83.finish();
}
if let Some(var_85) = &input.scalar_functions {
let mut array_86 = object.key("scalarFunctions").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.output_constraints {
let mut array_89 = object.key("outputConstraints").start_array();
for item_90 in var_88 {
{
#[allow(unused_mut)]
let mut object_91 = array_89.value().start_object();
crate::json_ser::serialize_structure_crate_model_aggregation_constraint(
&mut object_91,
item_90,
)?;
object_91.finish();
}
}
array_89.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_protected_query_s3_output_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ProtectedQueryS3OutputConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_92) = &input.result_format {
object.key("resultFormat").string(var_92.as_str());
}
if let Some(var_93) = &input.bucket {
object.key("bucket").string(var_93.as_str());
}
if let Some(var_94) = &input.key_prefix {
object.key("keyPrefix").string(var_94.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aggregate_column(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AggregateColumn,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_95) = &input.column_names {
let mut array_96 = object.key("columnNames").start_array();
for item_97 in var_95 {
{
array_96.value().string(item_97.as_str());
}
}
array_96.finish();
}
if let Some(var_98) = &input.function {
object.key("function").string(var_98.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aggregation_constraint(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AggregationConstraint,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_99) = &input.column_name {
object.key("columnName").string(var_99.as_str());
}
if let Some(var_100) = &input.minimum {
object.key("minimum").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_100).into()),
);
}
if let Some(var_101) = &input.r#type {
object.key("type").string(var_101.as_str());
}
Ok(())
}