#[allow(unused_imports)]
use super::*;
#[doc(hidden)]
impl serde::ser::Serialize for super::ArrowSchema {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.serialized_schema.is_empty() {
struct __With<'a>(&'a ::bytes::Bytes);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<serde_with::base64::Base64>::serialize(self.0, serializer)
}
}
state.serialize_entry("serializedSchema", &__With(&self.serialized_schema))?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::ArrowRecordBatch {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.serialized_record_batch.is_empty() {
struct __With<'a>(&'a ::bytes::Bytes);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<serde_with::base64::Base64>::serialize(self.0, serializer)
}
}
state.serialize_entry(
"serializedRecordBatch",
&__With(&self.serialized_record_batch),
)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::ArrowSerializationOptions {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !wkt::internal::is_default(&self.buffer_compression) {
state.serialize_entry("bufferCompression", &self.buffer_compression)?;
}
if !wkt::internal::is_default(&self.picos_timestamp_precision) {
state.serialize_entry("picosTimestampPrecision", &self.picos_timestamp_precision)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::BigLakeConfiguration {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.connection_id.is_empty() {
state.serialize_entry("connectionId", &self.connection_id)?;
}
if !self.storage_uri.is_empty() {
state.serialize_entry("storageUri", &self.storage_uri)?;
}
if !wkt::internal::is_default(&self.file_format) {
state.serialize_entry("fileFormat", &self.file_format)?;
}
if !wkt::internal::is_default(&self.table_format) {
state.serialize_entry("tableFormat", &self.table_format)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::Clustering {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.fields.is_empty() {
state.serialize_entry("fields", &self.fields)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::DataFormatOptions {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !wkt::internal::is_default(&self.use_int64_timestamp) {
state.serialize_entry("useInt64Timestamp", &self.use_int64_timestamp)?;
}
if !wkt::internal::is_default(&self.timestamp_output_format) {
state.serialize_entry("timestampOutputFormat", &self.timestamp_output_format)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::DatasetAccessEntry {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.dataset.is_some() {
state.serialize_entry("dataset", &self.dataset)?;
}
if !self.target_types.is_empty() {
state.serialize_entry("targetTypes", &self.target_types)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::Access {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.role.is_empty() {
state.serialize_entry("role", &self.role)?;
}
if !self.user_by_email.is_empty() {
state.serialize_entry("userByEmail", &self.user_by_email)?;
}
if !self.group_by_email.is_empty() {
state.serialize_entry("groupByEmail", &self.group_by_email)?;
}
if !self.domain.is_empty() {
state.serialize_entry("domain", &self.domain)?;
}
if !self.special_group.is_empty() {
state.serialize_entry("specialGroup", &self.special_group)?;
}
if !self.iam_member.is_empty() {
state.serialize_entry("iamMember", &self.iam_member)?;
}
if self.view.is_some() {
state.serialize_entry("view", &self.view)?;
}
if self.routine.is_some() {
state.serialize_entry("routine", &self.routine)?;
}
if self.dataset.is_some() {
state.serialize_entry("dataset", &self.dataset)?;
}
if self.condition.is_some() {
state.serialize_entry("condition", &self.condition)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::Dataset {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.kind.is_empty() {
state.serialize_entry("kind", &self.kind)?;
}
if !self.etag.is_empty() {
state.serialize_entry("etag", &self.etag)?;
}
if !self.id.is_empty() {
state.serialize_entry("id", &self.id)?;
}
if !self.self_link.is_empty() {
state.serialize_entry("selfLink", &self.self_link)?;
}
if self.dataset_reference.is_some() {
state.serialize_entry("datasetReference", &self.dataset_reference)?;
}
if self.friendly_name.is_some() {
state.serialize_entry("friendlyName", &self.friendly_name)?;
}
if self.description.is_some() {
state.serialize_entry("description", &self.description)?;
}
if self.default_table_expiration_ms.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry(
"defaultTableExpirationMs",
&__With(&self.default_table_expiration_ms),
)?;
}
if self.default_partition_expiration_ms.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry(
"defaultPartitionExpirationMs",
&__With(&self.default_partition_expiration_ms),
)?;
}
if !self.labels.is_empty() {
state.serialize_entry("labels", &self.labels)?;
}
if !self.access.is_empty() {
state.serialize_entry("access", &self.access)?;
}
if !wkt::internal::is_default(&self.creation_time) {
struct __With<'a>(&'a i64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
}
}
state.serialize_entry("creationTime", &__With(&self.creation_time))?;
}
if !wkt::internal::is_default(&self.last_modified_time) {
struct __With<'a>(&'a i64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
}
}
state.serialize_entry("lastModifiedTime", &__With(&self.last_modified_time))?;
}
if !self.location.is_empty() {
state.serialize_entry("location", &self.location)?;
}
if self.default_encryption_configuration.is_some() {
state.serialize_entry(
"defaultEncryptionConfiguration",
&self.default_encryption_configuration,
)?;
}
if self.satisfies_pzs.is_some() {
state.serialize_entry("satisfiesPzs", &self.satisfies_pzs)?;
}
if self.satisfies_pzi.is_some() {
state.serialize_entry("satisfiesPzi", &self.satisfies_pzi)?;
}
if !self.r#type.is_empty() {
state.serialize_entry("type", &self.r#type)?;
}
if self.catalog_source.is_some() {
state.serialize_entry("catalogSource", &self.catalog_source)?;
}
if self.linked_dataset_source.is_some() {
state.serialize_entry("linkedDatasetSource", &self.linked_dataset_source)?;
}
if self.linked_dataset_metadata.is_some() {
state.serialize_entry("linkedDatasetMetadata", &self.linked_dataset_metadata)?;
}
if self.external_dataset_reference.is_some() {
state.serialize_entry("externalDatasetReference", &self.external_dataset_reference)?;
}
if self.external_catalog_dataset_options.is_some() {
state.serialize_entry(
"externalCatalogDatasetOptions",
&self.external_catalog_dataset_options,
)?;
}
if self.is_case_insensitive.is_some() {
state.serialize_entry("isCaseInsensitive", &self.is_case_insensitive)?;
}
if self.default_collation.is_some() {
state.serialize_entry("defaultCollation", &self.default_collation)?;
}
if !wkt::internal::is_default(&self.default_rounding_mode) {
state.serialize_entry("defaultRoundingMode", &self.default_rounding_mode)?;
}
if self.max_time_travel_hours.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("maxTimeTravelHours", &__With(&self.max_time_travel_hours))?;
}
if !self.tags.is_empty() {
state.serialize_entry("tags", &self.tags)?;
}
if !wkt::internal::is_default(&self.storage_billing_model) {
state.serialize_entry("storageBillingModel", &self.storage_billing_model)?;
}
if self.restrictions.is_some() {
state.serialize_entry("restrictions", &self.restrictions)?;
}
if !self.resource_tags.is_empty() {
state.serialize_entry("resourceTags", &self.resource_tags)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::GcpTag {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.tag_key.is_empty() {
state.serialize_entry("tagKey", &self.tag_key)?;
}
if !self.tag_value.is_empty() {
state.serialize_entry("tagValue", &self.tag_value)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::LinkedDatasetSource {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.source_dataset.is_some() {
state.serialize_entry("sourceDataset", &self.source_dataset)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::LinkedDatasetMetadata {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !wkt::internal::is_default(&self.link_state) {
state.serialize_entry("linkState", &self.link_state)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::GetDatasetRequest {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.project_id.is_empty() {
state.serialize_entry("projectId", &self.project_id)?;
}
if !self.dataset_id.is_empty() {
state.serialize_entry("datasetId", &self.dataset_id)?;
}
if !wkt::internal::is_default(&self.dataset_view) {
state.serialize_entry("datasetView", &self.dataset_view)?;
}
if !wkt::internal::is_default(&self.access_policy_version) {
struct __With<'a>(&'a i32);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
}
}
state.serialize_entry("accessPolicyVersion", &__With(&self.access_policy_version))?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::InsertDatasetRequest {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.project_id.is_empty() {
state.serialize_entry("projectId", &self.project_id)?;
}
if self.dataset.is_some() {
state.serialize_entry("dataset", &self.dataset)?;
}
if !wkt::internal::is_default(&self.access_policy_version) {
struct __With<'a>(&'a i32);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
}
}
state.serialize_entry("accessPolicyVersion", &__With(&self.access_policy_version))?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::UpdateOrPatchDatasetRequest {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.project_id.is_empty() {
state.serialize_entry("projectId", &self.project_id)?;
}
if !self.dataset_id.is_empty() {
state.serialize_entry("datasetId", &self.dataset_id)?;
}
if self.dataset.is_some() {
state.serialize_entry("dataset", &self.dataset)?;
}
if !wkt::internal::is_default(&self.update_mode) {
state.serialize_entry("updateMode", &self.update_mode)?;
}
if !wkt::internal::is_default(&self.access_policy_version) {
struct __With<'a>(&'a i32);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
}
}
state.serialize_entry("accessPolicyVersion", &__With(&self.access_policy_version))?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::DeleteDatasetRequest {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.project_id.is_empty() {
state.serialize_entry("projectId", &self.project_id)?;
}
if !self.dataset_id.is_empty() {
state.serialize_entry("datasetId", &self.dataset_id)?;
}
if !wkt::internal::is_default(&self.delete_contents) {
state.serialize_entry("deleteContents", &self.delete_contents)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::ListDatasetsRequest {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.project_id.is_empty() {
state.serialize_entry("projectId", &self.project_id)?;
}
if self.max_results.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::UInt32Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::U32>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("maxResults", &__With(&self.max_results))?;
}
if !self.page_token.is_empty() {
state.serialize_entry("pageToken", &self.page_token)?;
}
if !wkt::internal::is_default(&self.all) {
state.serialize_entry("all", &self.all)?;
}
if !self.filter.is_empty() {
state.serialize_entry("filter", &self.filter)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::ListFormatDataset {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.kind.is_empty() {
state.serialize_entry("kind", &self.kind)?;
}
if !self.id.is_empty() {
state.serialize_entry("id", &self.id)?;
}
if self.dataset_reference.is_some() {
state.serialize_entry("datasetReference", &self.dataset_reference)?;
}
if !self.labels.is_empty() {
state.serialize_entry("labels", &self.labels)?;
}
if self.friendly_name.is_some() {
state.serialize_entry("friendlyName", &self.friendly_name)?;
}
if !self.location.is_empty() {
state.serialize_entry("location", &self.location)?;
}
if !self.r#type.is_empty() {
state.serialize_entry("type", &self.r#type)?;
}
if self.catalog_source.is_some() {
state.serialize_entry("catalogSource", &self.catalog_source)?;
}
if self.external_dataset_reference.is_some() {
state.serialize_entry("externalDatasetReference", &self.external_dataset_reference)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::DatasetList {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.kind.is_empty() {
state.serialize_entry("kind", &self.kind)?;
}
if !self.etag.is_empty() {
state.serialize_entry("etag", &self.etag)?;
}
if !self.next_page_token.is_empty() {
state.serialize_entry("nextPageToken", &self.next_page_token)?;
}
if !self.datasets.is_empty() {
state.serialize_entry("datasets", &self.datasets)?;
}
if !self.unreachable.is_empty() {
state.serialize_entry("unreachable", &self.unreachable)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::UndeleteDatasetRequest {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.project_id.is_empty() {
state.serialize_entry("projectId", &self.project_id)?;
}
if !self.dataset_id.is_empty() {
state.serialize_entry("datasetId", &self.dataset_id)?;
}
if self.deletion_time.is_some() {
state.serialize_entry("deletionTime", &self.deletion_time)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::DatasetReference {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.dataset_id.is_empty() {
state.serialize_entry("datasetId", &self.dataset_id)?;
}
if !self.project_id.is_empty() {
state.serialize_entry("projectId", &self.project_id)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::EncryptionConfiguration {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.kms_key_name.is_some() {
state.serialize_entry("kmsKeyName", &self.kms_key_name)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::ErrorProto {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.reason.is_empty() {
state.serialize_entry("reason", &self.reason)?;
}
if !self.location.is_empty() {
state.serialize_entry("location", &self.location)?;
}
if !self.debug_info.is_empty() {
state.serialize_entry("debugInfo", &self.debug_info)?;
}
if !self.message.is_empty() {
state.serialize_entry("message", &self.message)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::ExternalCatalogDatasetOptions {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.parameters.is_empty() {
state.serialize_entry("parameters", &self.parameters)?;
}
if !self.default_storage_location_uri.is_empty() {
state.serialize_entry(
"defaultStorageLocationUri",
&self.default_storage_location_uri,
)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::ExternalCatalogTableOptions {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.parameters.is_empty() {
state.serialize_entry("parameters", &self.parameters)?;
}
if self.storage_descriptor.is_some() {
state.serialize_entry("storageDescriptor", &self.storage_descriptor)?;
}
if !self.connection_id.is_empty() {
state.serialize_entry("connectionId", &self.connection_id)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::StorageDescriptor {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.location_uri.is_empty() {
state.serialize_entry("locationUri", &self.location_uri)?;
}
if !self.input_format.is_empty() {
state.serialize_entry("inputFormat", &self.input_format)?;
}
if !self.output_format.is_empty() {
state.serialize_entry("outputFormat", &self.output_format)?;
}
if self.serde_info.is_some() {
state.serialize_entry("serdeInfo", &self.serde_info)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::SerDeInfo {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.name.is_empty() {
state.serialize_entry("name", &self.name)?;
}
if !self.serialization_library.is_empty() {
state.serialize_entry("serializationLibrary", &self.serialization_library)?;
}
if !self.parameters.is_empty() {
state.serialize_entry("parameters", &self.parameters)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::AvroOptions {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.use_avro_logical_types.is_some() {
state.serialize_entry("useAvroLogicalTypes", &self.use_avro_logical_types)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::ParquetOptions {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.enum_as_string.is_some() {
state.serialize_entry("enumAsString", &self.enum_as_string)?;
}
if self.enable_list_inference.is_some() {
state.serialize_entry("enableListInference", &self.enable_list_inference)?;
}
if !wkt::internal::is_default(&self.map_target_type) {
state.serialize_entry("mapTargetType", &self.map_target_type)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::CsvOptions {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.field_delimiter.is_empty() {
state.serialize_entry("fieldDelimiter", &self.field_delimiter)?;
}
if self.skip_leading_rows.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("skipLeadingRows", &__With(&self.skip_leading_rows))?;
}
if self.quote.is_some() {
state.serialize_entry("quote", &self.quote)?;
}
if self.allow_quoted_newlines.is_some() {
state.serialize_entry("allowQuotedNewlines", &self.allow_quoted_newlines)?;
}
if self.allow_jagged_rows.is_some() {
state.serialize_entry("allowJaggedRows", &self.allow_jagged_rows)?;
}
if !self.encoding.is_empty() {
state.serialize_entry("encoding", &self.encoding)?;
}
if self.preserve_ascii_control_characters.is_some() {
state.serialize_entry(
"preserveAsciiControlCharacters",
&self.preserve_ascii_control_characters,
)?;
}
if self.null_marker.is_some() {
state.serialize_entry("nullMarker", &self.null_marker)?;
}
if !self.null_markers.is_empty() {
state.serialize_entry("nullMarkers", &self.null_markers)?;
}
if !self.source_column_match.is_empty() {
state.serialize_entry("sourceColumnMatch", &self.source_column_match)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::JsonOptions {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.encoding.is_empty() {
state.serialize_entry("encoding", &self.encoding)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::BigtableProtoConfig {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.schema_bundle_id.is_empty() {
state.serialize_entry("schemaBundleId", &self.schema_bundle_id)?;
}
if !self.proto_message_name.is_empty() {
state.serialize_entry("protoMessageName", &self.proto_message_name)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::BigtableColumn {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.qualifier_encoded.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::BytesValue>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<serde_with::base64::Base64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("qualifierEncoded", &__With(&self.qualifier_encoded))?;
}
if self.qualifier_string.is_some() {
state.serialize_entry("qualifierString", &self.qualifier_string)?;
}
if !self.field_name.is_empty() {
state.serialize_entry("fieldName", &self.field_name)?;
}
if !self.r#type.is_empty() {
state.serialize_entry("type", &self.r#type)?;
}
if !self.encoding.is_empty() {
state.serialize_entry("encoding", &self.encoding)?;
}
if self.only_read_latest.is_some() {
state.serialize_entry("onlyReadLatest", &self.only_read_latest)?;
}
if self.proto_config.is_some() {
state.serialize_entry("protoConfig", &self.proto_config)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::BigtableColumnFamily {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.family_id.is_empty() {
state.serialize_entry("familyId", &self.family_id)?;
}
if !self.r#type.is_empty() {
state.serialize_entry("type", &self.r#type)?;
}
if !self.encoding.is_empty() {
state.serialize_entry("encoding", &self.encoding)?;
}
if !self.columns.is_empty() {
state.serialize_entry("columns", &self.columns)?;
}
if self.only_read_latest.is_some() {
state.serialize_entry("onlyReadLatest", &self.only_read_latest)?;
}
if self.proto_config.is_some() {
state.serialize_entry("protoConfig", &self.proto_config)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::BigtableOptions {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.column_families.is_empty() {
state.serialize_entry("columnFamilies", &self.column_families)?;
}
if self.ignore_unspecified_column_families.is_some() {
state.serialize_entry(
"ignoreUnspecifiedColumnFamilies",
&self.ignore_unspecified_column_families,
)?;
}
if self.read_rowkey_as_string.is_some() {
state.serialize_entry("readRowkeyAsString", &self.read_rowkey_as_string)?;
}
if self.output_column_families_as_json.is_some() {
state.serialize_entry(
"outputColumnFamiliesAsJson",
&self.output_column_families_as_json,
)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::GoogleSheetsOptions {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.skip_leading_rows.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("skipLeadingRows", &__With(&self.skip_leading_rows))?;
}
if !self.range.is_empty() {
state.serialize_entry("range", &self.range)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::ExternalDataConfiguration {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.source_uris.is_empty() {
state.serialize_entry("sourceUris", &self.source_uris)?;
}
if !wkt::internal::is_default(&self.file_set_spec_type) {
state.serialize_entry("fileSetSpecType", &self.file_set_spec_type)?;
}
if self.schema.is_some() {
state.serialize_entry("schema", &self.schema)?;
}
if !self.source_format.is_empty() {
state.serialize_entry("sourceFormat", &self.source_format)?;
}
if self.max_bad_records.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int32Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I32>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("maxBadRecords", &__With(&self.max_bad_records))?;
}
if self.autodetect.is_some() {
state.serialize_entry("autodetect", &self.autodetect)?;
}
if self.ignore_unknown_values.is_some() {
state.serialize_entry("ignoreUnknownValues", &self.ignore_unknown_values)?;
}
if !self.compression.is_empty() {
state.serialize_entry("compression", &self.compression)?;
}
if self.csv_options.is_some() {
state.serialize_entry("csvOptions", &self.csv_options)?;
}
if self.json_options.is_some() {
state.serialize_entry("jsonOptions", &self.json_options)?;
}
if self.bigtable_options.is_some() {
state.serialize_entry("bigtableOptions", &self.bigtable_options)?;
}
if self.google_sheets_options.is_some() {
state.serialize_entry("googleSheetsOptions", &self.google_sheets_options)?;
}
if self.hive_partitioning_options.is_some() {
state.serialize_entry("hivePartitioningOptions", &self.hive_partitioning_options)?;
}
if !self.connection_id.is_empty() {
state.serialize_entry("connectionId", &self.connection_id)?;
}
if !self.decimal_target_types.is_empty() {
state.serialize_entry("decimalTargetTypes", &self.decimal_target_types)?;
}
if self.avro_options.is_some() {
state.serialize_entry("avroOptions", &self.avro_options)?;
}
if !wkt::internal::is_default(&self.json_extension) {
state.serialize_entry("jsonExtension", &self.json_extension)?;
}
if self.parquet_options.is_some() {
state.serialize_entry("parquetOptions", &self.parquet_options)?;
}
if self.object_metadata.is_some() {
state.serialize_entry("objectMetadata", &self.object_metadata)?;
}
if self.reference_file_schema_uri.is_some() {
state.serialize_entry("referenceFileSchemaUri", &self.reference_file_schema_uri)?;
}
if !wkt::internal::is_default(&self.metadata_cache_mode) {
state.serialize_entry("metadataCacheMode", &self.metadata_cache_mode)?;
}
if self.time_zone.is_some() {
state.serialize_entry("timeZone", &self.time_zone)?;
}
if self.date_format.is_some() {
state.serialize_entry("dateFormat", &self.date_format)?;
}
if self.datetime_format.is_some() {
state.serialize_entry("datetimeFormat", &self.datetime_format)?;
}
if self.time_format.is_some() {
state.serialize_entry("timeFormat", &self.time_format)?;
}
if self.timestamp_format.is_some() {
state.serialize_entry("timestampFormat", &self.timestamp_format)?;
}
if !self.timestamp_target_precision.is_empty() {
struct __With<'a>(&'a std::vec::Vec<i32>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::vec::Vec<wkt::internal::I32>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry(
"timestampTargetPrecision",
&__With(&self.timestamp_target_precision),
)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::ExternalDatasetReference {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.external_source.is_empty() {
state.serialize_entry("externalSource", &self.external_source)?;
}
if !self.connection.is_empty() {
state.serialize_entry("connection", &self.connection)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::GenAiFunctionErrorStats {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.errors.is_empty() {
state.serialize_entry("errors", &self.errors)?;
}
if !wkt::internal::is_default(&self.num_failed_rows) {
struct __With<'a>(&'a i64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
}
}
state.serialize_entry("numFailedRows", &__With(&self.num_failed_rows))?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::GenAiFunctionCostOptimizationStats {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.num_cost_optimized_rows.is_some() {
struct __With<'a>(&'a std::option::Option<i64>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry(
"numCostOptimizedRows",
&__With(&self.num_cost_optimized_rows),
)?;
}
if self.message.is_some() {
state.serialize_entry("message", &self.message)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::GenAiFunctionCacheStats {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.num_cache_hit_rows.is_some() {
struct __With<'a>(&'a std::option::Option<i64>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("numCacheHitRows", &__With(&self.num_cache_hit_rows))?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::GenAiFunctionStats {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.function_name.is_some() {
state.serialize_entry("functionName", &self.function_name)?;
}
if self.prompt.is_some() {
state.serialize_entry("prompt", &self.prompt)?;
}
if self.num_processed_rows.is_some() {
struct __With<'a>(&'a std::option::Option<i64>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("numProcessedRows", &__With(&self.num_processed_rows))?;
}
if self.error_stats.is_some() {
state.serialize_entry("errorStats", &self.error_stats)?;
}
if self.cost_optimization_stats.is_some() {
state.serialize_entry("costOptimizationStats", &self.cost_optimization_stats)?;
}
if self.cache_stats.is_some() {
state.serialize_entry("cacheStats", &self.cache_stats)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::GenAiErrorStats {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.errors.is_empty() {
state.serialize_entry("errors", &self.errors)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::GenAiStats {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.error_stats.is_some() {
state.serialize_entry("errorStats", &self.error_stats)?;
}
if !self.function_stats.is_empty() {
state.serialize_entry("functionStats", &self.function_stats)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::HivePartitioningOptions {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.mode.is_empty() {
state.serialize_entry("mode", &self.mode)?;
}
if !self.source_uri_prefix.is_empty() {
state.serialize_entry("sourceUriPrefix", &self.source_uri_prefix)?;
}
if self.require_partition_filter.is_some() {
state.serialize_entry("requirePartitionFilter", &self.require_partition_filter)?;
}
if !self.fields.is_empty() {
state.serialize_entry("fields", &self.fields)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::Job {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.kind.is_empty() {
state.serialize_entry("kind", &self.kind)?;
}
if !self.etag.is_empty() {
state.serialize_entry("etag", &self.etag)?;
}
if !self.id.is_empty() {
state.serialize_entry("id", &self.id)?;
}
if !self.self_link.is_empty() {
state.serialize_entry("selfLink", &self.self_link)?;
}
if !self.user_email.is_empty() {
state.serialize_entry("user_email", &self.user_email)?;
}
if self.configuration.is_some() {
state.serialize_entry("configuration", &self.configuration)?;
}
if self.job_reference.is_some() {
state.serialize_entry("jobReference", &self.job_reference)?;
}
if self.statistics.is_some() {
state.serialize_entry("statistics", &self.statistics)?;
}
if self.status.is_some() {
state.serialize_entry("status", &self.status)?;
}
if !self.principal_subject.is_empty() {
state.serialize_entry("principal_subject", &self.principal_subject)?;
}
if self.job_creation_reason.is_some() {
state.serialize_entry("jobCreationReason", &self.job_creation_reason)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::CancelJobRequest {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.project_id.is_empty() {
state.serialize_entry("projectId", &self.project_id)?;
}
if !self.job_id.is_empty() {
state.serialize_entry("jobId", &self.job_id)?;
}
if !self.location.is_empty() {
state.serialize_entry("location", &self.location)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::JobCancelResponse {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.kind.is_empty() {
state.serialize_entry("kind", &self.kind)?;
}
if self.job.is_some() {
state.serialize_entry("job", &self.job)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::GetJobRequest {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.project_id.is_empty() {
state.serialize_entry("projectId", &self.project_id)?;
}
if !self.job_id.is_empty() {
state.serialize_entry("jobId", &self.job_id)?;
}
if !self.location.is_empty() {
state.serialize_entry("location", &self.location)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::InsertJobRequest {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.project_id.is_empty() {
state.serialize_entry("projectId", &self.project_id)?;
}
if self.job.is_some() {
state.serialize_entry("job", &self.job)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::DeleteJobRequest {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.project_id.is_empty() {
state.serialize_entry("projectId", &self.project_id)?;
}
if !self.job_id.is_empty() {
state.serialize_entry("jobId", &self.job_id)?;
}
if !self.location.is_empty() {
state.serialize_entry("location", &self.location)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::ListJobsRequest {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.project_id.is_empty() {
state.serialize_entry("projectId", &self.project_id)?;
}
if !wkt::internal::is_default(&self.all_users) {
state.serialize_entry("allUsers", &self.all_users)?;
}
if self.max_results.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int32Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I32>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("maxResults", &__With(&self.max_results))?;
}
if !wkt::internal::is_default(&self.min_creation_time) {
struct __With<'a>(&'a u64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::U64>::serialize(self.0, serializer)
}
}
state.serialize_entry("minCreationTime", &__With(&self.min_creation_time))?;
}
if self.max_creation_time.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::UInt64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::U64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("maxCreationTime", &__With(&self.max_creation_time))?;
}
if !self.page_token.is_empty() {
state.serialize_entry("pageToken", &self.page_token)?;
}
if !wkt::internal::is_default(&self.projection) {
state.serialize_entry("projection", &self.projection)?;
}
if !self.state_filter.is_empty() {
state.serialize_entry("stateFilter", &self.state_filter)?;
}
if !self.parent_job_id.is_empty() {
state.serialize_entry("parentJobId", &self.parent_job_id)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::ListFormatJob {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.id.is_empty() {
state.serialize_entry("id", &self.id)?;
}
if !self.kind.is_empty() {
state.serialize_entry("kind", &self.kind)?;
}
if self.job_reference.is_some() {
state.serialize_entry("jobReference", &self.job_reference)?;
}
if !self.state.is_empty() {
state.serialize_entry("state", &self.state)?;
}
if self.error_result.is_some() {
state.serialize_entry("errorResult", &self.error_result)?;
}
if self.statistics.is_some() {
state.serialize_entry("statistics", &self.statistics)?;
}
if self.configuration.is_some() {
state.serialize_entry("configuration", &self.configuration)?;
}
if self.status.is_some() {
state.serialize_entry("status", &self.status)?;
}
if !self.user_email.is_empty() {
state.serialize_entry("user_email", &self.user_email)?;
}
if !self.principal_subject.is_empty() {
state.serialize_entry("principal_subject", &self.principal_subject)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::JobList {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.etag.is_empty() {
state.serialize_entry("etag", &self.etag)?;
}
if !self.kind.is_empty() {
state.serialize_entry("kind", &self.kind)?;
}
if !self.next_page_token.is_empty() {
state.serialize_entry("nextPageToken", &self.next_page_token)?;
}
if !self.jobs.is_empty() {
state.serialize_entry("jobs", &self.jobs)?;
}
if !self.unreachable.is_empty() {
state.serialize_entry("unreachable", &self.unreachable)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::GetQueryResultsRequest {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.project_id.is_empty() {
state.serialize_entry("projectId", &self.project_id)?;
}
if !self.job_id.is_empty() {
state.serialize_entry("jobId", &self.job_id)?;
}
if self.start_index.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::UInt64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::U64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("startIndex", &__With(&self.start_index))?;
}
if !self.page_token.is_empty() {
state.serialize_entry("pageToken", &self.page_token)?;
}
if self.max_results.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::UInt32Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::U32>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("maxResults", &__With(&self.max_results))?;
}
if self.timeout_ms.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::UInt32Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::U32>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("timeoutMs", &__With(&self.timeout_ms))?;
}
if !self.location.is_empty() {
state.serialize_entry("location", &self.location)?;
}
if self.format_options.is_some() {
state.serialize_entry("formatOptions", &self.format_options)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::GetQueryResultsResponse {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.kind.is_empty() {
state.serialize_entry("kind", &self.kind)?;
}
if !self.etag.is_empty() {
state.serialize_entry("etag", &self.etag)?;
}
if self.schema.is_some() {
state.serialize_entry("schema", &self.schema)?;
}
if self.job_reference.is_some() {
state.serialize_entry("jobReference", &self.job_reference)?;
}
if self.total_rows.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::UInt64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::U64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("totalRows", &__With(&self.total_rows))?;
}
if !self.page_token.is_empty() {
state.serialize_entry("pageToken", &self.page_token)?;
}
if !self.rows.is_empty() {
state.serialize_entry("rows", &self.rows)?;
}
if self.total_bytes_processed.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("totalBytesProcessed", &__With(&self.total_bytes_processed))?;
}
if self.job_complete.is_some() {
state.serialize_entry("jobComplete", &self.job_complete)?;
}
if !self.errors.is_empty() {
state.serialize_entry("errors", &self.errors)?;
}
if self.cache_hit.is_some() {
state.serialize_entry("cacheHit", &self.cache_hit)?;
}
if self.num_dml_affected_rows.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("numDmlAffectedRows", &__With(&self.num_dml_affected_rows))?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::PostQueryRequest {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.project_id.is_empty() {
state.serialize_entry("projectId", &self.project_id)?;
}
if self.query_request.is_some() {
state.serialize_entry("queryRequest", &self.query_request)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::QueryRequest {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.kind.is_empty() {
state.serialize_entry("kind", &self.kind)?;
}
if !self.query.is_empty() {
state.serialize_entry("query", &self.query)?;
}
if self.max_results.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::UInt32Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::U32>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("maxResults", &__With(&self.max_results))?;
}
if self.default_dataset.is_some() {
state.serialize_entry("defaultDataset", &self.default_dataset)?;
}
if self.timeout_ms.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::UInt32Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::U32>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("timeoutMs", &__With(&self.timeout_ms))?;
}
if self.job_timeout_ms.is_some() {
struct __With<'a>(&'a std::option::Option<i64>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("jobTimeoutMs", &__With(&self.job_timeout_ms))?;
}
if self.max_slots.is_some() {
struct __With<'a>(&'a std::option::Option<i32>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I32>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("maxSlots", &__With(&self.max_slots))?;
}
if self.destination_encryption_configuration.is_some() {
state.serialize_entry(
"destinationEncryptionConfiguration",
&self.destination_encryption_configuration,
)?;
}
if !wkt::internal::is_default(&self.dry_run) {
state.serialize_entry("dryRun", &self.dry_run)?;
}
if self.use_query_cache.is_some() {
state.serialize_entry("useQueryCache", &self.use_query_cache)?;
}
if self.use_legacy_sql.is_some() {
state.serialize_entry("useLegacySql", &self.use_legacy_sql)?;
}
if !self.parameter_mode.is_empty() {
state.serialize_entry("parameterMode", &self.parameter_mode)?;
}
if !self.query_parameters.is_empty() {
state.serialize_entry("queryParameters", &self.query_parameters)?;
}
if !self.location.is_empty() {
state.serialize_entry("location", &self.location)?;
}
if self.format_options.is_some() {
state.serialize_entry("formatOptions", &self.format_options)?;
}
if !self.connection_properties.is_empty() {
state.serialize_entry("connectionProperties", &self.connection_properties)?;
}
if !self.labels.is_empty() {
state.serialize_entry("labels", &self.labels)?;
}
if self.maximum_bytes_billed.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("maximumBytesBilled", &__With(&self.maximum_bytes_billed))?;
}
if !self.request_id.is_empty() {
state.serialize_entry("requestId", &self.request_id)?;
}
if self.create_session.is_some() {
state.serialize_entry("createSession", &self.create_session)?;
}
if !wkt::internal::is_default(&self.job_creation_mode) {
state.serialize_entry("jobCreationMode", &self.job_creation_mode)?;
}
if self.reservation.is_some() {
state.serialize_entry("reservation", &self.reservation)?;
}
if !wkt::internal::is_default(&self.write_incremental_results) {
state.serialize_entry("writeIncrementalResults", &self.write_incremental_results)?;
}
if !wkt::internal::is_default(&self.query_results_format) {
state.serialize_entry("queryResultsFormat", &self.query_results_format)?;
}
if let Some(value) = self.arrow_serialization_options() {
state.serialize_entry("arrowSerializationOptions", value)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::QueryResponse {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.kind.is_empty() {
state.serialize_entry("kind", &self.kind)?;
}
if self.schema.is_some() {
state.serialize_entry("schema", &self.schema)?;
}
if self.job_reference.is_some() {
state.serialize_entry("jobReference", &self.job_reference)?;
}
if self.job_creation_reason.is_some() {
state.serialize_entry("jobCreationReason", &self.job_creation_reason)?;
}
if !self.query_id.is_empty() {
state.serialize_entry("queryId", &self.query_id)?;
}
if !self.location.is_empty() {
state.serialize_entry("location", &self.location)?;
}
if self.total_rows.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::UInt64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::U64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("totalRows", &__With(&self.total_rows))?;
}
if !self.page_token.is_empty() {
state.serialize_entry("pageToken", &self.page_token)?;
}
if !self.rows.is_empty() {
state.serialize_entry("rows", &self.rows)?;
}
if self.total_bytes_processed.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("totalBytesProcessed", &__With(&self.total_bytes_processed))?;
}
if self.total_bytes_billed.is_some() {
struct __With<'a>(&'a std::option::Option<i64>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("totalBytesBilled", &__With(&self.total_bytes_billed))?;
}
if self.total_slot_ms.is_some() {
struct __With<'a>(&'a std::option::Option<i64>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("totalSlotMs", &__With(&self.total_slot_ms))?;
}
if self.job_complete.is_some() {
state.serialize_entry("jobComplete", &self.job_complete)?;
}
if !self.errors.is_empty() {
state.serialize_entry("errors", &self.errors)?;
}
if self.cache_hit.is_some() {
state.serialize_entry("cacheHit", &self.cache_hit)?;
}
if self.num_dml_affected_rows.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("numDmlAffectedRows", &__With(&self.num_dml_affected_rows))?;
}
if self.session_info.is_some() {
state.serialize_entry("sessionInfo", &self.session_info)?;
}
if self.dml_stats.is_some() {
state.serialize_entry("dmlStats", &self.dml_stats)?;
}
if self.creation_time.is_some() {
struct __With<'a>(&'a std::option::Option<i64>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("creationTime", &__With(&self.creation_time))?;
}
if self.start_time.is_some() {
struct __With<'a>(&'a std::option::Option<i64>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("startTime", &__With(&self.start_time))?;
}
if self.end_time.is_some() {
struct __With<'a>(&'a std::option::Option<i64>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("endTime", &__With(&self.end_time))?;
}
if let Some(value) = self.arrow_schema() {
state.serialize_entry("arrowSchema", value)?;
}
if let Some(value) = self.arrow_record_batch() {
state.serialize_entry("arrowRecordBatch", value)?;
}
if !wkt::internal::is_default(&self.page_row_count) {
struct __With<'a>(&'a i64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
}
}
state.serialize_entry("pageRowCount", &__With(&self.page_row_count))?;
}
if !self.statement_type.is_empty() {
state.serialize_entry("statementType", &self.statement_type)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::DestinationTableProperties {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.friendly_name.is_some() {
state.serialize_entry("friendlyName", &self.friendly_name)?;
}
if self.description.is_some() {
state.serialize_entry("description", &self.description)?;
}
if !self.labels.is_empty() {
state.serialize_entry("labels", &self.labels)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::ConnectionProperty {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.key.is_empty() {
state.serialize_entry("key", &self.key)?;
}
if !self.value.is_empty() {
state.serialize_entry("value", &self.value)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::JobConfigurationQuery {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.query.is_empty() {
state.serialize_entry("query", &self.query)?;
}
if self.destination_table.is_some() {
state.serialize_entry("destinationTable", &self.destination_table)?;
}
if !self.external_table_definitions.is_empty() {
state.serialize_entry("tableDefinitions", &self.external_table_definitions)?;
}
if !self.user_defined_function_resources.is_empty() {
state.serialize_entry(
"userDefinedFunctionResources",
&self.user_defined_function_resources,
)?;
}
if !self.create_disposition.is_empty() {
state.serialize_entry("createDisposition", &self.create_disposition)?;
}
if !self.write_disposition.is_empty() {
state.serialize_entry("writeDisposition", &self.write_disposition)?;
}
if self.default_dataset.is_some() {
state.serialize_entry("defaultDataset", &self.default_dataset)?;
}
if !self.priority.is_empty() {
state.serialize_entry("priority", &self.priority)?;
}
if self.allow_large_results.is_some() {
state.serialize_entry("allowLargeResults", &self.allow_large_results)?;
}
if self.use_query_cache.is_some() {
state.serialize_entry("useQueryCache", &self.use_query_cache)?;
}
if self.flatten_results.is_some() {
state.serialize_entry("flattenResults", &self.flatten_results)?;
}
if self.maximum_bytes_billed.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("maximumBytesBilled", &__With(&self.maximum_bytes_billed))?;
}
if self.use_legacy_sql.is_some() {
state.serialize_entry("useLegacySql", &self.use_legacy_sql)?;
}
if !self.parameter_mode.is_empty() {
state.serialize_entry("parameterMode", &self.parameter_mode)?;
}
if !self.query_parameters.is_empty() {
state.serialize_entry("queryParameters", &self.query_parameters)?;
}
if self.system_variables.is_some() {
state.serialize_entry("systemVariables", &self.system_variables)?;
}
if !self.schema_update_options.is_empty() {
state.serialize_entry("schemaUpdateOptions", &self.schema_update_options)?;
}
if self.time_partitioning.is_some() {
state.serialize_entry("timePartitioning", &self.time_partitioning)?;
}
if self.range_partitioning.is_some() {
state.serialize_entry("rangePartitioning", &self.range_partitioning)?;
}
if self.clustering.is_some() {
state.serialize_entry("clustering", &self.clustering)?;
}
if self.destination_encryption_configuration.is_some() {
state.serialize_entry(
"destinationEncryptionConfiguration",
&self.destination_encryption_configuration,
)?;
}
if self.script_options.is_some() {
state.serialize_entry("scriptOptions", &self.script_options)?;
}
if !self.connection_properties.is_empty() {
state.serialize_entry("connectionProperties", &self.connection_properties)?;
}
if self.create_session.is_some() {
state.serialize_entry("createSession", &self.create_session)?;
}
if self.continuous.is_some() {
state.serialize_entry("continuous", &self.continuous)?;
}
if !wkt::internal::is_default(&self.write_incremental_results) {
state.serialize_entry("writeIncrementalResults", &self.write_incremental_results)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::ScriptOptions {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.statement_timeout_ms.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("statementTimeoutMs", &__With(&self.statement_timeout_ms))?;
}
if self.statement_byte_budget.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("statementByteBudget", &__With(&self.statement_byte_budget))?;
}
if !wkt::internal::is_default(&self.key_result_statement) {
state.serialize_entry("keyResultStatement", &self.key_result_statement)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::JobConfigurationLoad {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.source_uris.is_empty() {
state.serialize_entry("sourceUris", &self.source_uris)?;
}
if !wkt::internal::is_default(&self.file_set_spec_type) {
state.serialize_entry("fileSetSpecType", &self.file_set_spec_type)?;
}
if self.schema.is_some() {
state.serialize_entry("schema", &self.schema)?;
}
if self.destination_table.is_some() {
state.serialize_entry("destinationTable", &self.destination_table)?;
}
if self.destination_table_properties.is_some() {
state.serialize_entry(
"destinationTableProperties",
&self.destination_table_properties,
)?;
}
if !self.create_disposition.is_empty() {
state.serialize_entry("createDisposition", &self.create_disposition)?;
}
if !self.write_disposition.is_empty() {
state.serialize_entry("writeDisposition", &self.write_disposition)?;
}
if self.null_marker.is_some() {
state.serialize_entry("nullMarker", &self.null_marker)?;
}
if !self.field_delimiter.is_empty() {
state.serialize_entry("fieldDelimiter", &self.field_delimiter)?;
}
if self.skip_leading_rows.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int32Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I32>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("skipLeadingRows", &__With(&self.skip_leading_rows))?;
}
if !self.encoding.is_empty() {
state.serialize_entry("encoding", &self.encoding)?;
}
if self.quote.is_some() {
state.serialize_entry("quote", &self.quote)?;
}
if self.max_bad_records.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int32Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I32>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("maxBadRecords", &__With(&self.max_bad_records))?;
}
if self.allow_quoted_newlines.is_some() {
state.serialize_entry("allowQuotedNewlines", &self.allow_quoted_newlines)?;
}
if !self.source_format.is_empty() {
state.serialize_entry("sourceFormat", &self.source_format)?;
}
if self.allow_jagged_rows.is_some() {
state.serialize_entry("allowJaggedRows", &self.allow_jagged_rows)?;
}
if self.ignore_unknown_values.is_some() {
state.serialize_entry("ignoreUnknownValues", &self.ignore_unknown_values)?;
}
if !self.projection_fields.is_empty() {
state.serialize_entry("projectionFields", &self.projection_fields)?;
}
if self.autodetect.is_some() {
state.serialize_entry("autodetect", &self.autodetect)?;
}
if !self.schema_update_options.is_empty() {
state.serialize_entry("schemaUpdateOptions", &self.schema_update_options)?;
}
if self.time_partitioning.is_some() {
state.serialize_entry("timePartitioning", &self.time_partitioning)?;
}
if self.range_partitioning.is_some() {
state.serialize_entry("rangePartitioning", &self.range_partitioning)?;
}
if self.clustering.is_some() {
state.serialize_entry("clustering", &self.clustering)?;
}
if self.destination_encryption_configuration.is_some() {
state.serialize_entry(
"destinationEncryptionConfiguration",
&self.destination_encryption_configuration,
)?;
}
if self.use_avro_logical_types.is_some() {
state.serialize_entry("useAvroLogicalTypes", &self.use_avro_logical_types)?;
}
if self.reference_file_schema_uri.is_some() {
state.serialize_entry("referenceFileSchemaUri", &self.reference_file_schema_uri)?;
}
if self.hive_partitioning_options.is_some() {
state.serialize_entry("hivePartitioningOptions", &self.hive_partitioning_options)?;
}
if !self.decimal_target_types.is_empty() {
state.serialize_entry("decimalTargetTypes", &self.decimal_target_types)?;
}
if !wkt::internal::is_default(&self.json_extension) {
state.serialize_entry("jsonExtension", &self.json_extension)?;
}
if self.parquet_options.is_some() {
state.serialize_entry("parquetOptions", &self.parquet_options)?;
}
if self.preserve_ascii_control_characters.is_some() {
state.serialize_entry(
"preserveAsciiControlCharacters",
&self.preserve_ascii_control_characters,
)?;
}
if !self.connection_properties.is_empty() {
state.serialize_entry("connectionProperties", &self.connection_properties)?;
}
if self.create_session.is_some() {
state.serialize_entry("createSession", &self.create_session)?;
}
if !wkt::internal::is_default(&self.column_name_character_map) {
state.serialize_entry("columnNameCharacterMap", &self.column_name_character_map)?;
}
if self.copy_files_only.is_some() {
state.serialize_entry("copyFilesOnly", &self.copy_files_only)?;
}
if self.time_zone.is_some() {
state.serialize_entry("timeZone", &self.time_zone)?;
}
if !self.null_markers.is_empty() {
state.serialize_entry("nullMarkers", &self.null_markers)?;
}
if self.date_format.is_some() {
state.serialize_entry("dateFormat", &self.date_format)?;
}
if self.datetime_format.is_some() {
state.serialize_entry("datetimeFormat", &self.datetime_format)?;
}
if self.time_format.is_some() {
state.serialize_entry("timeFormat", &self.time_format)?;
}
if self.timestamp_format.is_some() {
state.serialize_entry("timestampFormat", &self.timestamp_format)?;
}
if !wkt::internal::is_default(&self.source_column_match) {
state.serialize_entry("sourceColumnMatch", &self.source_column_match)?;
}
if !self.timestamp_target_precision.is_empty() {
struct __With<'a>(&'a std::vec::Vec<i32>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::vec::Vec<wkt::internal::I32>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry(
"timestampTargetPrecision",
&__With(&self.timestamp_target_precision),
)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::JobConfigurationTableCopy {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.source_table.is_some() {
state.serialize_entry("sourceTable", &self.source_table)?;
}
if !self.source_tables.is_empty() {
state.serialize_entry("sourceTables", &self.source_tables)?;
}
if self.destination_table.is_some() {
state.serialize_entry("destinationTable", &self.destination_table)?;
}
if !self.create_disposition.is_empty() {
state.serialize_entry("createDisposition", &self.create_disposition)?;
}
if !self.write_disposition.is_empty() {
state.serialize_entry("writeDisposition", &self.write_disposition)?;
}
if self.destination_encryption_configuration.is_some() {
state.serialize_entry(
"destinationEncryptionConfiguration",
&self.destination_encryption_configuration,
)?;
}
if !wkt::internal::is_default(&self.operation_type) {
state.serialize_entry("operationType", &self.operation_type)?;
}
if self.destination_expiration_time.is_some() {
state.serialize_entry(
"destinationExpirationTime",
&self.destination_expiration_time,
)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::JobConfigurationExtract {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if let Some(value) = self.source_table() {
state.serialize_entry("sourceTable", value)?;
}
if let Some(value) = self.source_model() {
state.serialize_entry("sourceModel", value)?;
}
if !self.destination_uris.is_empty() {
state.serialize_entry("destinationUris", &self.destination_uris)?;
}
if self.print_header.is_some() {
state.serialize_entry("printHeader", &self.print_header)?;
}
if !self.field_delimiter.is_empty() {
state.serialize_entry("fieldDelimiter", &self.field_delimiter)?;
}
if !self.destination_format.is_empty() {
state.serialize_entry("destinationFormat", &self.destination_format)?;
}
if !self.compression.is_empty() {
state.serialize_entry("compression", &self.compression)?;
}
if self.use_avro_logical_types.is_some() {
state.serialize_entry("useAvroLogicalTypes", &self.use_avro_logical_types)?;
}
if self.model_extract_options.is_some() {
state.serialize_entry("modelExtractOptions", &self.model_extract_options)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::job_configuration_extract::ModelExtractOptions {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.trial_id.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("trialId", &__With(&self.trial_id))?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::JobConfiguration {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.job_type.is_empty() {
state.serialize_entry("jobType", &self.job_type)?;
}
if self.query.is_some() {
state.serialize_entry("query", &self.query)?;
}
if self.load.is_some() {
state.serialize_entry("load", &self.load)?;
}
if self.copy.is_some() {
state.serialize_entry("copy", &self.copy)?;
}
if self.extract.is_some() {
state.serialize_entry("extract", &self.extract)?;
}
if self.dry_run.is_some() {
state.serialize_entry("dryRun", &self.dry_run)?;
}
if self.job_timeout_ms.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("jobTimeoutMs", &__With(&self.job_timeout_ms))?;
}
if self.max_slots.is_some() {
struct __With<'a>(&'a std::option::Option<i32>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I32>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("maxSlots", &__With(&self.max_slots))?;
}
if !self.labels.is_empty() {
state.serialize_entry("labels", &self.labels)?;
}
if self.reservation.is_some() {
state.serialize_entry("reservation", &self.reservation)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::JobCreationReason {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !wkt::internal::is_default(&self.code) {
state.serialize_entry("code", &self.code)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::JobReference {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.project_id.is_empty() {
state.serialize_entry("projectId", &self.project_id)?;
}
if !self.job_id.is_empty() {
state.serialize_entry("jobId", &self.job_id)?;
}
if self.location.is_some() {
state.serialize_entry("location", &self.location)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::ExplainQueryStep {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.kind.is_empty() {
state.serialize_entry("kind", &self.kind)?;
}
if !self.substeps.is_empty() {
state.serialize_entry("substeps", &self.substeps)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::ExplainQueryStage {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.name.is_empty() {
state.serialize_entry("name", &self.name)?;
}
if self.id.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("id", &__With(&self.id))?;
}
if !wkt::internal::is_default(&self.start_ms) {
struct __With<'a>(&'a i64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
}
}
state.serialize_entry("startMs", &__With(&self.start_ms))?;
}
if !wkt::internal::is_default(&self.end_ms) {
struct __With<'a>(&'a i64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
}
}
state.serialize_entry("endMs", &__With(&self.end_ms))?;
}
if !self.input_stages.is_empty() {
struct __With<'a>(&'a std::vec::Vec<i64>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::vec::Vec<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("inputStages", &__With(&self.input_stages))?;
}
if self.wait_ratio_avg.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::DoubleValue>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("waitRatioAvg", &__With(&self.wait_ratio_avg))?;
}
if self.wait_ms_avg.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("waitMsAvg", &__With(&self.wait_ms_avg))?;
}
if self.wait_ratio_max.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::DoubleValue>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("waitRatioMax", &__With(&self.wait_ratio_max))?;
}
if self.wait_ms_max.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("waitMsMax", &__With(&self.wait_ms_max))?;
}
if self.read_ratio_avg.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::DoubleValue>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("readRatioAvg", &__With(&self.read_ratio_avg))?;
}
if self.read_ms_avg.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("readMsAvg", &__With(&self.read_ms_avg))?;
}
if self.read_ratio_max.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::DoubleValue>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("readRatioMax", &__With(&self.read_ratio_max))?;
}
if self.read_ms_max.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("readMsMax", &__With(&self.read_ms_max))?;
}
if self.compute_ratio_avg.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::DoubleValue>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("computeRatioAvg", &__With(&self.compute_ratio_avg))?;
}
if self.compute_ms_avg.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("computeMsAvg", &__With(&self.compute_ms_avg))?;
}
if self.compute_ratio_max.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::DoubleValue>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("computeRatioMax", &__With(&self.compute_ratio_max))?;
}
if self.compute_ms_max.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("computeMsMax", &__With(&self.compute_ms_max))?;
}
if self.write_ratio_avg.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::DoubleValue>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("writeRatioAvg", &__With(&self.write_ratio_avg))?;
}
if self.write_ms_avg.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("writeMsAvg", &__With(&self.write_ms_avg))?;
}
if self.write_ratio_max.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::DoubleValue>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("writeRatioMax", &__With(&self.write_ratio_max))?;
}
if self.write_ms_max.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("writeMsMax", &__With(&self.write_ms_max))?;
}
if self.shuffle_output_bytes.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("shuffleOutputBytes", &__With(&self.shuffle_output_bytes))?;
}
if self.shuffle_output_bytes_spilled.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry(
"shuffleOutputBytesSpilled",
&__With(&self.shuffle_output_bytes_spilled),
)?;
}
if self.records_read.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("recordsRead", &__With(&self.records_read))?;
}
if self.records_written.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("recordsWritten", &__With(&self.records_written))?;
}
if self.parallel_inputs.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("parallelInputs", &__With(&self.parallel_inputs))?;
}
if self.completed_parallel_inputs.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry(
"completedParallelInputs",
&__With(&self.completed_parallel_inputs),
)?;
}
if !self.status.is_empty() {
state.serialize_entry("status", &self.status)?;
}
if !self.steps.is_empty() {
state.serialize_entry("steps", &self.steps)?;
}
if self.slot_ms.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("slotMs", &__With(&self.slot_ms))?;
}
if !wkt::internal::is_default(&self.compute_mode) {
state.serialize_entry("computeMode", &self.compute_mode)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::QueryTimelineSample {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.elapsed_ms.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("elapsedMs", &__With(&self.elapsed_ms))?;
}
if self.total_slot_ms.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("totalSlotMs", &__With(&self.total_slot_ms))?;
}
if self.pending_units.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("pendingUnits", &__With(&self.pending_units))?;
}
if self.completed_units.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("completedUnits", &__With(&self.completed_units))?;
}
if self.active_units.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("activeUnits", &__With(&self.active_units))?;
}
if self.shuffle_ram_usage_ratio.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::DoubleValue>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry(
"shuffleRamUsageRatio",
&__With(&self.shuffle_ram_usage_ratio),
)?;
}
if self.estimated_runnable_units.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry(
"estimatedRunnableUnits",
&__With(&self.estimated_runnable_units),
)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::ExternalServiceCost {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.external_service.is_empty() {
state.serialize_entry("externalService", &self.external_service)?;
}
if self.bytes_processed.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("bytesProcessed", &__With(&self.bytes_processed))?;
}
if self.bytes_billed.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("bytesBilled", &__With(&self.bytes_billed))?;
}
if self.slot_ms.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("slotMs", &__With(&self.slot_ms))?;
}
if !wkt::internal::is_default(&self.reserved_slot_count) {
struct __With<'a>(&'a i64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
}
}
state.serialize_entry("reservedSlotCount", &__With(&self.reserved_slot_count))?;
}
if !self.billing_method.is_empty() {
state.serialize_entry("billingMethod", &self.billing_method)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::ExportDataStatistics {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.file_count.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("fileCount", &__With(&self.file_count))?;
}
if self.row_count.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("rowCount", &__With(&self.row_count))?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::BiEngineReason {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !wkt::internal::is_default(&self.code) {
state.serialize_entry("code", &self.code)?;
}
if !self.message.is_empty() {
state.serialize_entry("message", &self.message)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::BiEngineStatistics {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !wkt::internal::is_default(&self.bi_engine_mode) {
state.serialize_entry("biEngineMode", &self.bi_engine_mode)?;
}
if !wkt::internal::is_default(&self.acceleration_mode) {
state.serialize_entry("accelerationMode", &self.acceleration_mode)?;
}
if !self.bi_engine_reasons.is_empty() {
state.serialize_entry("biEngineReasons", &self.bi_engine_reasons)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::IndexUnusedReason {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.code.is_some() {
state.serialize_entry("code", &self.code)?;
}
if self.message.is_some() {
state.serialize_entry("message", &self.message)?;
}
if self.base_table.is_some() {
state.serialize_entry("baseTable", &self.base_table)?;
}
if self.index_name.is_some() {
state.serialize_entry("indexName", &self.index_name)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::IndexPruningStats {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.base_table.is_some() {
state.serialize_entry("baseTable", &self.base_table)?;
}
if self.index_id.is_some() {
state.serialize_entry("indexId", &self.index_id)?;
}
if self.pre_index_pruning_parallel_input_count.is_some() {
struct __With<'a>(&'a std::option::Option<i64>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry(
"preIndexPruningParallelInputCount",
&__With(&self.pre_index_pruning_parallel_input_count),
)?;
}
if self.post_index_pruning_parallel_input_count.is_some() {
struct __With<'a>(&'a std::option::Option<i64>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry(
"postIndexPruningParallelInputCount",
&__With(&self.post_index_pruning_parallel_input_count),
)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::StoredColumnsUsage {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.is_query_accelerated.is_some() {
state.serialize_entry("isQueryAccelerated", &self.is_query_accelerated)?;
}
if self.base_table.is_some() {
state.serialize_entry("baseTable", &self.base_table)?;
}
if !self.stored_columns_unused_reasons.is_empty() {
state.serialize_entry(
"storedColumnsUnusedReasons",
&self.stored_columns_unused_reasons,
)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::stored_columns_usage::StoredColumnsUnusedReason {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.code.is_some() {
state.serialize_entry("code", &self.code)?;
}
if self.message.is_some() {
state.serialize_entry("message", &self.message)?;
}
if !self.uncovered_columns.is_empty() {
state.serialize_entry("uncoveredColumns", &self.uncovered_columns)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::SearchStatistics {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !wkt::internal::is_default(&self.index_usage_mode) {
state.serialize_entry("indexUsageMode", &self.index_usage_mode)?;
}
if !self.index_unused_reasons.is_empty() {
state.serialize_entry("indexUnusedReasons", &self.index_unused_reasons)?;
}
if !self.index_pruning_stats.is_empty() {
state.serialize_entry("indexPruningStats", &self.index_pruning_stats)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::VectorSearchStatistics {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !wkt::internal::is_default(&self.index_usage_mode) {
state.serialize_entry("indexUsageMode", &self.index_usage_mode)?;
}
if !self.index_unused_reasons.is_empty() {
state.serialize_entry("indexUnusedReasons", &self.index_unused_reasons)?;
}
if !self.stored_columns_usages.is_empty() {
state.serialize_entry("storedColumnsUsages", &self.stored_columns_usages)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::QueryInfo {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.optimization_details.is_some() {
state.serialize_entry("optimizationDetails", &self.optimization_details)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::LoadQueryStatistics {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.input_files.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("inputFiles", &__With(&self.input_files))?;
}
if self.input_file_bytes.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("inputFileBytes", &__With(&self.input_file_bytes))?;
}
if self.output_rows.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("outputRows", &__With(&self.output_rows))?;
}
if self.output_bytes.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("outputBytes", &__With(&self.output_bytes))?;
}
if self.bad_records.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("badRecords", &__With(&self.bad_records))?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::IncrementalResultStats {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !wkt::internal::is_default(&self.disabled_reason) {
state.serialize_entry("disabledReason", &self.disabled_reason)?;
}
if !self.disabled_reason_details.is_empty() {
state.serialize_entry("disabledReasonDetails", &self.disabled_reason_details)?;
}
if self.result_set_last_replace_time.is_some() {
state.serialize_entry(
"resultSetLastReplaceTime",
&self.result_set_last_replace_time,
)?;
}
if self.result_set_last_modify_time.is_some() {
state.serialize_entry("resultSetLastModifyTime", &self.result_set_last_modify_time)?;
}
if self.first_incremental_row_time.is_some() {
state.serialize_entry("firstIncrementalRowTime", &self.first_incremental_row_time)?;
}
if self.last_incremental_row_time.is_some() {
state.serialize_entry("lastIncrementalRowTime", &self.last_incremental_row_time)?;
}
if self.incremental_row_count.is_some() {
struct __With<'a>(&'a std::option::Option<i64>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("incrementalRowCount", &__With(&self.incremental_row_count))?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::JobStatistics2 {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.query_plan.is_empty() {
state.serialize_entry("queryPlan", &self.query_plan)?;
}
if self.estimated_bytes_processed.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry(
"estimatedBytesProcessed",
&__With(&self.estimated_bytes_processed),
)?;
}
if !self.timeline.is_empty() {
state.serialize_entry("timeline", &self.timeline)?;
}
if self.total_partitions_processed.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry(
"totalPartitionsProcessed",
&__With(&self.total_partitions_processed),
)?;
}
if self.total_bytes_processed.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("totalBytesProcessed", &__With(&self.total_bytes_processed))?;
}
if !self.total_bytes_processed_accuracy.is_empty() {
state.serialize_entry(
"totalBytesProcessedAccuracy",
&self.total_bytes_processed_accuracy,
)?;
}
if self.total_bytes_billed.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("totalBytesBilled", &__With(&self.total_bytes_billed))?;
}
if self.billing_tier.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int32Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I32>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("billingTier", &__With(&self.billing_tier))?;
}
if self.total_slot_ms.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("totalSlotMs", &__With(&self.total_slot_ms))?;
}
if self.total_services_sku_slot_ms.is_some() {
struct __With<'a>(&'a std::option::Option<i64>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry(
"totalServicesSkuSlotMs",
&__With(&self.total_services_sku_slot_ms),
)?;
}
if self.cache_hit.is_some() {
state.serialize_entry("cacheHit", &self.cache_hit)?;
}
if !self.referenced_tables.is_empty() {
state.serialize_entry("referencedTables", &self.referenced_tables)?;
}
if !self.referenced_routines.is_empty() {
state.serialize_entry("referencedRoutines", &self.referenced_routines)?;
}
if !self.referenced_property_graphs.is_empty() {
state.serialize_entry("referencedPropertyGraphs", &self.referenced_property_graphs)?;
}
if self.schema.is_some() {
state.serialize_entry("schema", &self.schema)?;
}
if self.num_dml_affected_rows.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("numDmlAffectedRows", &__With(&self.num_dml_affected_rows))?;
}
if self.dml_stats.is_some() {
state.serialize_entry("dmlStats", &self.dml_stats)?;
}
if !self.undeclared_query_parameters.is_empty() {
state.serialize_entry(
"undeclaredQueryParameters",
&self.undeclared_query_parameters,
)?;
}
if !self.statement_type.is_empty() {
state.serialize_entry("statementType", &self.statement_type)?;
}
if !self.ddl_operation_performed.is_empty() {
state.serialize_entry("ddlOperationPerformed", &self.ddl_operation_performed)?;
}
if self.ddl_target_table.is_some() {
state.serialize_entry("ddlTargetTable", &self.ddl_target_table)?;
}
if self.ddl_destination_table.is_some() {
state.serialize_entry("ddlDestinationTable", &self.ddl_destination_table)?;
}
if self.ddl_target_row_access_policy.is_some() {
state.serialize_entry(
"ddlTargetRowAccessPolicy",
&self.ddl_target_row_access_policy,
)?;
}
if self.ddl_affected_row_access_policy_count.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry(
"ddlAffectedRowAccessPolicyCount",
&__With(&self.ddl_affected_row_access_policy_count),
)?;
}
if self.ddl_target_routine.is_some() {
state.serialize_entry("ddlTargetRoutine", &self.ddl_target_routine)?;
}
if self.ddl_target_dataset.is_some() {
state.serialize_entry("ddlTargetDataset", &self.ddl_target_dataset)?;
}
if self.ml_statistics.is_some() {
state.serialize_entry("mlStatistics", &self.ml_statistics)?;
}
if self.export_data_statistics.is_some() {
state.serialize_entry("exportDataStatistics", &self.export_data_statistics)?;
}
if !self.external_service_costs.is_empty() {
state.serialize_entry("externalServiceCosts", &self.external_service_costs)?;
}
if self.bi_engine_statistics.is_some() {
state.serialize_entry("biEngineStatistics", &self.bi_engine_statistics)?;
}
if self.load_query_statistics.is_some() {
state.serialize_entry("loadQueryStatistics", &self.load_query_statistics)?;
}
if self.dcl_target_table.is_some() {
state.serialize_entry("dclTargetTable", &self.dcl_target_table)?;
}
if self.dcl_target_view.is_some() {
state.serialize_entry("dclTargetView", &self.dcl_target_view)?;
}
if self.dcl_target_dataset.is_some() {
state.serialize_entry("dclTargetDataset", &self.dcl_target_dataset)?;
}
if self.search_statistics.is_some() {
state.serialize_entry("searchStatistics", &self.search_statistics)?;
}
if self.vector_search_statistics.is_some() {
state.serialize_entry("vectorSearchStatistics", &self.vector_search_statistics)?;
}
if self.performance_insights.is_some() {
state.serialize_entry("performanceInsights", &self.performance_insights)?;
}
if self.query_info.is_some() {
state.serialize_entry("queryInfo", &self.query_info)?;
}
if self.spark_statistics.is_some() {
state.serialize_entry("sparkStatistics", &self.spark_statistics)?;
}
if self.transferred_bytes.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("transferredBytes", &__With(&self.transferred_bytes))?;
}
if self.materialized_view_statistics.is_some() {
state.serialize_entry(
"materializedViewStatistics",
&self.materialized_view_statistics,
)?;
}
if self.metadata_cache_statistics.is_some() {
state.serialize_entry("metadataCacheStatistics", &self.metadata_cache_statistics)?;
}
if self.incremental_result_stats.is_some() {
state.serialize_entry("incrementalResultStats", &self.incremental_result_stats)?;
}
if self.gen_ai_stats.is_some() {
state.serialize_entry("genAiStats", &self.gen_ai_stats)?;
}
if !self.object_storage_stats.is_empty() {
state.serialize_entry("objectStorageStats", &self.object_storage_stats)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::ObjectStorageStats {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.cloud_provider.is_some() {
state.serialize_entry("cloudProvider", &self.cloud_provider)?;
}
if self.object_storage_bytes_read.is_some() {
struct __With<'a>(&'a std::option::Option<i64>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry(
"objectStorageBytesRead",
&__With(&self.object_storage_bytes_read),
)?;
}
if self.cache_bytes_read.is_some() {
struct __With<'a>(&'a std::option::Option<i64>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("cacheBytesRead", &__With(&self.cache_bytes_read))?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::JobStatistics3 {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.input_files.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("inputFiles", &__With(&self.input_files))?;
}
if self.input_file_bytes.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("inputFileBytes", &__With(&self.input_file_bytes))?;
}
if self.output_rows.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("outputRows", &__With(&self.output_rows))?;
}
if self.output_bytes.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("outputBytes", &__With(&self.output_bytes))?;
}
if self.bad_records.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("badRecords", &__With(&self.bad_records))?;
}
if !self.timeline.is_empty() {
state.serialize_entry("timeline", &self.timeline)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::JobStatistics4 {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.destination_uri_file_counts.is_empty() {
struct __With<'a>(&'a std::vec::Vec<i64>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::vec::Vec<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry(
"destinationUriFileCounts",
&__With(&self.destination_uri_file_counts),
)?;
}
if self.input_bytes.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("inputBytes", &__With(&self.input_bytes))?;
}
if !self.timeline.is_empty() {
state.serialize_entry("timeline", &self.timeline)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::CopyJobStatistics {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.copied_rows.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("copiedRows", &__With(&self.copied_rows))?;
}
if self.copied_logical_bytes.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("copiedLogicalBytes", &__With(&self.copied_logical_bytes))?;
}
if !self.remote_destination_region.is_empty() {
state.serialize_entry("remoteDestinationRegion", &self.remote_destination_region)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::MlStatistics {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !wkt::internal::is_default(&self.max_iterations) {
struct __With<'a>(&'a i64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
}
}
state.serialize_entry("maxIterations", &__With(&self.max_iterations))?;
}
if !self.iteration_results.is_empty() {
state.serialize_entry("iterationResults", &self.iteration_results)?;
}
if !wkt::internal::is_default(&self.model_type) {
state.serialize_entry("modelType", &self.model_type)?;
}
if !wkt::internal::is_default(&self.training_type) {
state.serialize_entry("trainingType", &self.training_type)?;
}
if !self.hparam_trials.is_empty() {
state.serialize_entry("hparamTrials", &self.hparam_trials)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::ScriptStatistics {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !wkt::internal::is_default(&self.evaluation_kind) {
state.serialize_entry("evaluationKind", &self.evaluation_kind)?;
}
if !self.stack_frames.is_empty() {
state.serialize_entry("stackFrames", &self.stack_frames)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::script_statistics::ScriptStackFrame {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !wkt::internal::is_default(&self.start_line) {
struct __With<'a>(&'a i32);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
}
}
state.serialize_entry("startLine", &__With(&self.start_line))?;
}
if !wkt::internal::is_default(&self.start_column) {
struct __With<'a>(&'a i32);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
}
}
state.serialize_entry("startColumn", &__With(&self.start_column))?;
}
if !wkt::internal::is_default(&self.end_line) {
struct __With<'a>(&'a i32);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
}
}
state.serialize_entry("endLine", &__With(&self.end_line))?;
}
if !wkt::internal::is_default(&self.end_column) {
struct __With<'a>(&'a i32);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
}
}
state.serialize_entry("endColumn", &__With(&self.end_column))?;
}
if !self.procedure_id.is_empty() {
state.serialize_entry("procedureId", &self.procedure_id)?;
}
if !self.text.is_empty() {
state.serialize_entry("text", &self.text)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::RowLevelSecurityStatistics {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !wkt::internal::is_default(&self.row_level_security_applied) {
state.serialize_entry("rowLevelSecurityApplied", &self.row_level_security_applied)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::DataMaskingStatistics {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !wkt::internal::is_default(&self.data_masking_applied) {
state.serialize_entry("dataMaskingApplied", &self.data_masking_applied)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::JobStatistics {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !wkt::internal::is_default(&self.creation_time) {
struct __With<'a>(&'a i64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
}
}
state.serialize_entry("creationTime", &__With(&self.creation_time))?;
}
if !wkt::internal::is_default(&self.start_time) {
struct __With<'a>(&'a i64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
}
}
state.serialize_entry("startTime", &__With(&self.start_time))?;
}
if !wkt::internal::is_default(&self.end_time) {
struct __With<'a>(&'a i64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
}
}
state.serialize_entry("endTime", &__With(&self.end_time))?;
}
if self.total_bytes_processed.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("totalBytesProcessed", &__With(&self.total_bytes_processed))?;
}
if self.completion_ratio.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::DoubleValue>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("completionRatio", &__With(&self.completion_ratio))?;
}
if !self.quota_deferments.is_empty() {
state.serialize_entry("quotaDeferments", &self.quota_deferments)?;
}
if self.query.is_some() {
state.serialize_entry("query", &self.query)?;
}
if self.load.is_some() {
state.serialize_entry("load", &self.load)?;
}
if self.extract.is_some() {
state.serialize_entry("extract", &self.extract)?;
}
if self.copy.is_some() {
state.serialize_entry("copy", &self.copy)?;
}
if self.total_slot_ms.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("totalSlotMs", &__With(&self.total_slot_ms))?;
}
if !self.reservation_id.is_empty() {
state.serialize_entry("reservation_id", &self.reservation_id)?;
}
if !wkt::internal::is_default(&self.num_child_jobs) {
struct __With<'a>(&'a i64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
}
}
state.serialize_entry("numChildJobs", &__With(&self.num_child_jobs))?;
}
if !self.parent_job_id.is_empty() {
state.serialize_entry("parentJobId", &self.parent_job_id)?;
}
if self.script_statistics.is_some() {
state.serialize_entry("scriptStatistics", &self.script_statistics)?;
}
if self.row_level_security_statistics.is_some() {
state.serialize_entry(
"rowLevelSecurityStatistics",
&self.row_level_security_statistics,
)?;
}
if self.data_masking_statistics.is_some() {
state.serialize_entry("dataMaskingStatistics", &self.data_masking_statistics)?;
}
if self.transaction_info.is_some() {
state.serialize_entry("transactionInfo", &self.transaction_info)?;
}
if self.session_info.is_some() {
state.serialize_entry("sessionInfo", &self.session_info)?;
}
if !wkt::internal::is_default(&self.final_execution_duration_ms) {
struct __With<'a>(&'a i64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
}
}
state.serialize_entry(
"finalExecutionDurationMs",
&__With(&self.final_execution_duration_ms),
)?;
}
if !wkt::internal::is_default(&self.edition) {
state.serialize_entry("edition", &self.edition)?;
}
if !self.reservation_group_path.is_empty() {
state.serialize_entry("reservationGroupPath", &self.reservation_group_path)?;
}
if !self.global_query_remote_regions.is_empty() {
state.serialize_entry(
"globalQueryRemoteRegions",
&self.global_query_remote_regions,
)?;
}
if self.parent_global_query_job.is_some() {
state.serialize_entry("parentGlobalQueryJob", &self.parent_global_query_job)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::job_statistics::TransactionInfo {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.transaction_id.is_empty() {
state.serialize_entry("transactionId", &self.transaction_id)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::DmlStats {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.inserted_row_count.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("insertedRowCount", &__With(&self.inserted_row_count))?;
}
if self.deleted_row_count.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("deletedRowCount", &__With(&self.deleted_row_count))?;
}
if self.updated_row_count.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("updatedRowCount", &__With(&self.updated_row_count))?;
}
if !wkt::internal::is_default(&self.dml_mode) {
state.serialize_entry("dmlMode", &self.dml_mode)?;
}
if !wkt::internal::is_default(&self.fine_grained_dml_unused_reason) {
state.serialize_entry(
"fineGrainedDmlUnusedReason",
&self.fine_grained_dml_unused_reason,
)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::PerformanceInsights {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !wkt::internal::is_default(&self.avg_previous_execution_ms) {
struct __With<'a>(&'a i64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
}
}
state.serialize_entry(
"avgPreviousExecutionMs",
&__With(&self.avg_previous_execution_ms),
)?;
}
if !self.stage_performance_standalone_insights.is_empty() {
state.serialize_entry(
"stagePerformanceStandaloneInsights",
&self.stage_performance_standalone_insights,
)?;
}
if !self.stage_performance_change_insights.is_empty() {
state.serialize_entry(
"stagePerformanceChangeInsights",
&self.stage_performance_change_insights,
)?;
}
if !self.table_change_insights.is_empty() {
state.serialize_entry("tableChangeInsights", &self.table_change_insights)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::StagePerformanceChangeInsight {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !wkt::internal::is_default(&self.stage_id) {
struct __With<'a>(&'a i64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
}
}
state.serialize_entry("stageId", &__With(&self.stage_id))?;
}
if self.input_data_change.is_some() {
state.serialize_entry("inputDataChange", &self.input_data_change)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::InputDataChange {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !wkt::internal::is_default(&self.records_read_diff_percentage) {
struct __With<'a>(&'a f32);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::F32>::serialize(self.0, serializer)
}
}
state.serialize_entry(
"recordsReadDiffPercentage",
&__With(&self.records_read_diff_percentage),
)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::StagePerformanceStandaloneInsight {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !wkt::internal::is_default(&self.stage_id) {
struct __With<'a>(&'a i64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
}
}
state.serialize_entry("stageId", &__With(&self.stage_id))?;
}
if self.slot_contention.is_some() {
state.serialize_entry("slotContention", &self.slot_contention)?;
}
if self.insufficient_shuffle_quota.is_some() {
state.serialize_entry("insufficientShuffleQuota", &self.insufficient_shuffle_quota)?;
}
if !self.bi_engine_reasons.is_empty() {
state.serialize_entry("biEngineReasons", &self.bi_engine_reasons)?;
}
if !self.high_cardinality_joins.is_empty() {
state.serialize_entry("highCardinalityJoins", &self.high_cardinality_joins)?;
}
if self.partition_skew.is_some() {
state.serialize_entry("partitionSkew", &self.partition_skew)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::HighCardinalityJoin {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !wkt::internal::is_default(&self.left_rows) {
struct __With<'a>(&'a i64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
}
}
state.serialize_entry("leftRows", &__With(&self.left_rows))?;
}
if !wkt::internal::is_default(&self.right_rows) {
struct __With<'a>(&'a i64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
}
}
state.serialize_entry("rightRows", &__With(&self.right_rows))?;
}
if !wkt::internal::is_default(&self.output_rows) {
struct __With<'a>(&'a i64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
}
}
state.serialize_entry("outputRows", &__With(&self.output_rows))?;
}
if !wkt::internal::is_default(&self.step_index) {
struct __With<'a>(&'a i32);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
}
}
state.serialize_entry("stepIndex", &__With(&self.step_index))?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::PartitionSkew {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.skew_sources.is_empty() {
state.serialize_entry("skewSources", &self.skew_sources)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::partition_skew::SkewSource {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !wkt::internal::is_default(&self.stage_id) {
struct __With<'a>(&'a i64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
}
}
state.serialize_entry("stageId", &__With(&self.stage_id))?;
}
if !wkt::internal::is_default(&self.output_bytes_median) {
struct __With<'a>(&'a i64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
}
}
state.serialize_entry("outputBytesMedian", &__With(&self.output_bytes_median))?;
}
if !wkt::internal::is_default(&self.output_bytes_p95) {
struct __With<'a>(&'a i64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
}
}
state.serialize_entry("outputBytesP95", &__With(&self.output_bytes_p95))?;
}
if !wkt::internal::is_default(&self.output_bytes_max) {
struct __With<'a>(&'a i64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
}
}
state.serialize_entry("outputBytesMax", &__With(&self.output_bytes_max))?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::TableChangeInsight {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.table_reference.is_some() {
state.serialize_entry("tableReference", &self.table_reference)?;
}
if self.metadata_cache_staleness_insight.is_some() {
state.serialize_entry(
"metadataCacheStalenessInsight",
&self.metadata_cache_staleness_insight,
)?;
}
if self.metadata_cache_not_used_but_used_previously.is_some() {
state.serialize_entry(
"metadataCacheNotUsedButUsedPreviously",
&self.metadata_cache_not_used_but_used_previously,
)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::MetadataCacheStalenessInsight {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.avg_previous_staleness_ms.is_some() {
state.serialize_entry("avgPreviousStalenessMs", &self.avg_previous_staleness_ms)?;
}
if !wkt::internal::is_default(&self.staleness_percentage_increase) {
struct __With<'a>(&'a f64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::F64>::serialize(self.0, serializer)
}
}
state.serialize_entry(
"stalenessPercentageIncrease",
&__With(&self.staleness_percentage_increase),
)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::SparkStatistics {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.spark_job_id.is_some() {
state.serialize_entry("sparkJobId", &self.spark_job_id)?;
}
if self.spark_job_location.is_some() {
state.serialize_entry("sparkJobLocation", &self.spark_job_location)?;
}
if !self.endpoints.is_empty() {
state.serialize_entry("endpoints", &self.endpoints)?;
}
if self.logging_info.is_some() {
state.serialize_entry("loggingInfo", &self.logging_info)?;
}
if self.kms_key_name.is_some() {
state.serialize_entry("kmsKeyName", &self.kms_key_name)?;
}
if self.gcs_staging_bucket.is_some() {
state.serialize_entry("gcsStagingBucket", &self.gcs_staging_bucket)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::spark_statistics::LoggingInfo {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.resource_type.is_empty() {
state.serialize_entry("resourceType", &self.resource_type)?;
}
if !self.project_id.is_empty() {
state.serialize_entry("projectId", &self.project_id)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::MaterializedViewStatistics {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.materialized_view.is_empty() {
state.serialize_entry("materializedView", &self.materialized_view)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::MaterializedView {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.table_reference.is_some() {
state.serialize_entry("tableReference", &self.table_reference)?;
}
if self.chosen.is_some() {
state.serialize_entry("chosen", &self.chosen)?;
}
if self.estimated_bytes_saved.is_some() {
struct __With<'a>(&'a std::option::Option<i64>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("estimatedBytesSaved", &__With(&self.estimated_bytes_saved))?;
}
if self.rejected_reason.is_some() {
state.serialize_entry("rejectedReason", &self.rejected_reason)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::PruningStats {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.post_cmeta_pruning_partition_count.is_some() {
struct __With<'a>(&'a std::option::Option<i64>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry(
"postCmetaPruningPartitionCount",
&__With(&self.post_cmeta_pruning_partition_count),
)?;
}
if self.pre_cmeta_pruning_parallel_input_count.is_some() {
struct __With<'a>(&'a std::option::Option<i64>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry(
"preCmetaPruningParallelInputCount",
&__With(&self.pre_cmeta_pruning_parallel_input_count),
)?;
}
if self.post_cmeta_pruning_parallel_input_count.is_some() {
struct __With<'a>(&'a std::option::Option<i64>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry(
"postCmetaPruningParallelInputCount",
&__With(&self.post_cmeta_pruning_parallel_input_count),
)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::TableMetadataCacheUsage {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.table_reference.is_some() {
state.serialize_entry("tableReference", &self.table_reference)?;
}
if self.unused_reason.is_some() {
state.serialize_entry("unusedReason", &self.unused_reason)?;
}
if self.explanation.is_some() {
state.serialize_entry("explanation", &self.explanation)?;
}
if self.staleness.is_some() {
state.serialize_entry("staleness", &self.staleness)?;
}
if !self.table_type.is_empty() {
state.serialize_entry("tableType", &self.table_type)?;
}
if self.pruning_stats.is_some() {
state.serialize_entry("pruningStats", &self.pruning_stats)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::MetadataCacheStatistics {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.table_metadata_cache_usage.is_empty() {
state.serialize_entry("tableMetadataCacheUsage", &self.table_metadata_cache_usage)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::JobStatus {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.error_result.is_some() {
state.serialize_entry("errorResult", &self.error_result)?;
}
if !self.errors.is_empty() {
state.serialize_entry("errors", &self.errors)?;
}
if !self.state.is_empty() {
state.serialize_entry("state", &self.state)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::LocationMetadata {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.legacy_location_id.is_empty() {
state.serialize_entry("legacyLocationId", &self.legacy_location_id)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::RemoteModelInfo {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if let Some(value) = self.endpoint() {
state.serialize_entry("endpoint", value)?;
}
if let Some(value) = self.remote_service_type() {
state.serialize_entry("remoteServiceType", value)?;
}
if !self.connection.is_empty() {
state.serialize_entry("connection", &self.connection)?;
}
if !wkt::internal::is_default(&self.max_batching_rows) {
struct __With<'a>(&'a i64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
}
}
state.serialize_entry("maxBatchingRows", &__With(&self.max_batching_rows))?;
}
if !self.remote_model_version.is_empty() {
state.serialize_entry("remoteModelVersion", &self.remote_model_version)?;
}
if !self.speech_recognizer.is_empty() {
state.serialize_entry("speechRecognizer", &self.speech_recognizer)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::TransformColumn {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.name.is_empty() {
state.serialize_entry("name", &self.name)?;
}
if self.r#type.is_some() {
state.serialize_entry("type", &self.r#type)?;
}
if !self.transform_sql.is_empty() {
state.serialize_entry("transformSql", &self.transform_sql)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::Model {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.etag.is_empty() {
state.serialize_entry("etag", &self.etag)?;
}
if self.model_reference.is_some() {
state.serialize_entry("modelReference", &self.model_reference)?;
}
if !wkt::internal::is_default(&self.creation_time) {
struct __With<'a>(&'a i64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
}
}
state.serialize_entry("creationTime", &__With(&self.creation_time))?;
}
if !wkt::internal::is_default(&self.last_modified_time) {
struct __With<'a>(&'a i64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
}
}
state.serialize_entry("lastModifiedTime", &__With(&self.last_modified_time))?;
}
if !self.description.is_empty() {
state.serialize_entry("description", &self.description)?;
}
if !self.friendly_name.is_empty() {
state.serialize_entry("friendlyName", &self.friendly_name)?;
}
if !self.labels.is_empty() {
state.serialize_entry("labels", &self.labels)?;
}
if !wkt::internal::is_default(&self.expiration_time) {
struct __With<'a>(&'a i64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
}
}
state.serialize_entry("expirationTime", &__With(&self.expiration_time))?;
}
if !self.location.is_empty() {
state.serialize_entry("location", &self.location)?;
}
if self.encryption_configuration.is_some() {
state.serialize_entry("encryptionConfiguration", &self.encryption_configuration)?;
}
if !wkt::internal::is_default(&self.model_type) {
state.serialize_entry("modelType", &self.model_type)?;
}
if !self.training_runs.is_empty() {
state.serialize_entry("trainingRuns", &self.training_runs)?;
}
if !self.feature_columns.is_empty() {
state.serialize_entry("featureColumns", &self.feature_columns)?;
}
if !self.label_columns.is_empty() {
state.serialize_entry("labelColumns", &self.label_columns)?;
}
if !self.transform_columns.is_empty() {
state.serialize_entry("transformColumns", &self.transform_columns)?;
}
if self.hparam_search_spaces.is_some() {
state.serialize_entry("hparamSearchSpaces", &self.hparam_search_spaces)?;
}
if !wkt::internal::is_default(&self.default_trial_id) {
struct __With<'a>(&'a i64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
}
}
state.serialize_entry("defaultTrialId", &__With(&self.default_trial_id))?;
}
if !self.hparam_trials.is_empty() {
state.serialize_entry("hparamTrials", &self.hparam_trials)?;
}
if !self.optimal_trial_ids.is_empty() {
struct __With<'a>(&'a std::vec::Vec<i64>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::vec::Vec<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("optimalTrialIds", &__With(&self.optimal_trial_ids))?;
}
if self.remote_model_info.is_some() {
state.serialize_entry("remoteModelInfo", &self.remote_model_info)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::model::SeasonalPeriod {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::model::KmeansEnums {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::model::BoostedTreeOptionEnums {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::model::HparamTuningEnums {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::model::RegressionMetrics {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.mean_absolute_error.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::DoubleValue>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("meanAbsoluteError", &__With(&self.mean_absolute_error))?;
}
if self.mean_squared_error.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::DoubleValue>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("meanSquaredError", &__With(&self.mean_squared_error))?;
}
if self.mean_squared_log_error.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::DoubleValue>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("meanSquaredLogError", &__With(&self.mean_squared_log_error))?;
}
if self.median_absolute_error.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::DoubleValue>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("medianAbsoluteError", &__With(&self.median_absolute_error))?;
}
if self.r_squared.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::DoubleValue>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("rSquared", &__With(&self.r_squared))?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::model::AggregateClassificationMetrics {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.precision.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::DoubleValue>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("precision", &__With(&self.precision))?;
}
if self.recall.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::DoubleValue>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("recall", &__With(&self.recall))?;
}
if self.accuracy.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::DoubleValue>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("accuracy", &__With(&self.accuracy))?;
}
if self.threshold.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::DoubleValue>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("threshold", &__With(&self.threshold))?;
}
if self.f1_score.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::DoubleValue>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("f1Score", &__With(&self.f1_score))?;
}
if self.log_loss.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::DoubleValue>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("logLoss", &__With(&self.log_loss))?;
}
if self.roc_auc.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::DoubleValue>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("rocAuc", &__With(&self.roc_auc))?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::model::BinaryClassificationMetrics {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.aggregate_classification_metrics.is_some() {
state.serialize_entry(
"aggregateClassificationMetrics",
&self.aggregate_classification_metrics,
)?;
}
if !self.binary_confusion_matrix_list.is_empty() {
state.serialize_entry(
"binaryConfusionMatrixList",
&self.binary_confusion_matrix_list,
)?;
}
if !self.positive_label.is_empty() {
state.serialize_entry("positiveLabel", &self.positive_label)?;
}
if !self.negative_label.is_empty() {
state.serialize_entry("negativeLabel", &self.negative_label)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::model::binary_classification_metrics::BinaryConfusionMatrix {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.positive_class_threshold.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::DoubleValue>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry(
"positiveClassThreshold",
&__With(&self.positive_class_threshold),
)?;
}
if self.true_positives.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("truePositives", &__With(&self.true_positives))?;
}
if self.false_positives.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("falsePositives", &__With(&self.false_positives))?;
}
if self.true_negatives.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("trueNegatives", &__With(&self.true_negatives))?;
}
if self.false_negatives.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("falseNegatives", &__With(&self.false_negatives))?;
}
if self.precision.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::DoubleValue>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("precision", &__With(&self.precision))?;
}
if self.recall.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::DoubleValue>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("recall", &__With(&self.recall))?;
}
if self.f1_score.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::DoubleValue>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("f1Score", &__With(&self.f1_score))?;
}
if self.accuracy.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::DoubleValue>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("accuracy", &__With(&self.accuracy))?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::model::MultiClassClassificationMetrics {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.aggregate_classification_metrics.is_some() {
state.serialize_entry(
"aggregateClassificationMetrics",
&self.aggregate_classification_metrics,
)?;
}
if !self.confusion_matrix_list.is_empty() {
state.serialize_entry("confusionMatrixList", &self.confusion_matrix_list)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::model::multi_class_classification_metrics::ConfusionMatrix {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.confidence_threshold.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::DoubleValue>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("confidenceThreshold", &__With(&self.confidence_threshold))?;
}
if !self.rows.is_empty() {
state.serialize_entry("rows", &self.rows)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize
for super::model::multi_class_classification_metrics::confusion_matrix::Entry
{
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.predicted_label.is_empty() {
state.serialize_entry("predictedLabel", &self.predicted_label)?;
}
if self.item_count.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("itemCount", &__With(&self.item_count))?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize
for super::model::multi_class_classification_metrics::confusion_matrix::Row
{
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.actual_label.is_empty() {
state.serialize_entry("actualLabel", &self.actual_label)?;
}
if !self.entries.is_empty() {
state.serialize_entry("entries", &self.entries)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::model::ClusteringMetrics {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.davies_bouldin_index.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::DoubleValue>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("daviesBouldinIndex", &__With(&self.davies_bouldin_index))?;
}
if self.mean_squared_distance.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::DoubleValue>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("meanSquaredDistance", &__With(&self.mean_squared_distance))?;
}
if !self.clusters.is_empty() {
state.serialize_entry("clusters", &self.clusters)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::model::clustering_metrics::Cluster {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !wkt::internal::is_default(&self.centroid_id) {
struct __With<'a>(&'a i64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
}
}
state.serialize_entry("centroidId", &__With(&self.centroid_id))?;
}
if !self.feature_values.is_empty() {
state.serialize_entry("featureValues", &self.feature_values)?;
}
if self.count.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("count", &__With(&self.count))?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::model::clustering_metrics::cluster::FeatureValue {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.feature_column.is_empty() {
state.serialize_entry("featureColumn", &self.feature_column)?;
}
if let Some(value) = self.numerical_value() {
struct __With<'a>(&'a std::boxed::Box<wkt::DoubleValue>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::F64>::serialize(self.0, serializer)
}
}
state.serialize_entry("numericalValue", &__With(value))?;
}
if let Some(value) = self.categorical_value() {
state.serialize_entry("categoricalValue", value)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize
for super::model::clustering_metrics::cluster::feature_value::CategoricalValue
{
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.category_counts.is_empty() {
state.serialize_entry("categoryCounts", &self.category_counts)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize
for super::model::clustering_metrics::cluster::feature_value::categorical_value::CategoryCount
{
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.category.is_empty() {
state.serialize_entry("category", &self.category)?;
}
if self.count.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("count", &__With(&self.count))?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::model::RankingMetrics {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.mean_average_precision.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::DoubleValue>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry(
"meanAveragePrecision",
&__With(&self.mean_average_precision),
)?;
}
if self.mean_squared_error.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::DoubleValue>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("meanSquaredError", &__With(&self.mean_squared_error))?;
}
if self.normalized_discounted_cumulative_gain.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::DoubleValue>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry(
"normalizedDiscountedCumulativeGain",
&__With(&self.normalized_discounted_cumulative_gain),
)?;
}
if self.average_rank.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::DoubleValue>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("averageRank", &__With(&self.average_rank))?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::model::ArimaForecastingMetrics {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.arima_single_model_forecasting_metrics.is_empty() {
state.serialize_entry(
"arimaSingleModelForecastingMetrics",
&self.arima_single_model_forecasting_metrics,
)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize
for super::model::arima_forecasting_metrics::ArimaSingleModelForecastingMetrics
{
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.non_seasonal_order.is_some() {
state.serialize_entry("nonSeasonalOrder", &self.non_seasonal_order)?;
}
if self.arima_fitting_metrics.is_some() {
state.serialize_entry("arimaFittingMetrics", &self.arima_fitting_metrics)?;
}
if self.has_drift.is_some() {
state.serialize_entry("hasDrift", &self.has_drift)?;
}
if !self.time_series_id.is_empty() {
state.serialize_entry("timeSeriesId", &self.time_series_id)?;
}
if !self.time_series_ids.is_empty() {
state.serialize_entry("timeSeriesIds", &self.time_series_ids)?;
}
if !self.seasonal_periods.is_empty() {
state.serialize_entry("seasonalPeriods", &self.seasonal_periods)?;
}
if self.has_holiday_effect.is_some() {
state.serialize_entry("hasHolidayEffect", &self.has_holiday_effect)?;
}
if self.has_spikes_and_dips.is_some() {
state.serialize_entry("hasSpikesAndDips", &self.has_spikes_and_dips)?;
}
if self.has_step_changes.is_some() {
state.serialize_entry("hasStepChanges", &self.has_step_changes)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::model::DimensionalityReductionMetrics {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.total_explained_variance_ratio.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::DoubleValue>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry(
"totalExplainedVarianceRatio",
&__With(&self.total_explained_variance_ratio),
)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::model::EvaluationMetrics {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if let Some(value) = self.regression_metrics() {
state.serialize_entry("regressionMetrics", value)?;
}
if let Some(value) = self.binary_classification_metrics() {
state.serialize_entry("binaryClassificationMetrics", value)?;
}
if let Some(value) = self.multi_class_classification_metrics() {
state.serialize_entry("multiClassClassificationMetrics", value)?;
}
if let Some(value) = self.clustering_metrics() {
state.serialize_entry("clusteringMetrics", value)?;
}
if let Some(value) = self.ranking_metrics() {
state.serialize_entry("rankingMetrics", value)?;
}
if let Some(value) = self.arima_forecasting_metrics() {
state.serialize_entry("arimaForecastingMetrics", value)?;
}
if let Some(value) = self.dimensionality_reduction_metrics() {
state.serialize_entry("dimensionalityReductionMetrics", value)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::model::DataSplitResult {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.training_table.is_some() {
state.serialize_entry("trainingTable", &self.training_table)?;
}
if self.evaluation_table.is_some() {
state.serialize_entry("evaluationTable", &self.evaluation_table)?;
}
if self.test_table.is_some() {
state.serialize_entry("testTable", &self.test_table)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::model::ArimaOrder {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.p.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("p", &__With(&self.p))?;
}
if self.d.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("d", &__With(&self.d))?;
}
if self.q.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("q", &__With(&self.q))?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::model::ArimaFittingMetrics {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.log_likelihood.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::DoubleValue>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("logLikelihood", &__With(&self.log_likelihood))?;
}
if self.aic.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::DoubleValue>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("aic", &__With(&self.aic))?;
}
if self.variance.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::DoubleValue>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("variance", &__With(&self.variance))?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::model::GlobalExplanation {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.explanations.is_empty() {
state.serialize_entry("explanations", &self.explanations)?;
}
if !self.class_label.is_empty() {
state.serialize_entry("classLabel", &self.class_label)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::model::global_explanation::Explanation {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.feature_name.is_empty() {
state.serialize_entry("featureName", &self.feature_name)?;
}
if self.attribution.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::DoubleValue>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("attribution", &__With(&self.attribution))?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::model::CategoryEncodingMethod {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::model::PcaSolverOptionEnums {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::model::ModelRegistryOptionEnums {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::model::TrainingRun {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.training_options.is_some() {
state.serialize_entry("trainingOptions", &self.training_options)?;
}
if self.start_time.is_some() {
state.serialize_entry("startTime", &self.start_time)?;
}
if !self.results.is_empty() {
state.serialize_entry("results", &self.results)?;
}
if self.evaluation_metrics.is_some() {
state.serialize_entry("evaluationMetrics", &self.evaluation_metrics)?;
}
if self.data_split_result.is_some() {
state.serialize_entry("dataSplitResult", &self.data_split_result)?;
}
if self.model_level_global_explanation.is_some() {
state.serialize_entry(
"modelLevelGlobalExplanation",
&self.model_level_global_explanation,
)?;
}
if !self.class_level_global_explanations.is_empty() {
state.serialize_entry(
"classLevelGlobalExplanations",
&self.class_level_global_explanations,
)?;
}
if !self.vertex_ai_model_id.is_empty() {
state.serialize_entry("vertexAiModelId", &self.vertex_ai_model_id)?;
}
if !self.vertex_ai_model_version.is_empty() {
state.serialize_entry("vertexAiModelVersion", &self.vertex_ai_model_version)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::model::training_run::TrainingOptions {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !wkt::internal::is_default(&self.max_iterations) {
struct __With<'a>(&'a i64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
}
}
state.serialize_entry("maxIterations", &__With(&self.max_iterations))?;
}
if !wkt::internal::is_default(&self.loss_type) {
state.serialize_entry("lossType", &self.loss_type)?;
}
if !wkt::internal::is_default(&self.learn_rate) {
struct __With<'a>(&'a f64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::F64>::serialize(self.0, serializer)
}
}
state.serialize_entry("learnRate", &__With(&self.learn_rate))?;
}
if self.l1_regularization.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::DoubleValue>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("l1Regularization", &__With(&self.l1_regularization))?;
}
if self.l2_regularization.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::DoubleValue>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("l2Regularization", &__With(&self.l2_regularization))?;
}
if self.min_relative_progress.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::DoubleValue>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("minRelativeProgress", &__With(&self.min_relative_progress))?;
}
if self.warm_start.is_some() {
state.serialize_entry("warmStart", &self.warm_start)?;
}
if self.early_stop.is_some() {
state.serialize_entry("earlyStop", &self.early_stop)?;
}
if !self.input_label_columns.is_empty() {
state.serialize_entry("inputLabelColumns", &self.input_label_columns)?;
}
if !wkt::internal::is_default(&self.data_split_method) {
state.serialize_entry("dataSplitMethod", &self.data_split_method)?;
}
if !wkt::internal::is_default(&self.data_split_eval_fraction) {
struct __With<'a>(&'a f64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::F64>::serialize(self.0, serializer)
}
}
state.serialize_entry(
"dataSplitEvalFraction",
&__With(&self.data_split_eval_fraction),
)?;
}
if !self.data_split_column.is_empty() {
state.serialize_entry("dataSplitColumn", &self.data_split_column)?;
}
if !wkt::internal::is_default(&self.learn_rate_strategy) {
state.serialize_entry("learnRateStrategy", &self.learn_rate_strategy)?;
}
if !wkt::internal::is_default(&self.initial_learn_rate) {
struct __With<'a>(&'a f64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::F64>::serialize(self.0, serializer)
}
}
state.serialize_entry("initialLearnRate", &__With(&self.initial_learn_rate))?;
}
if !self.label_class_weights.is_empty() {
struct __With<'a>(&'a std::collections::HashMap<std::string::String, f64>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::< std::collections::HashMap<serde_with::Same, wkt::internal::F64> >::serialize(self.0, serializer)
}
}
state.serialize_entry("labelClassWeights", &__With(&self.label_class_weights))?;
}
if !self.user_column.is_empty() {
state.serialize_entry("userColumn", &self.user_column)?;
}
if !self.item_column.is_empty() {
state.serialize_entry("itemColumn", &self.item_column)?;
}
if !wkt::internal::is_default(&self.distance_type) {
state.serialize_entry("distanceType", &self.distance_type)?;
}
if !wkt::internal::is_default(&self.num_clusters) {
struct __With<'a>(&'a i64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
}
}
state.serialize_entry("numClusters", &__With(&self.num_clusters))?;
}
if !self.model_uri.is_empty() {
state.serialize_entry("modelUri", &self.model_uri)?;
}
if !wkt::internal::is_default(&self.optimization_strategy) {
state.serialize_entry("optimizationStrategy", &self.optimization_strategy)?;
}
if !self.hidden_units.is_empty() {
struct __With<'a>(&'a std::vec::Vec<i64>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::vec::Vec<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("hiddenUnits", &__With(&self.hidden_units))?;
}
if !wkt::internal::is_default(&self.batch_size) {
struct __With<'a>(&'a i64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
}
}
state.serialize_entry("batchSize", &__With(&self.batch_size))?;
}
if self.dropout.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::DoubleValue>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("dropout", &__With(&self.dropout))?;
}
if !wkt::internal::is_default(&self.max_tree_depth) {
struct __With<'a>(&'a i64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
}
}
state.serialize_entry("maxTreeDepth", &__With(&self.max_tree_depth))?;
}
if !wkt::internal::is_default(&self.subsample) {
struct __With<'a>(&'a f64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::F64>::serialize(self.0, serializer)
}
}
state.serialize_entry("subsample", &__With(&self.subsample))?;
}
if self.min_split_loss.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::DoubleValue>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("minSplitLoss", &__With(&self.min_split_loss))?;
}
if !wkt::internal::is_default(&self.booster_type) {
state.serialize_entry("boosterType", &self.booster_type)?;
}
if self.num_parallel_tree.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("numParallelTree", &__With(&self.num_parallel_tree))?;
}
if !wkt::internal::is_default(&self.dart_normalize_type) {
state.serialize_entry("dartNormalizeType", &self.dart_normalize_type)?;
}
if !wkt::internal::is_default(&self.tree_method) {
state.serialize_entry("treeMethod", &self.tree_method)?;
}
if self.min_tree_child_weight.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("minTreeChildWeight", &__With(&self.min_tree_child_weight))?;
}
if self.colsample_bytree.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::DoubleValue>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("colsampleBytree", &__With(&self.colsample_bytree))?;
}
if self.colsample_bylevel.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::DoubleValue>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("colsampleBylevel", &__With(&self.colsample_bylevel))?;
}
if self.colsample_bynode.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::DoubleValue>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("colsampleBynode", &__With(&self.colsample_bynode))?;
}
if !wkt::internal::is_default(&self.num_factors) {
struct __With<'a>(&'a i64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
}
}
state.serialize_entry("numFactors", &__With(&self.num_factors))?;
}
if !wkt::internal::is_default(&self.feedback_type) {
state.serialize_entry("feedbackType", &self.feedback_type)?;
}
if self.wals_alpha.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::DoubleValue>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("walsAlpha", &__With(&self.wals_alpha))?;
}
if !wkt::internal::is_default(&self.kmeans_initialization_method) {
state.serialize_entry(
"kmeansInitializationMethod",
&self.kmeans_initialization_method,
)?;
}
if !self.kmeans_initialization_column.is_empty() {
state.serialize_entry(
"kmeansInitializationColumn",
&self.kmeans_initialization_column,
)?;
}
if !self.time_series_timestamp_column.is_empty() {
state.serialize_entry(
"timeSeriesTimestampColumn",
&self.time_series_timestamp_column,
)?;
}
if !self.time_series_data_column.is_empty() {
state.serialize_entry("timeSeriesDataColumn", &self.time_series_data_column)?;
}
if self.auto_arima.is_some() {
state.serialize_entry("autoArima", &self.auto_arima)?;
}
if self.non_seasonal_order.is_some() {
state.serialize_entry("nonSeasonalOrder", &self.non_seasonal_order)?;
}
if !wkt::internal::is_default(&self.data_frequency) {
state.serialize_entry("dataFrequency", &self.data_frequency)?;
}
if self.calculate_p_values.is_some() {
state.serialize_entry("calculatePValues", &self.calculate_p_values)?;
}
if self.include_drift.is_some() {
state.serialize_entry("includeDrift", &self.include_drift)?;
}
if !wkt::internal::is_default(&self.holiday_region) {
state.serialize_entry("holidayRegion", &self.holiday_region)?;
}
if !self.holiday_regions.is_empty() {
state.serialize_entry("holidayRegions", &self.holiday_regions)?;
}
if !self.time_series_id_column.is_empty() {
state.serialize_entry("timeSeriesIdColumn", &self.time_series_id_column)?;
}
if !self.time_series_id_columns.is_empty() {
state.serialize_entry("timeSeriesIdColumns", &self.time_series_id_columns)?;
}
if !wkt::internal::is_default(&self.forecast_limit_lower_bound) {
struct __With<'a>(&'a f64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::F64>::serialize(self.0, serializer)
}
}
state.serialize_entry(
"forecastLimitLowerBound",
&__With(&self.forecast_limit_lower_bound),
)?;
}
if !wkt::internal::is_default(&self.forecast_limit_upper_bound) {
struct __With<'a>(&'a f64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::F64>::serialize(self.0, serializer)
}
}
state.serialize_entry(
"forecastLimitUpperBound",
&__With(&self.forecast_limit_upper_bound),
)?;
}
if !wkt::internal::is_default(&self.horizon) {
struct __With<'a>(&'a i64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
}
}
state.serialize_entry("horizon", &__With(&self.horizon))?;
}
if !wkt::internal::is_default(&self.auto_arima_max_order) {
struct __With<'a>(&'a i64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
}
}
state.serialize_entry("autoArimaMaxOrder", &__With(&self.auto_arima_max_order))?;
}
if !wkt::internal::is_default(&self.auto_arima_min_order) {
struct __With<'a>(&'a i64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
}
}
state.serialize_entry("autoArimaMinOrder", &__With(&self.auto_arima_min_order))?;
}
if !wkt::internal::is_default(&self.num_trials) {
struct __With<'a>(&'a i64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
}
}
state.serialize_entry("numTrials", &__With(&self.num_trials))?;
}
if !wkt::internal::is_default(&self.max_parallel_trials) {
struct __With<'a>(&'a i64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
}
}
state.serialize_entry("maxParallelTrials", &__With(&self.max_parallel_trials))?;
}
if !self.hparam_tuning_objectives.is_empty() {
state.serialize_entry("hparamTuningObjectives", &self.hparam_tuning_objectives)?;
}
if self.decompose_time_series.is_some() {
state.serialize_entry("decomposeTimeSeries", &self.decompose_time_series)?;
}
if self.clean_spikes_and_dips.is_some() {
state.serialize_entry("cleanSpikesAndDips", &self.clean_spikes_and_dips)?;
}
if self.adjust_step_changes.is_some() {
state.serialize_entry("adjustStepChanges", &self.adjust_step_changes)?;
}
if self.enable_global_explain.is_some() {
state.serialize_entry("enableGlobalExplain", &self.enable_global_explain)?;
}
if !wkt::internal::is_default(&self.sampled_shapley_num_paths) {
struct __With<'a>(&'a i64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
}
}
state.serialize_entry(
"sampledShapleyNumPaths",
&__With(&self.sampled_shapley_num_paths),
)?;
}
if !wkt::internal::is_default(&self.integrated_gradients_num_steps) {
struct __With<'a>(&'a i64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
}
}
state.serialize_entry(
"integratedGradientsNumSteps",
&__With(&self.integrated_gradients_num_steps),
)?;
}
if !wkt::internal::is_default(&self.category_encoding_method) {
state.serialize_entry("categoryEncodingMethod", &self.category_encoding_method)?;
}
if !self.tf_version.is_empty() {
state.serialize_entry("tfVersion", &self.tf_version)?;
}
if !wkt::internal::is_default(&self.color_space) {
state.serialize_entry("colorSpace", &self.color_space)?;
}
if !self.instance_weight_column.is_empty() {
state.serialize_entry("instanceWeightColumn", &self.instance_weight_column)?;
}
if !wkt::internal::is_default(&self.trend_smoothing_window_size) {
struct __With<'a>(&'a i64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
}
}
state.serialize_entry(
"trendSmoothingWindowSize",
&__With(&self.trend_smoothing_window_size),
)?;
}
if !wkt::internal::is_default(&self.time_series_length_fraction) {
struct __With<'a>(&'a f64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::F64>::serialize(self.0, serializer)
}
}
state.serialize_entry(
"timeSeriesLengthFraction",
&__With(&self.time_series_length_fraction),
)?;
}
if !wkt::internal::is_default(&self.min_time_series_length) {
struct __With<'a>(&'a i64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
}
}
state.serialize_entry("minTimeSeriesLength", &__With(&self.min_time_series_length))?;
}
if !wkt::internal::is_default(&self.max_time_series_length) {
struct __With<'a>(&'a i64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
}
}
state.serialize_entry("maxTimeSeriesLength", &__With(&self.max_time_series_length))?;
}
if !self.xgboost_version.is_empty() {
state.serialize_entry("xgboostVersion", &self.xgboost_version)?;
}
if self.approx_global_feature_contrib.is_some() {
state.serialize_entry(
"approxGlobalFeatureContrib",
&self.approx_global_feature_contrib,
)?;
}
if self.fit_intercept.is_some() {
state.serialize_entry("fitIntercept", &self.fit_intercept)?;
}
if !wkt::internal::is_default(&self.num_principal_components) {
struct __With<'a>(&'a i64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
}
}
state.serialize_entry(
"numPrincipalComponents",
&__With(&self.num_principal_components),
)?;
}
if !wkt::internal::is_default(&self.pca_explained_variance_ratio) {
struct __With<'a>(&'a f64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::F64>::serialize(self.0, serializer)
}
}
state.serialize_entry(
"pcaExplainedVarianceRatio",
&__With(&self.pca_explained_variance_ratio),
)?;
}
if self.scale_features.is_some() {
state.serialize_entry("scaleFeatures", &self.scale_features)?;
}
if !wkt::internal::is_default(&self.pca_solver) {
state.serialize_entry("pcaSolver", &self.pca_solver)?;
}
if self.auto_class_weights.is_some() {
state.serialize_entry("autoClassWeights", &self.auto_class_weights)?;
}
if !self.activation_fn.is_empty() {
state.serialize_entry("activationFn", &self.activation_fn)?;
}
if !self.optimizer.is_empty() {
state.serialize_entry("optimizer", &self.optimizer)?;
}
if !wkt::internal::is_default(&self.budget_hours) {
struct __With<'a>(&'a f64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::F64>::serialize(self.0, serializer)
}
}
state.serialize_entry("budgetHours", &__With(&self.budget_hours))?;
}
if self.standardize_features.is_some() {
state.serialize_entry("standardizeFeatures", &self.standardize_features)?;
}
if !wkt::internal::is_default(&self.l1_reg_activation) {
struct __With<'a>(&'a f64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::F64>::serialize(self.0, serializer)
}
}
state.serialize_entry("l1RegActivation", &__With(&self.l1_reg_activation))?;
}
if !wkt::internal::is_default(&self.model_registry) {
state.serialize_entry("modelRegistry", &self.model_registry)?;
}
if !self.vertex_ai_model_version_aliases.is_empty() {
state.serialize_entry(
"vertexAiModelVersionAliases",
&self.vertex_ai_model_version_aliases,
)?;
}
if !self.dimension_id_columns.is_empty() {
state.serialize_entry("dimensionIdColumns", &self.dimension_id_columns)?;
}
if self.contribution_metric.is_some() {
state.serialize_entry("contributionMetric", &self.contribution_metric)?;
}
if self.is_test_column.is_some() {
state.serialize_entry("isTestColumn", &self.is_test_column)?;
}
if self.min_apriori_support.is_some() {
struct __With<'a>(&'a std::option::Option<f64>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("minAprioriSupport", &__With(&self.min_apriori_support))?;
}
if let Some(value) = self.hugging_face_model_id() {
state.serialize_entry("huggingFaceModelId", value)?;
}
if let Some(value) = self.model_garden_model_name() {
state.serialize_entry("modelGardenModelName", value)?;
}
if self.endpoint_idle_ttl.is_some() {
state.serialize_entry("endpointIdleTtl", &self.endpoint_idle_ttl)?;
}
if self.machine_type.is_some() {
state.serialize_entry("machineType", &self.machine_type)?;
}
if self.min_replica_count.is_some() {
struct __With<'a>(&'a std::option::Option<i64>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("minReplicaCount", &__With(&self.min_replica_count))?;
}
if self.max_replica_count.is_some() {
struct __With<'a>(&'a std::option::Option<i64>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("maxReplicaCount", &__With(&self.max_replica_count))?;
}
if self.reservation_affinity_type.is_some() {
state.serialize_entry("reservationAffinityType", &self.reservation_affinity_type)?;
}
if self.reservation_affinity_key.is_some() {
state.serialize_entry("reservationAffinityKey", &self.reservation_affinity_key)?;
}
if !self.reservation_affinity_values.is_empty() {
state.serialize_entry(
"reservationAffinityValues",
&self.reservation_affinity_values,
)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::model::training_run::IterationResult {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.index.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int32Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I32>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("index", &__With(&self.index))?;
}
if self.duration_ms.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("durationMs", &__With(&self.duration_ms))?;
}
if self.training_loss.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::DoubleValue>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("trainingLoss", &__With(&self.training_loss))?;
}
if self.eval_loss.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::DoubleValue>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("evalLoss", &__With(&self.eval_loss))?;
}
if !wkt::internal::is_default(&self.learn_rate) {
struct __With<'a>(&'a f64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::F64>::serialize(self.0, serializer)
}
}
state.serialize_entry("learnRate", &__With(&self.learn_rate))?;
}
if !self.cluster_infos.is_empty() {
state.serialize_entry("clusterInfos", &self.cluster_infos)?;
}
if self.arima_result.is_some() {
state.serialize_entry("arimaResult", &self.arima_result)?;
}
if !self.principal_component_infos.is_empty() {
state.serialize_entry("principalComponentInfos", &self.principal_component_infos)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::model::training_run::iteration_result::ClusterInfo {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !wkt::internal::is_default(&self.centroid_id) {
struct __With<'a>(&'a i64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
}
}
state.serialize_entry("centroidId", &__With(&self.centroid_id))?;
}
if self.cluster_radius.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::DoubleValue>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("clusterRadius", &__With(&self.cluster_radius))?;
}
if self.cluster_size.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("clusterSize", &__With(&self.cluster_size))?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::model::training_run::iteration_result::ArimaResult {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.arima_model_info.is_empty() {
state.serialize_entry("arimaModelInfo", &self.arima_model_info)?;
}
if !self.seasonal_periods.is_empty() {
state.serialize_entry("seasonalPeriods", &self.seasonal_periods)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize
for super::model::training_run::iteration_result::arima_result::ArimaCoefficients
{
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.auto_regressive_coefficients.is_empty() {
struct __With<'a>(&'a std::vec::Vec<f64>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::vec::Vec<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry(
"autoRegressiveCoefficients",
&__With(&self.auto_regressive_coefficients),
)?;
}
if !self.moving_average_coefficients.is_empty() {
struct __With<'a>(&'a std::vec::Vec<f64>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::vec::Vec<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry(
"movingAverageCoefficients",
&__With(&self.moving_average_coefficients),
)?;
}
if self.intercept_coefficient.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::DoubleValue>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("interceptCoefficient", &__With(&self.intercept_coefficient))?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize
for super::model::training_run::iteration_result::arima_result::ArimaModelInfo
{
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.non_seasonal_order.is_some() {
state.serialize_entry("nonSeasonalOrder", &self.non_seasonal_order)?;
}
if self.arima_coefficients.is_some() {
state.serialize_entry("arimaCoefficients", &self.arima_coefficients)?;
}
if self.arima_fitting_metrics.is_some() {
state.serialize_entry("arimaFittingMetrics", &self.arima_fitting_metrics)?;
}
if self.has_drift.is_some() {
state.serialize_entry("hasDrift", &self.has_drift)?;
}
if !self.time_series_id.is_empty() {
state.serialize_entry("timeSeriesId", &self.time_series_id)?;
}
if !self.time_series_ids.is_empty() {
state.serialize_entry("timeSeriesIds", &self.time_series_ids)?;
}
if !self.seasonal_periods.is_empty() {
state.serialize_entry("seasonalPeriods", &self.seasonal_periods)?;
}
if self.has_holiday_effect.is_some() {
state.serialize_entry("hasHolidayEffect", &self.has_holiday_effect)?;
}
if self.has_spikes_and_dips.is_some() {
state.serialize_entry("hasSpikesAndDips", &self.has_spikes_and_dips)?;
}
if self.has_step_changes.is_some() {
state.serialize_entry("hasStepChanges", &self.has_step_changes)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize
for super::model::training_run::iteration_result::PrincipalComponentInfo
{
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.principal_component_id.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry(
"principalComponentId",
&__With(&self.principal_component_id),
)?;
}
if self.explained_variance.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::DoubleValue>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("explainedVariance", &__With(&self.explained_variance))?;
}
if self.explained_variance_ratio.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::DoubleValue>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry(
"explainedVarianceRatio",
&__With(&self.explained_variance_ratio),
)?;
}
if self.cumulative_explained_variance_ratio.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::DoubleValue>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry(
"cumulativeExplainedVarianceRatio",
&__With(&self.cumulative_explained_variance_ratio),
)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::model::DoubleHparamSearchSpace {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if let Some(value) = self.range() {
state.serialize_entry("range", value)?;
}
if let Some(value) = self.candidates() {
state.serialize_entry("candidates", value)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::model::double_hparam_search_space::DoubleRange {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.min.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::DoubleValue>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("min", &__With(&self.min))?;
}
if self.max.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::DoubleValue>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("max", &__With(&self.max))?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::model::double_hparam_search_space::DoubleCandidates {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.candidates.is_empty() {
struct __With<'a>(&'a std::vec::Vec<wkt::DoubleValue>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::vec::Vec<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("candidates", &__With(&self.candidates))?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::model::IntHparamSearchSpace {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if let Some(value) = self.range() {
state.serialize_entry("range", value)?;
}
if let Some(value) = self.candidates() {
state.serialize_entry("candidates", value)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::model::int_hparam_search_space::IntRange {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.min.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("min", &__With(&self.min))?;
}
if self.max.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("max", &__With(&self.max))?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::model::int_hparam_search_space::IntCandidates {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.candidates.is_empty() {
struct __With<'a>(&'a std::vec::Vec<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::vec::Vec<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("candidates", &__With(&self.candidates))?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::model::StringHparamSearchSpace {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.candidates.is_empty() {
state.serialize_entry("candidates", &self.candidates)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::model::IntArrayHparamSearchSpace {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.candidates.is_empty() {
state.serialize_entry("candidates", &self.candidates)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::model::int_array_hparam_search_space::IntArray {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.elements.is_empty() {
struct __With<'a>(&'a std::vec::Vec<i64>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::vec::Vec<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("elements", &__With(&self.elements))?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::model::HparamSearchSpaces {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.learn_rate.is_some() {
state.serialize_entry("learnRate", &self.learn_rate)?;
}
if self.l1_reg.is_some() {
state.serialize_entry("l1Reg", &self.l1_reg)?;
}
if self.l2_reg.is_some() {
state.serialize_entry("l2Reg", &self.l2_reg)?;
}
if self.num_clusters.is_some() {
state.serialize_entry("numClusters", &self.num_clusters)?;
}
if self.num_factors.is_some() {
state.serialize_entry("numFactors", &self.num_factors)?;
}
if self.hidden_units.is_some() {
state.serialize_entry("hiddenUnits", &self.hidden_units)?;
}
if self.batch_size.is_some() {
state.serialize_entry("batchSize", &self.batch_size)?;
}
if self.dropout.is_some() {
state.serialize_entry("dropout", &self.dropout)?;
}
if self.max_tree_depth.is_some() {
state.serialize_entry("maxTreeDepth", &self.max_tree_depth)?;
}
if self.subsample.is_some() {
state.serialize_entry("subsample", &self.subsample)?;
}
if self.min_split_loss.is_some() {
state.serialize_entry("minSplitLoss", &self.min_split_loss)?;
}
if self.wals_alpha.is_some() {
state.serialize_entry("walsAlpha", &self.wals_alpha)?;
}
if self.booster_type.is_some() {
state.serialize_entry("boosterType", &self.booster_type)?;
}
if self.num_parallel_tree.is_some() {
state.serialize_entry("numParallelTree", &self.num_parallel_tree)?;
}
if self.dart_normalize_type.is_some() {
state.serialize_entry("dartNormalizeType", &self.dart_normalize_type)?;
}
if self.tree_method.is_some() {
state.serialize_entry("treeMethod", &self.tree_method)?;
}
if self.min_tree_child_weight.is_some() {
state.serialize_entry("minTreeChildWeight", &self.min_tree_child_weight)?;
}
if self.colsample_bytree.is_some() {
state.serialize_entry("colsampleBytree", &self.colsample_bytree)?;
}
if self.colsample_bylevel.is_some() {
state.serialize_entry("colsampleBylevel", &self.colsample_bylevel)?;
}
if self.colsample_bynode.is_some() {
state.serialize_entry("colsampleBynode", &self.colsample_bynode)?;
}
if self.activation_fn.is_some() {
state.serialize_entry("activationFn", &self.activation_fn)?;
}
if self.optimizer.is_some() {
state.serialize_entry("optimizer", &self.optimizer)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::model::HparamTuningTrial {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !wkt::internal::is_default(&self.trial_id) {
struct __With<'a>(&'a i64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
}
}
state.serialize_entry("trialId", &__With(&self.trial_id))?;
}
if !wkt::internal::is_default(&self.start_time_ms) {
struct __With<'a>(&'a i64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
}
}
state.serialize_entry("startTimeMs", &__With(&self.start_time_ms))?;
}
if !wkt::internal::is_default(&self.end_time_ms) {
struct __With<'a>(&'a i64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
}
}
state.serialize_entry("endTimeMs", &__With(&self.end_time_ms))?;
}
if self.hparams.is_some() {
state.serialize_entry("hparams", &self.hparams)?;
}
if self.evaluation_metrics.is_some() {
state.serialize_entry("evaluationMetrics", &self.evaluation_metrics)?;
}
if !wkt::internal::is_default(&self.status) {
state.serialize_entry("status", &self.status)?;
}
if !self.error_message.is_empty() {
state.serialize_entry("errorMessage", &self.error_message)?;
}
if self.training_loss.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::DoubleValue>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("trainingLoss", &__With(&self.training_loss))?;
}
if self.eval_loss.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::DoubleValue>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("evalLoss", &__With(&self.eval_loss))?;
}
if self.hparam_tuning_evaluation_metrics.is_some() {
state.serialize_entry(
"hparamTuningEvaluationMetrics",
&self.hparam_tuning_evaluation_metrics,
)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::GetModelRequest {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.project_id.is_empty() {
state.serialize_entry("projectId", &self.project_id)?;
}
if !self.dataset_id.is_empty() {
state.serialize_entry("datasetId", &self.dataset_id)?;
}
if !self.model_id.is_empty() {
state.serialize_entry("modelId", &self.model_id)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::PatchModelRequest {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.project_id.is_empty() {
state.serialize_entry("projectId", &self.project_id)?;
}
if !self.dataset_id.is_empty() {
state.serialize_entry("datasetId", &self.dataset_id)?;
}
if !self.model_id.is_empty() {
state.serialize_entry("modelId", &self.model_id)?;
}
if self.model.is_some() {
state.serialize_entry("model", &self.model)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::DeleteModelRequest {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.project_id.is_empty() {
state.serialize_entry("projectId", &self.project_id)?;
}
if !self.dataset_id.is_empty() {
state.serialize_entry("datasetId", &self.dataset_id)?;
}
if !self.model_id.is_empty() {
state.serialize_entry("modelId", &self.model_id)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::ListModelsRequest {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.project_id.is_empty() {
state.serialize_entry("projectId", &self.project_id)?;
}
if !self.dataset_id.is_empty() {
state.serialize_entry("datasetId", &self.dataset_id)?;
}
if self.max_results.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::UInt32Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::U32>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("maxResults", &__With(&self.max_results))?;
}
if !self.page_token.is_empty() {
state.serialize_entry("pageToken", &self.page_token)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::ListModelsResponse {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.models.is_empty() {
state.serialize_entry("models", &self.models)?;
}
if !self.next_page_token.is_empty() {
state.serialize_entry("nextPageToken", &self.next_page_token)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::ModelReference {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.project_id.is_empty() {
state.serialize_entry("projectId", &self.project_id)?;
}
if !self.dataset_id.is_empty() {
state.serialize_entry("datasetId", &self.dataset_id)?;
}
if !self.model_id.is_empty() {
state.serialize_entry("modelId", &self.model_id)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::PartitioningDefinition {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.partitioned_column.is_empty() {
state.serialize_entry("partitionedColumn", &self.partitioned_column)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::PartitionedColumn {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.field.is_some() {
state.serialize_entry("field", &self.field)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::AggregationThresholdPolicy {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.threshold.is_some() {
struct __With<'a>(&'a std::option::Option<i64>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("threshold", &__With(&self.threshold))?;
}
if !self.privacy_unit_columns.is_empty() {
state.serialize_entry("privacyUnitColumns", &self.privacy_unit_columns)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::DifferentialPrivacyPolicy {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.max_epsilon_per_query.is_some() {
struct __With<'a>(&'a std::option::Option<f64>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("maxEpsilonPerQuery", &__With(&self.max_epsilon_per_query))?;
}
if self.delta_per_query.is_some() {
struct __With<'a>(&'a std::option::Option<f64>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("deltaPerQuery", &__With(&self.delta_per_query))?;
}
if self.max_groups_contributed.is_some() {
struct __With<'a>(&'a std::option::Option<i64>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry(
"maxGroupsContributed",
&__With(&self.max_groups_contributed),
)?;
}
if self.privacy_unit_column.is_some() {
state.serialize_entry("privacyUnitColumn", &self.privacy_unit_column)?;
}
if self.epsilon_budget.is_some() {
struct __With<'a>(&'a std::option::Option<f64>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("epsilonBudget", &__With(&self.epsilon_budget))?;
}
if self.delta_budget.is_some() {
struct __With<'a>(&'a std::option::Option<f64>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("deltaBudget", &__With(&self.delta_budget))?;
}
if self.epsilon_budget_remaining.is_some() {
struct __With<'a>(&'a std::option::Option<f64>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry(
"epsilonBudgetRemaining",
&__With(&self.epsilon_budget_remaining),
)?;
}
if self.delta_budget_remaining.is_some() {
struct __With<'a>(&'a std::option::Option<f64>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry(
"deltaBudgetRemaining",
&__With(&self.delta_budget_remaining),
)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::JoinRestrictionPolicy {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.join_condition.is_some() {
state.serialize_entry("joinCondition", &self.join_condition)?;
}
if !self.join_allowed_columns.is_empty() {
state.serialize_entry("joinAllowedColumns", &self.join_allowed_columns)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::PrivacyPolicy {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if let Some(value) = self.aggregation_threshold_policy() {
state.serialize_entry("aggregationThresholdPolicy", value)?;
}
if let Some(value) = self.differential_privacy_policy() {
state.serialize_entry("differentialPrivacyPolicy", value)?;
}
if self.join_restriction_policy.is_some() {
state.serialize_entry("joinRestrictionPolicy", &self.join_restriction_policy)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::GetServiceAccountRequest {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.project_id.is_empty() {
state.serialize_entry("projectId", &self.project_id)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::GetServiceAccountResponse {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.kind.is_empty() {
state.serialize_entry("kind", &self.kind)?;
}
if !self.email.is_empty() {
state.serialize_entry("email", &self.email)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::PropertyGraphReference {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.project_id.is_empty() {
state.serialize_entry("projectId", &self.project_id)?;
}
if !self.dataset_id.is_empty() {
state.serialize_entry("datasetId", &self.dataset_id)?;
}
if !self.property_graph_id.is_empty() {
state.serialize_entry("propertyGraphId", &self.property_graph_id)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::QueryParameterStructType {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.name.is_empty() {
state.serialize_entry("name", &self.name)?;
}
if self.r#type.is_some() {
state.serialize_entry("type", &self.r#type)?;
}
if !self.description.is_empty() {
state.serialize_entry("description", &self.description)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::QueryParameterType {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.r#type.is_empty() {
state.serialize_entry("type", &self.r#type)?;
}
if self.timestamp_precision.is_some() {
struct __With<'a>(&'a std::option::Option<i64>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("timestampPrecision", &__With(&self.timestamp_precision))?;
}
if self.array_type.is_some() {
state.serialize_entry("arrayType", &self.array_type)?;
}
if !self.struct_types.is_empty() {
state.serialize_entry("structTypes", &self.struct_types)?;
}
if self.range_element_type.is_some() {
state.serialize_entry("rangeElementType", &self.range_element_type)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::RangeValue {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.start.is_some() {
state.serialize_entry("start", &self.start)?;
}
if self.end.is_some() {
state.serialize_entry("end", &self.end)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::QueryParameterValue {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.value.is_some() {
state.serialize_entry("value", &self.value)?;
}
if !self.array_values.is_empty() {
state.serialize_entry("arrayValues", &self.array_values)?;
}
if !self.struct_values.is_empty() {
state.serialize_entry("structValues", &self.struct_values)?;
}
if self.range_value.is_some() {
state.serialize_entry("rangeValue", &self.range_value)?;
}
if !self.alt_struct_values.is_empty() {
state.serialize_entry("altStructValues", &self.alt_struct_values)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::QueryParameter {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.name.is_empty() {
state.serialize_entry("name", &self.name)?;
}
if self.parameter_type.is_some() {
state.serialize_entry("parameterType", &self.parameter_type)?;
}
if self.parameter_value.is_some() {
state.serialize_entry("parameterValue", &self.parameter_value)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::RangePartitioning {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.field.is_empty() {
state.serialize_entry("field", &self.field)?;
}
if self.range.is_some() {
state.serialize_entry("range", &self.range)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::range_partitioning::Range {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.start.is_empty() {
state.serialize_entry("start", &self.start)?;
}
if !self.end.is_empty() {
state.serialize_entry("end", &self.end)?;
}
if !self.interval.is_empty() {
state.serialize_entry("interval", &self.interval)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::RestrictionConfig {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !wkt::internal::is_default(&self.r#type) {
state.serialize_entry("type", &self.r#type)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::Routine {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.etag.is_empty() {
state.serialize_entry("etag", &self.etag)?;
}
if self.routine_reference.is_some() {
state.serialize_entry("routineReference", &self.routine_reference)?;
}
if !wkt::internal::is_default(&self.routine_type) {
state.serialize_entry("routineType", &self.routine_type)?;
}
if !wkt::internal::is_default(&self.creation_time) {
struct __With<'a>(&'a i64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
}
}
state.serialize_entry("creationTime", &__With(&self.creation_time))?;
}
if !wkt::internal::is_default(&self.last_modified_time) {
struct __With<'a>(&'a i64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
}
}
state.serialize_entry("lastModifiedTime", &__With(&self.last_modified_time))?;
}
if !wkt::internal::is_default(&self.language) {
state.serialize_entry("language", &self.language)?;
}
if !self.arguments.is_empty() {
state.serialize_entry("arguments", &self.arguments)?;
}
if self.return_type.is_some() {
state.serialize_entry("returnType", &self.return_type)?;
}
if self.return_table_type.is_some() {
state.serialize_entry("returnTableType", &self.return_table_type)?;
}
if !self.imported_libraries.is_empty() {
state.serialize_entry("importedLibraries", &self.imported_libraries)?;
}
if !self.definition_body.is_empty() {
state.serialize_entry("definitionBody", &self.definition_body)?;
}
if !self.description.is_empty() {
state.serialize_entry("description", &self.description)?;
}
if !wkt::internal::is_default(&self.determinism_level) {
state.serialize_entry("determinismLevel", &self.determinism_level)?;
}
if !wkt::internal::is_default(&self.security_mode) {
state.serialize_entry("securityMode", &self.security_mode)?;
}
if self.strict_mode.is_some() {
state.serialize_entry("strictMode", &self.strict_mode)?;
}
if self.remote_function_options.is_some() {
state.serialize_entry("remoteFunctionOptions", &self.remote_function_options)?;
}
if self.spark_options.is_some() {
state.serialize_entry("sparkOptions", &self.spark_options)?;
}
if !wkt::internal::is_default(&self.data_governance_type) {
state.serialize_entry("dataGovernanceType", &self.data_governance_type)?;
}
if self.python_options.is_some() {
state.serialize_entry("pythonOptions", &self.python_options)?;
}
if self.external_runtime_options.is_some() {
state.serialize_entry("externalRuntimeOptions", &self.external_runtime_options)?;
}
if self.build_status.is_some() {
state.serialize_entry("buildStatus", &self.build_status)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::routine::Argument {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.name.is_empty() {
state.serialize_entry("name", &self.name)?;
}
if !wkt::internal::is_default(&self.argument_kind) {
state.serialize_entry("argumentKind", &self.argument_kind)?;
}
if !wkt::internal::is_default(&self.mode) {
state.serialize_entry("mode", &self.mode)?;
}
if self.data_type.is_some() {
state.serialize_entry("dataType", &self.data_type)?;
}
if self.table_type.is_some() {
state.serialize_entry("tableType", &self.table_type)?;
}
if self.is_aggregate.is_some() {
state.serialize_entry("isAggregate", &self.is_aggregate)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::routine::RemoteFunctionOptions {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.endpoint.is_empty() {
state.serialize_entry("endpoint", &self.endpoint)?;
}
if !self.connection.is_empty() {
state.serialize_entry("connection", &self.connection)?;
}
if !self.user_defined_context.is_empty() {
state.serialize_entry("userDefinedContext", &self.user_defined_context)?;
}
if !wkt::internal::is_default(&self.max_batching_rows) {
struct __With<'a>(&'a i64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
}
}
state.serialize_entry("maxBatchingRows", &__With(&self.max_batching_rows))?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::PythonOptions {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.entry_point.is_empty() {
state.serialize_entry("entryPoint", &self.entry_point)?;
}
if !self.packages.is_empty() {
state.serialize_entry("packages", &self.packages)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::ExternalRuntimeOptions {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.container_memory.is_empty() {
state.serialize_entry("containerMemory", &self.container_memory)?;
}
if !wkt::internal::is_default(&self.container_cpu) {
struct __With<'a>(&'a f64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::F64>::serialize(self.0, serializer)
}
}
state.serialize_entry("containerCpu", &__With(&self.container_cpu))?;
}
if !self.runtime_connection.is_empty() {
state.serialize_entry("runtimeConnection", &self.runtime_connection)?;
}
if !wkt::internal::is_default(&self.max_batching_rows) {
struct __With<'a>(&'a i64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
}
}
state.serialize_entry("maxBatchingRows", &__With(&self.max_batching_rows))?;
}
if !self.runtime_version.is_empty() {
state.serialize_entry("runtimeVersion", &self.runtime_version)?;
}
if !wkt::internal::is_default(&self.container_request_concurrency) {
struct __With<'a>(&'a i64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
}
}
state.serialize_entry(
"containerRequestConcurrency",
&__With(&self.container_request_concurrency),
)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::SparkOptions {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.connection.is_empty() {
state.serialize_entry("connection", &self.connection)?;
}
if !self.runtime_version.is_empty() {
state.serialize_entry("runtimeVersion", &self.runtime_version)?;
}
if !self.container_image.is_empty() {
state.serialize_entry("containerImage", &self.container_image)?;
}
if !self.properties.is_empty() {
state.serialize_entry("properties", &self.properties)?;
}
if !self.main_file_uri.is_empty() {
state.serialize_entry("mainFileUri", &self.main_file_uri)?;
}
if !self.py_file_uris.is_empty() {
state.serialize_entry("pyFileUris", &self.py_file_uris)?;
}
if !self.jar_uris.is_empty() {
state.serialize_entry("jarUris", &self.jar_uris)?;
}
if !self.file_uris.is_empty() {
state.serialize_entry("fileUris", &self.file_uris)?;
}
if !self.archive_uris.is_empty() {
state.serialize_entry("archiveUris", &self.archive_uris)?;
}
if !self.main_class.is_empty() {
state.serialize_entry("mainClass", &self.main_class)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::RoutineBuildStatus {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !wkt::internal::is_default(&self.build_state) {
state.serialize_entry("buildState", &self.build_state)?;
}
if self.error_result.is_some() {
state.serialize_entry("errorResult", &self.error_result)?;
}
if self.build_state_update_time.is_some() {
state.serialize_entry("buildStateUpdateTime", &self.build_state_update_time)?;
}
if self.build_duration.is_some() {
state.serialize_entry("buildDuration", &self.build_duration)?;
}
if !wkt::internal::is_default(&self.image_size_bytes) {
struct __With<'a>(&'a i64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
}
}
state.serialize_entry("imageSizeBytes", &__With(&self.image_size_bytes))?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::GetRoutineRequest {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.project_id.is_empty() {
state.serialize_entry("projectId", &self.project_id)?;
}
if !self.dataset_id.is_empty() {
state.serialize_entry("datasetId", &self.dataset_id)?;
}
if !self.routine_id.is_empty() {
state.serialize_entry("routineId", &self.routine_id)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::InsertRoutineRequest {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.project_id.is_empty() {
state.serialize_entry("projectId", &self.project_id)?;
}
if !self.dataset_id.is_empty() {
state.serialize_entry("datasetId", &self.dataset_id)?;
}
if self.routine.is_some() {
state.serialize_entry("routine", &self.routine)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::UpdateRoutineRequest {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.project_id.is_empty() {
state.serialize_entry("projectId", &self.project_id)?;
}
if !self.dataset_id.is_empty() {
state.serialize_entry("datasetId", &self.dataset_id)?;
}
if !self.routine_id.is_empty() {
state.serialize_entry("routineId", &self.routine_id)?;
}
if self.routine.is_some() {
state.serialize_entry("routine", &self.routine)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::DeleteRoutineRequest {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.project_id.is_empty() {
state.serialize_entry("projectId", &self.project_id)?;
}
if !self.dataset_id.is_empty() {
state.serialize_entry("datasetId", &self.dataset_id)?;
}
if !self.routine_id.is_empty() {
state.serialize_entry("routineId", &self.routine_id)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::ListRoutinesRequest {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.project_id.is_empty() {
state.serialize_entry("projectId", &self.project_id)?;
}
if !self.dataset_id.is_empty() {
state.serialize_entry("datasetId", &self.dataset_id)?;
}
if self.max_results.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::UInt32Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::U32>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("maxResults", &__With(&self.max_results))?;
}
if !self.page_token.is_empty() {
state.serialize_entry("pageToken", &self.page_token)?;
}
if !self.filter.is_empty() {
state.serialize_entry("filter", &self.filter)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::ListRoutinesResponse {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.routines.is_empty() {
state.serialize_entry("routines", &self.routines)?;
}
if !self.next_page_token.is_empty() {
state.serialize_entry("nextPageToken", &self.next_page_token)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::RoutineReference {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.project_id.is_empty() {
state.serialize_entry("projectId", &self.project_id)?;
}
if !self.dataset_id.is_empty() {
state.serialize_entry("datasetId", &self.dataset_id)?;
}
if !self.routine_id.is_empty() {
state.serialize_entry("routineId", &self.routine_id)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::ListRowAccessPoliciesRequest {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.project_id.is_empty() {
state.serialize_entry("projectId", &self.project_id)?;
}
if !self.dataset_id.is_empty() {
state.serialize_entry("datasetId", &self.dataset_id)?;
}
if !self.table_id.is_empty() {
state.serialize_entry("tableId", &self.table_id)?;
}
if !self.page_token.is_empty() {
state.serialize_entry("pageToken", &self.page_token)?;
}
if !wkt::internal::is_default(&self.page_size) {
struct __With<'a>(&'a i32);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
}
}
state.serialize_entry("pageSize", &__With(&self.page_size))?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::ListRowAccessPoliciesResponse {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.row_access_policies.is_empty() {
state.serialize_entry("rowAccessPolicies", &self.row_access_policies)?;
}
if !self.next_page_token.is_empty() {
state.serialize_entry("nextPageToken", &self.next_page_token)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::GetRowAccessPolicyRequest {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.project_id.is_empty() {
state.serialize_entry("projectId", &self.project_id)?;
}
if !self.dataset_id.is_empty() {
state.serialize_entry("datasetId", &self.dataset_id)?;
}
if !self.table_id.is_empty() {
state.serialize_entry("tableId", &self.table_id)?;
}
if !self.policy_id.is_empty() {
state.serialize_entry("policyId", &self.policy_id)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::CreateRowAccessPolicyRequest {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.project_id.is_empty() {
state.serialize_entry("projectId", &self.project_id)?;
}
if !self.dataset_id.is_empty() {
state.serialize_entry("datasetId", &self.dataset_id)?;
}
if !self.table_id.is_empty() {
state.serialize_entry("tableId", &self.table_id)?;
}
if self.row_access_policy.is_some() {
state.serialize_entry("rowAccessPolicy", &self.row_access_policy)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::UpdateRowAccessPolicyRequest {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.project_id.is_empty() {
state.serialize_entry("projectId", &self.project_id)?;
}
if !self.dataset_id.is_empty() {
state.serialize_entry("datasetId", &self.dataset_id)?;
}
if !self.table_id.is_empty() {
state.serialize_entry("tableId", &self.table_id)?;
}
if !self.policy_id.is_empty() {
state.serialize_entry("policyId", &self.policy_id)?;
}
if self.row_access_policy.is_some() {
state.serialize_entry("rowAccessPolicy", &self.row_access_policy)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::DeleteRowAccessPolicyRequest {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.project_id.is_empty() {
state.serialize_entry("projectId", &self.project_id)?;
}
if !self.dataset_id.is_empty() {
state.serialize_entry("datasetId", &self.dataset_id)?;
}
if !self.table_id.is_empty() {
state.serialize_entry("tableId", &self.table_id)?;
}
if !self.policy_id.is_empty() {
state.serialize_entry("policyId", &self.policy_id)?;
}
if self.force.is_some() {
state.serialize_entry("force", &self.force)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::BatchDeleteRowAccessPoliciesRequest {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.project_id.is_empty() {
state.serialize_entry("projectId", &self.project_id)?;
}
if !self.dataset_id.is_empty() {
state.serialize_entry("datasetId", &self.dataset_id)?;
}
if !self.table_id.is_empty() {
state.serialize_entry("tableId", &self.table_id)?;
}
if !self.policy_ids.is_empty() {
state.serialize_entry("policyIds", &self.policy_ids)?;
}
if self.force.is_some() {
state.serialize_entry("force", &self.force)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::RowAccessPolicy {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.etag.is_empty() {
state.serialize_entry("etag", &self.etag)?;
}
if self.row_access_policy_reference.is_some() {
state.serialize_entry(
"rowAccessPolicyReference",
&self.row_access_policy_reference,
)?;
}
if !self.filter_predicate.is_empty() {
state.serialize_entry("filterPredicate", &self.filter_predicate)?;
}
if self.creation_time.is_some() {
state.serialize_entry("creationTime", &self.creation_time)?;
}
if self.last_modified_time.is_some() {
state.serialize_entry("lastModifiedTime", &self.last_modified_time)?;
}
if !self.grantees.is_empty() {
state.serialize_entry("grantees", &self.grantees)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::RowAccessPolicyReference {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.project_id.is_empty() {
state.serialize_entry("projectId", &self.project_id)?;
}
if !self.dataset_id.is_empty() {
state.serialize_entry("datasetId", &self.dataset_id)?;
}
if !self.table_id.is_empty() {
state.serialize_entry("tableId", &self.table_id)?;
}
if !self.policy_id.is_empty() {
state.serialize_entry("policyId", &self.policy_id)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::SessionInfo {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.session_id.is_empty() {
state.serialize_entry("sessionId", &self.session_id)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::StandardSqlDataType {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !wkt::internal::is_default(&self.type_kind) {
state.serialize_entry("typeKind", &self.type_kind)?;
}
if let Some(value) = self.array_element_type() {
state.serialize_entry("arrayElementType", value)?;
}
if let Some(value) = self.struct_type() {
state.serialize_entry("structType", value)?;
}
if let Some(value) = self.range_element_type() {
state.serialize_entry("rangeElementType", value)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::StandardSqlField {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.name.is_empty() {
state.serialize_entry("name", &self.name)?;
}
if self.r#type.is_some() {
state.serialize_entry("type", &self.r#type)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::StandardSqlStructType {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.fields.is_empty() {
state.serialize_entry("fields", &self.fields)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::StandardSqlTableType {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.columns.is_empty() {
state.serialize_entry("columns", &self.columns)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::SystemVariables {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.types.is_empty() {
state.serialize_entry("types", &self.types)?;
}
if self.values.is_some() {
state.serialize_entry("values", &self.values)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::TableReplicationInfo {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.source_table.is_some() {
state.serialize_entry("sourceTable", &self.source_table)?;
}
if !wkt::internal::is_default(&self.replication_interval_ms) {
struct __With<'a>(&'a i64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
}
}
state.serialize_entry(
"replicationIntervalMs",
&__With(&self.replication_interval_ms),
)?;
}
if !wkt::internal::is_default(&self.replicated_source_last_refresh_time) {
struct __With<'a>(&'a i64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
}
}
state.serialize_entry(
"replicatedSourceLastRefreshTime",
&__With(&self.replicated_source_last_refresh_time),
)?;
}
if !wkt::internal::is_default(&self.replication_status) {
state.serialize_entry("replicationStatus", &self.replication_status)?;
}
if self.replication_error.is_some() {
state.serialize_entry("replicationError", &self.replication_error)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::ViewDefinition {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.query.is_empty() {
state.serialize_entry("query", &self.query)?;
}
if !self.user_defined_function_resources.is_empty() {
state.serialize_entry(
"userDefinedFunctionResources",
&self.user_defined_function_resources,
)?;
}
if self.use_legacy_sql.is_some() {
state.serialize_entry("useLegacySql", &self.use_legacy_sql)?;
}
if !wkt::internal::is_default(&self.use_explicit_column_names) {
state.serialize_entry("useExplicitColumnNames", &self.use_explicit_column_names)?;
}
if self.privacy_policy.is_some() {
state.serialize_entry("privacyPolicy", &self.privacy_policy)?;
}
if !self.foreign_definitions.is_empty() {
state.serialize_entry("foreignDefinitions", &self.foreign_definitions)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::ForeignViewDefinition {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.query.is_empty() {
state.serialize_entry("query", &self.query)?;
}
if !self.dialect.is_empty() {
state.serialize_entry("dialect", &self.dialect)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::MaterializedViewDefinition {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.query.is_empty() {
state.serialize_entry("query", &self.query)?;
}
if !wkt::internal::is_default(&self.last_refresh_time) {
struct __With<'a>(&'a i64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
}
}
state.serialize_entry("lastRefreshTime", &__With(&self.last_refresh_time))?;
}
if self.enable_refresh.is_some() {
state.serialize_entry("enableRefresh", &self.enable_refresh)?;
}
if self.refresh_interval_ms.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::UInt64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::U64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("refreshIntervalMs", &__With(&self.refresh_interval_ms))?;
}
if self.allow_non_incremental_definition.is_some() {
state.serialize_entry(
"allowNonIncrementalDefinition",
&self.allow_non_incremental_definition,
)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::MaterializedViewStatus {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.refresh_watermark.is_some() {
state.serialize_entry("refreshWatermark", &self.refresh_watermark)?;
}
if self.last_refresh_status.is_some() {
state.serialize_entry("lastRefreshStatus", &self.last_refresh_status)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::SnapshotDefinition {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.base_table_reference.is_some() {
state.serialize_entry("baseTableReference", &self.base_table_reference)?;
}
if self.snapshot_time.is_some() {
state.serialize_entry("snapshotTime", &self.snapshot_time)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::CloneDefinition {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.base_table_reference.is_some() {
state.serialize_entry("baseTableReference", &self.base_table_reference)?;
}
if self.clone_time.is_some() {
state.serialize_entry("cloneTime", &self.clone_time)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::Streamingbuffer {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !wkt::internal::is_default(&self.estimated_bytes) {
struct __With<'a>(&'a u64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::U64>::serialize(self.0, serializer)
}
}
state.serialize_entry("estimatedBytes", &__With(&self.estimated_bytes))?;
}
if !wkt::internal::is_default(&self.estimated_rows) {
struct __With<'a>(&'a u64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::U64>::serialize(self.0, serializer)
}
}
state.serialize_entry("estimatedRows", &__With(&self.estimated_rows))?;
}
if !wkt::internal::is_default(&self.oldest_entry_time) {
struct __With<'a>(&'a u64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::U64>::serialize(self.0, serializer)
}
}
state.serialize_entry("oldestEntryTime", &__With(&self.oldest_entry_time))?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::Table {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.kind.is_empty() {
state.serialize_entry("kind", &self.kind)?;
}
if !self.etag.is_empty() {
state.serialize_entry("etag", &self.etag)?;
}
if !self.id.is_empty() {
state.serialize_entry("id", &self.id)?;
}
if !self.self_link.is_empty() {
state.serialize_entry("selfLink", &self.self_link)?;
}
if self.table_reference.is_some() {
state.serialize_entry("tableReference", &self.table_reference)?;
}
if self.friendly_name.is_some() {
state.serialize_entry("friendlyName", &self.friendly_name)?;
}
if self.description.is_some() {
state.serialize_entry("description", &self.description)?;
}
if !self.labels.is_empty() {
state.serialize_entry("labels", &self.labels)?;
}
if self.schema.is_some() {
state.serialize_entry("schema", &self.schema)?;
}
if self.time_partitioning.is_some() {
state.serialize_entry("timePartitioning", &self.time_partitioning)?;
}
if self.range_partitioning.is_some() {
state.serialize_entry("rangePartitioning", &self.range_partitioning)?;
}
if self.clustering.is_some() {
state.serialize_entry("clustering", &self.clustering)?;
}
if self.require_partition_filter.is_some() {
state.serialize_entry("requirePartitionFilter", &self.require_partition_filter)?;
}
if self.partition_definition.is_some() {
state.serialize_entry("partitionDefinition", &self.partition_definition)?;
}
if self.num_bytes.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("numBytes", &__With(&self.num_bytes))?;
}
if self.num_physical_bytes.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("numPhysicalBytes", &__With(&self.num_physical_bytes))?;
}
if self.num_long_term_bytes.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("numLongTermBytes", &__With(&self.num_long_term_bytes))?;
}
if self.num_rows.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::UInt64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::U64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("numRows", &__With(&self.num_rows))?;
}
if !wkt::internal::is_default(&self.creation_time) {
struct __With<'a>(&'a i64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
}
}
state.serialize_entry("creationTime", &__With(&self.creation_time))?;
}
if self.expiration_time.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("expirationTime", &__With(&self.expiration_time))?;
}
if !wkt::internal::is_default(&self.last_modified_time) {
struct __With<'a>(&'a u64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::U64>::serialize(self.0, serializer)
}
}
state.serialize_entry("lastModifiedTime", &__With(&self.last_modified_time))?;
}
if !self.r#type.is_empty() {
state.serialize_entry("type", &self.r#type)?;
}
if self.view.is_some() {
state.serialize_entry("view", &self.view)?;
}
if self.materialized_view.is_some() {
state.serialize_entry("materializedView", &self.materialized_view)?;
}
if self.materialized_view_status.is_some() {
state.serialize_entry("materializedViewStatus", &self.materialized_view_status)?;
}
if self.external_data_configuration.is_some() {
state.serialize_entry(
"externalDataConfiguration",
&self.external_data_configuration,
)?;
}
if self.biglake_configuration.is_some() {
state.serialize_entry("biglakeConfiguration", &self.biglake_configuration)?;
}
if !wkt::internal::is_default(&self.managed_table_type) {
state.serialize_entry("managedTableType", &self.managed_table_type)?;
}
if !self.location.is_empty() {
state.serialize_entry("location", &self.location)?;
}
if self.streaming_buffer.is_some() {
state.serialize_entry("streamingBuffer", &self.streaming_buffer)?;
}
if self.encryption_configuration.is_some() {
state.serialize_entry("encryptionConfiguration", &self.encryption_configuration)?;
}
if self.snapshot_definition.is_some() {
state.serialize_entry("snapshotDefinition", &self.snapshot_definition)?;
}
if self.default_collation.is_some() {
state.serialize_entry("defaultCollation", &self.default_collation)?;
}
if !wkt::internal::is_default(&self.default_rounding_mode) {
state.serialize_entry("defaultRoundingMode", &self.default_rounding_mode)?;
}
if self.clone_definition.is_some() {
state.serialize_entry("cloneDefinition", &self.clone_definition)?;
}
if self.num_time_travel_physical_bytes.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry(
"numTimeTravelPhysicalBytes",
&__With(&self.num_time_travel_physical_bytes),
)?;
}
if self.num_total_logical_bytes.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry(
"numTotalLogicalBytes",
&__With(&self.num_total_logical_bytes),
)?;
}
if self.num_active_logical_bytes.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry(
"numActiveLogicalBytes",
&__With(&self.num_active_logical_bytes),
)?;
}
if self.num_long_term_logical_bytes.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry(
"numLongTermLogicalBytes",
&__With(&self.num_long_term_logical_bytes),
)?;
}
if self.num_current_physical_bytes.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry(
"numCurrentPhysicalBytes",
&__With(&self.num_current_physical_bytes),
)?;
}
if self.num_total_physical_bytes.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry(
"numTotalPhysicalBytes",
&__With(&self.num_total_physical_bytes),
)?;
}
if self.num_active_physical_bytes.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry(
"numActivePhysicalBytes",
&__With(&self.num_active_physical_bytes),
)?;
}
if self.num_long_term_physical_bytes.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry(
"numLongTermPhysicalBytes",
&__With(&self.num_long_term_physical_bytes),
)?;
}
if self.num_partitions.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("numPartitions", &__With(&self.num_partitions))?;
}
if !self.max_staleness.is_empty() {
state.serialize_entry("maxStaleness", &self.max_staleness)?;
}
if self.restrictions.is_some() {
state.serialize_entry("restrictions", &self.restrictions)?;
}
if self.table_constraints.is_some() {
state.serialize_entry("tableConstraints", &self.table_constraints)?;
}
if !self.resource_tags.is_empty() {
state.serialize_entry("resourceTags", &self.resource_tags)?;
}
if self.table_replication_info.is_some() {
state.serialize_entry("tableReplicationInfo", &self.table_replication_info)?;
}
if !self.replicas.is_empty() {
state.serialize_entry("replicas", &self.replicas)?;
}
if self.external_catalog_table_options.is_some() {
state.serialize_entry(
"externalCatalogTableOptions",
&self.external_catalog_table_options,
)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::GetTableRequest {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.project_id.is_empty() {
state.serialize_entry("projectId", &self.project_id)?;
}
if !self.dataset_id.is_empty() {
state.serialize_entry("datasetId", &self.dataset_id)?;
}
if !self.table_id.is_empty() {
state.serialize_entry("tableId", &self.table_id)?;
}
if !self.selected_fields.is_empty() {
state.serialize_entry("selectedFields", &self.selected_fields)?;
}
if !wkt::internal::is_default(&self.view) {
state.serialize_entry("view", &self.view)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::InsertTableRequest {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.project_id.is_empty() {
state.serialize_entry("projectId", &self.project_id)?;
}
if !self.dataset_id.is_empty() {
state.serialize_entry("datasetId", &self.dataset_id)?;
}
if self.table.is_some() {
state.serialize_entry("table", &self.table)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::UpdateOrPatchTableRequest {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.project_id.is_empty() {
state.serialize_entry("projectId", &self.project_id)?;
}
if !self.dataset_id.is_empty() {
state.serialize_entry("datasetId", &self.dataset_id)?;
}
if !self.table_id.is_empty() {
state.serialize_entry("tableId", &self.table_id)?;
}
if self.table.is_some() {
state.serialize_entry("table", &self.table)?;
}
if !wkt::internal::is_default(&self.autodetect_schema) {
state.serialize_entry("autodetectSchema", &self.autodetect_schema)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::DeleteTableRequest {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.project_id.is_empty() {
state.serialize_entry("projectId", &self.project_id)?;
}
if !self.dataset_id.is_empty() {
state.serialize_entry("datasetId", &self.dataset_id)?;
}
if !self.table_id.is_empty() {
state.serialize_entry("tableId", &self.table_id)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::ListTablesRequest {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.project_id.is_empty() {
state.serialize_entry("projectId", &self.project_id)?;
}
if !self.dataset_id.is_empty() {
state.serialize_entry("datasetId", &self.dataset_id)?;
}
if self.max_results.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::UInt32Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::U32>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("maxResults", &__With(&self.max_results))?;
}
if !self.page_token.is_empty() {
state.serialize_entry("pageToken", &self.page_token)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::ListFormatView {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.use_legacy_sql.is_some() {
state.serialize_entry("useLegacySql", &self.use_legacy_sql)?;
}
if self.privacy_policy.is_some() {
state.serialize_entry("privacyPolicy", &self.privacy_policy)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::ListFormatTable {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.kind.is_empty() {
state.serialize_entry("kind", &self.kind)?;
}
if !self.id.is_empty() {
state.serialize_entry("id", &self.id)?;
}
if self.table_reference.is_some() {
state.serialize_entry("tableReference", &self.table_reference)?;
}
if self.friendly_name.is_some() {
state.serialize_entry("friendlyName", &self.friendly_name)?;
}
if !self.r#type.is_empty() {
state.serialize_entry("type", &self.r#type)?;
}
if self.time_partitioning.is_some() {
state.serialize_entry("timePartitioning", &self.time_partitioning)?;
}
if self.range_partitioning.is_some() {
state.serialize_entry("rangePartitioning", &self.range_partitioning)?;
}
if self.clustering.is_some() {
state.serialize_entry("clustering", &self.clustering)?;
}
if !self.labels.is_empty() {
state.serialize_entry("labels", &self.labels)?;
}
if self.view.is_some() {
state.serialize_entry("view", &self.view)?;
}
if !wkt::internal::is_default(&self.creation_time) {
struct __With<'a>(&'a i64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
}
}
state.serialize_entry("creationTime", &__With(&self.creation_time))?;
}
if !wkt::internal::is_default(&self.expiration_time) {
struct __With<'a>(&'a i64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
}
}
state.serialize_entry("expirationTime", &__With(&self.expiration_time))?;
}
if self.require_partition_filter.is_some() {
state.serialize_entry("requirePartitionFilter", &self.require_partition_filter)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::TableList {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.kind.is_empty() {
state.serialize_entry("kind", &self.kind)?;
}
if !self.etag.is_empty() {
state.serialize_entry("etag", &self.etag)?;
}
if !self.next_page_token.is_empty() {
state.serialize_entry("nextPageToken", &self.next_page_token)?;
}
if !self.tables.is_empty() {
state.serialize_entry("tables", &self.tables)?;
}
if self.total_items.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int32Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I32>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("totalItems", &__With(&self.total_items))?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::PrimaryKey {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.columns.is_empty() {
state.serialize_entry("columns", &self.columns)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::ColumnReference {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.referencing_column.is_empty() {
state.serialize_entry("referencingColumn", &self.referencing_column)?;
}
if !self.referenced_column.is_empty() {
state.serialize_entry("referencedColumn", &self.referenced_column)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::ForeignKey {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.name.is_empty() {
state.serialize_entry("name", &self.name)?;
}
if self.referenced_table.is_some() {
state.serialize_entry("referencedTable", &self.referenced_table)?;
}
if !self.column_references.is_empty() {
state.serialize_entry("columnReferences", &self.column_references)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::TableConstraints {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.primary_key.is_some() {
state.serialize_entry("primaryKey", &self.primary_key)?;
}
if !self.foreign_keys.is_empty() {
state.serialize_entry("foreignKeys", &self.foreign_keys)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::TableReference {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.project_id.is_empty() {
state.serialize_entry("projectId", &self.project_id)?;
}
if !self.dataset_id.is_empty() {
state.serialize_entry("datasetId", &self.dataset_id)?;
}
if !self.table_id.is_empty() {
state.serialize_entry("tableId", &self.table_id)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::TableSchema {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.fields.is_empty() {
state.serialize_entry("fields", &self.fields)?;
}
if self.foreign_type_info.is_some() {
state.serialize_entry("foreignTypeInfo", &self.foreign_type_info)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::ForeignTypeInfo {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !wkt::internal::is_default(&self.type_system) {
state.serialize_entry("typeSystem", &self.type_system)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::DataPolicyOption {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.name.is_some() {
state.serialize_entry("name", &self.name)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::DataPolicyList {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.data_policies.is_empty() {
state.serialize_entry("dataPolicies", &self.data_policies)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::TableFieldSchema {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.name.is_empty() {
state.serialize_entry("name", &self.name)?;
}
if !self.r#type.is_empty() {
state.serialize_entry("type", &self.r#type)?;
}
if !self.mode.is_empty() {
state.serialize_entry("mode", &self.mode)?;
}
if !self.fields.is_empty() {
state.serialize_entry("fields", &self.fields)?;
}
if self.description.is_some() {
state.serialize_entry("description", &self.description)?;
}
if self.policy_tags.is_some() {
state.serialize_entry("policyTags", &self.policy_tags)?;
}
if self.data_governance_tags_info.is_some() {
state.serialize_entry("dataGovernanceTagsInfo", &self.data_governance_tags_info)?;
}
if !self.data_policies.is_empty() {
state.serialize_entry("dataPolicies", &self.data_policies)?;
}
if self.data_policy_list.is_some() {
state.serialize_entry("dataPolicyList", &self.data_policy_list)?;
}
if !wkt::internal::is_default(&self.max_length) {
struct __With<'a>(&'a i64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
}
}
state.serialize_entry("maxLength", &__With(&self.max_length))?;
}
if !wkt::internal::is_default(&self.precision) {
struct __With<'a>(&'a i64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
}
}
state.serialize_entry("precision", &__With(&self.precision))?;
}
if !wkt::internal::is_default(&self.scale) {
struct __With<'a>(&'a i64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
}
}
state.serialize_entry("scale", &__With(&self.scale))?;
}
if self.timestamp_precision.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("timestampPrecision", &__With(&self.timestamp_precision))?;
}
if !wkt::internal::is_default(&self.rounding_mode) {
state.serialize_entry("roundingMode", &self.rounding_mode)?;
}
if self.collation.is_some() {
state.serialize_entry("collation", &self.collation)?;
}
if self.default_value_expression.is_some() {
state.serialize_entry("defaultValueExpression", &self.default_value_expression)?;
}
if self.range_element_type.is_some() {
state.serialize_entry("rangeElementType", &self.range_element_type)?;
}
if !self.foreign_type_definition.is_empty() {
state.serialize_entry("foreignTypeDefinition", &self.foreign_type_definition)?;
}
if self.generated_column.is_some() {
state.serialize_entry("generatedColumn", &self.generated_column)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::table_field_schema::PolicyTagList {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.names.is_empty() {
state.serialize_entry("names", &self.names)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::table_field_schema::DataGovernanceTagsInfo {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.data_governance_tags.is_empty() {
state.serialize_entry("dataGovernanceTags", &self.data_governance_tags)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::table_field_schema::FieldElementType {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.r#type.is_empty() {
state.serialize_entry("type", &self.r#type)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::table_field_schema::GeneratedExpressionInfo {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.generation_expression.is_some() {
state.serialize_entry("generationExpression", &self.generation_expression)?;
}
if self.asynchronous.is_some() {
state.serialize_entry("asynchronous", &self.asynchronous)?;
}
if self.stored.is_some() {
state.serialize_entry("stored", &self.stored)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::table_field_schema::GeneratedColumn {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.generated_mode.is_some() {
state.serialize_entry("generatedMode", &self.generated_mode)?;
}
if let Some(value) = self.generated_expression_info() {
state.serialize_entry("generatedExpressionInfo", value)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::TimePartitioning {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.r#type.is_empty() {
state.serialize_entry("type", &self.r#type)?;
}
if self.expiration_ms.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int64Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("expirationMs", &__With(&self.expiration_ms))?;
}
if self.field.is_some() {
state.serialize_entry("field", &self.field)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::UserDefinedFunctionResource {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.resource_uri.is_some() {
state.serialize_entry("resourceUri", &self.resource_uri)?;
}
if self.inline_code.is_some() {
state.serialize_entry("inlineCode", &self.inline_code)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}