google-cloud-spanner 0.34.1-preview

// Copyright 2026 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// Code generated by sidekick. DO NOT EDIT.

#[allow(unused_imports)]
use super::*;

impl std::fmt::Debug for super::ChangeStreamRecord {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ChangeStreamRecord");
        debug_struct.field("record", &self.record);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::change_stream_record::DataChangeRecord {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DataChangeRecord");
        debug_struct.field("commit_timestamp", &self.commit_timestamp);
        debug_struct.field("record_sequence", &self.record_sequence);
        debug_struct.field("server_transaction_id", &self.server_transaction_id);
        debug_struct.field(
            "is_last_record_in_transaction_in_partition",
            &self.is_last_record_in_transaction_in_partition,
        );
        debug_struct.field("table", &self.table);
        debug_struct.field("column_metadata", &self.column_metadata);
        debug_struct.field("mods", &self.mods);
        debug_struct.field("mod_type", &self.mod_type);
        debug_struct.field("value_capture_type", &self.value_capture_type);
        debug_struct.field(
            "number_of_records_in_transaction",
            &self.number_of_records_in_transaction,
        );
        debug_struct.field(
            "number_of_partitions_in_transaction",
            &self.number_of_partitions_in_transaction,
        );
        debug_struct.field("transaction_tag", &self.transaction_tag);
        debug_struct.field("is_system_transaction", &self.is_system_transaction);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::change_stream_record::data_change_record::ColumnMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ColumnMetadata");
        debug_struct.field("name", &self.name);
        debug_struct.field("r#type", &self.r#type);
        debug_struct.field("is_primary_key", &self.is_primary_key);
        debug_struct.field("ordinal_position", &self.ordinal_position);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::change_stream_record::data_change_record::ModValue {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ModValue");
        debug_struct.field("column_metadata_index", &self.column_metadata_index);
        debug_struct.field("value", &self.value);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::change_stream_record::data_change_record::Mod {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Mod");
        debug_struct.field("keys", &self.keys);
        debug_struct.field("old_values", &self.old_values);
        debug_struct.field("new_values", &self.new_values);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::change_stream_record::HeartbeatRecord {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("HeartbeatRecord");
        debug_struct.field("timestamp", &self.timestamp);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::change_stream_record::PartitionStartRecord {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PartitionStartRecord");
        debug_struct.field("start_timestamp", &self.start_timestamp);
        debug_struct.field("record_sequence", &self.record_sequence);
        debug_struct.field("partition_tokens", &self.partition_tokens);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::change_stream_record::PartitionEndRecord {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PartitionEndRecord");
        debug_struct.field("end_timestamp", &self.end_timestamp);
        debug_struct.field("record_sequence", &self.record_sequence);
        debug_struct.field("partition_token", &self.partition_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::change_stream_record::PartitionEventRecord {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PartitionEventRecord");
        debug_struct.field("commit_timestamp", &self.commit_timestamp);
        debug_struct.field("record_sequence", &self.record_sequence);
        debug_struct.field("partition_token", &self.partition_token);
        debug_struct.field("move_in_events", &self.move_in_events);
        debug_struct.field("move_out_events", &self.move_out_events);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::change_stream_record::partition_event_record::MoveInEvent {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("MoveInEvent");
        debug_struct.field("source_partition_token", &self.source_partition_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::change_stream_record::partition_event_record::MoveOutEvent {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("MoveOutEvent");
        debug_struct.field(
            "destination_partition_token",
            &self.destination_partition_token,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::CommitResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CommitResponse");
        debug_struct.field("commit_timestamp", &self.commit_timestamp);
        debug_struct.field("commit_stats", &self.commit_stats);
        debug_struct.field("snapshot_timestamp", &self.snapshot_timestamp);
        debug_struct.field("cache_update", &self.cache_update);
        debug_struct.field("isolation_level", &self.isolation_level);
        debug_struct.field("read_lock_mode", &self.read_lock_mode);
        debug_struct.field("multiplexed_session_retry", &self.multiplexed_session_retry);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::commit_response::CommitStats {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CommitStats");
        debug_struct.field("mutation_count", &self.mutation_count);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::KeyRange {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("KeyRange");
        debug_struct.field("start_key_type", &self.start_key_type);
        debug_struct.field("end_key_type", &self.end_key_type);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::KeySet {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("KeySet");
        debug_struct.field("keys", &self.keys);
        debug_struct.field("ranges", &self.ranges);
        debug_struct.field("all", &self.all);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::Range {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Range");
        debug_struct.field("start_key", &self.start_key);
        debug_struct.field("limit_key", &self.limit_key);
        debug_struct.field("group_uid", &self.group_uid);
        debug_struct.field("split_id", &self.split_id);
        debug_struct.field("generation", &self.generation);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::Tablet {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Tablet");
        debug_struct.field("tablet_uid", &self.tablet_uid);
        debug_struct.field("server_address", &self.server_address);
        debug_struct.field("location", &self.location);
        debug_struct.field("role", &self.role);
        debug_struct.field("incarnation", &self.incarnation);
        debug_struct.field("distance", &self.distance);
        debug_struct.field("skip", &self.skip);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::Group {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Group");
        debug_struct.field("group_uid", &self.group_uid);
        debug_struct.field("tablets", &self.tablets);
        debug_struct.field("leader_index", &self.leader_index);
        debug_struct.field("generation", &self.generation);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::KeyRecipe {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("KeyRecipe");
        debug_struct.field("part", &self.part);
        debug_struct.field("target", &self.target);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::key_recipe::Part {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Part");
        debug_struct.field("tag", &self.tag);
        debug_struct.field("order", &self.order);
        debug_struct.field("null_order", &self.null_order);
        debug_struct.field("r#type", &self.r#type);
        debug_struct.field("struct_identifiers", &self.struct_identifiers);
        debug_struct.field("value_type", &self.value_type);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::RecipeList {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RecipeList");
        debug_struct.field("schema_generation", &self.schema_generation);
        debug_struct.field("recipe", &self.recipe);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::CacheUpdate {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CacheUpdate");
        debug_struct.field("database_id", &self.database_id);
        debug_struct.field("range", &self.range);
        debug_struct.field("group", &self.group);
        debug_struct.field("key_recipes", &self.key_recipes);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::RoutingHint {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RoutingHint");
        debug_struct.field("operation_uid", &self.operation_uid);
        debug_struct.field("database_id", &self.database_id);
        debug_struct.field("schema_generation", &self.schema_generation);
        debug_struct.field("key", &self.key);
        debug_struct.field("limit_key", &self.limit_key);
        debug_struct.field("group_uid", &self.group_uid);
        debug_struct.field("split_id", &self.split_id);
        debug_struct.field("tablet_uid", &self.tablet_uid);
        debug_struct.field("skipped_tablet_uid", &self.skipped_tablet_uid);
        debug_struct.field("client_location", &self.client_location);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::routing_hint::SkippedTablet {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SkippedTablet");
        debug_struct.field("tablet_uid", &self.tablet_uid);
        debug_struct.field("incarnation", &self.incarnation);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::Mutation {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Mutation");
        debug_struct.field("operation", &self.operation);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::mutation::Write {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Write");
        debug_struct.field("table", &self.table);
        debug_struct.field("columns", &self.columns);
        debug_struct.field("values", &self.values);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::mutation::Delete {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Delete");
        debug_struct.field("table", &self.table);
        debug_struct.field("key_set", &self.key_set);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::mutation::Send {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Send");
        debug_struct.field("queue", &self.queue);
        debug_struct.field("key", &self.key);
        debug_struct.field("deliver_time", &self.deliver_time);
        debug_struct.field("payload", &self.payload);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::mutation::Ack {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Ack");
        debug_struct.field("queue", &self.queue);
        debug_struct.field("key", &self.key);
        debug_struct.field("ignore_not_found", &self.ignore_not_found);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::PlanNode {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PlanNode");
        debug_struct.field("index", &self.index);
        debug_struct.field("kind", &self.kind);
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("child_links", &self.child_links);
        debug_struct.field("short_representation", &self.short_representation);
        debug_struct.field("metadata", &self.metadata);
        debug_struct.field("execution_stats", &self.execution_stats);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::plan_node::ChildLink {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ChildLink");
        debug_struct.field("child_index", &self.child_index);
        debug_struct.field("r#type", &self.r#type);
        debug_struct.field("variable", &self.variable);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::plan_node::ShortRepresentation {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ShortRepresentation");
        debug_struct.field("description", &self.description);
        debug_struct.field("subqueries", &self.subqueries);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::QueryAdvisorResult {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("QueryAdvisorResult");
        debug_struct.field("index_advice", &self.index_advice);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::query_advisor_result::IndexAdvice {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("IndexAdvice");
        debug_struct.field("ddl", &self.ddl);
        debug_struct.field("improvement_factor", &self.improvement_factor);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::QueryPlan {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("QueryPlan");
        debug_struct.field("plan_nodes", &self.plan_nodes);
        debug_struct.field("query_advice", &self.query_advice);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ResultSet {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ResultSet");
        debug_struct.field("metadata", &self.metadata);
        debug_struct.field("rows", &self.rows);
        debug_struct.field("stats", &self.stats);
        debug_struct.field("precommit_token", &self.precommit_token);
        debug_struct.field("cache_update", &self.cache_update);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::PartialResultSet {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PartialResultSet");
        debug_struct.field("metadata", &self.metadata);
        debug_struct.field("values", &self.values);
        debug_struct.field("chunked_value", &self.chunked_value);
        debug_struct.field("resume_token", &self.resume_token);
        debug_struct.field("stats", &self.stats);
        debug_struct.field("precommit_token", &self.precommit_token);
        debug_struct.field("last", &self.last);
        debug_struct.field("cache_update", &self.cache_update);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ResultSetMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ResultSetMetadata");
        debug_struct.field("row_type", &self.row_type);
        debug_struct.field("transaction", &self.transaction);
        debug_struct.field("undeclared_parameters", &self.undeclared_parameters);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ResultSetStats {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ResultSetStats");
        debug_struct.field("query_plan", &self.query_plan);
        debug_struct.field("query_stats", &self.query_stats);
        debug_struct.field("row_count", &self.row_count);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::CreateSessionRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateSessionRequest");
        debug_struct.field("database", &self.database);
        debug_struct.field("session", &self.session);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::BatchCreateSessionsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BatchCreateSessionsRequest");
        debug_struct.field("database", &self.database);
        debug_struct.field("session_template", &self.session_template);
        debug_struct.field("session_count", &self.session_count);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::BatchCreateSessionsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BatchCreateSessionsResponse");
        debug_struct.field("session", &self.session);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::Session {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Session");
        debug_struct.field("name", &self.name);
        debug_struct.field("labels", &self.labels);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("approximate_last_use_time", &self.approximate_last_use_time);
        debug_struct.field("creator_role", &self.creator_role);
        debug_struct.field("multiplexed", &self.multiplexed);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::GetSessionRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetSessionRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ListSessionsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListSessionsRequest");
        debug_struct.field("database", &self.database);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("filter", &self.filter);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ListSessionsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListSessionsResponse");
        debug_struct.field("sessions", &self.sessions);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::DeleteSessionRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteSessionRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::RequestOptions {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RequestOptions");
        debug_struct.field("priority", &self.priority);
        debug_struct.field("request_tag", &self.request_tag);
        debug_struct.field("transaction_tag", &self.transaction_tag);
        debug_struct.field("client_context", &self.client_context);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::request_options::ClientContext {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ClientContext");
        debug_struct.field("secure_context", &self.secure_context);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::DirectedReadOptions {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DirectedReadOptions");
        debug_struct.field("replicas", &self.replicas);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::directed_read_options::ReplicaSelection {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ReplicaSelection");
        debug_struct.field("location", &self.location);
        debug_struct.field("r#type", &self.r#type);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::directed_read_options::IncludeReplicas {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("IncludeReplicas");
        debug_struct.field("replica_selections", &self.replica_selections);
        debug_struct.field("auto_failover_disabled", &self.auto_failover_disabled);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::directed_read_options::ExcludeReplicas {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ExcludeReplicas");
        debug_struct.field("replica_selections", &self.replica_selections);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ExecuteSqlRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ExecuteSqlRequest");
        debug_struct.field("session", &self.session);
        debug_struct.field("transaction", &self.transaction);
        debug_struct.field("sql", &self.sql);
        debug_struct.field("params", &self.params);
        debug_struct.field("param_types", &self.param_types);
        debug_struct.field("resume_token", &self.resume_token);
        debug_struct.field("query_mode", &self.query_mode);
        debug_struct.field("partition_token", &self.partition_token);
        debug_struct.field("seqno", &self.seqno);
        debug_struct.field("query_options", &self.query_options);
        debug_struct.field("request_options", &self.request_options);
        debug_struct.field("directed_read_options", &self.directed_read_options);
        debug_struct.field("data_boost_enabled", &self.data_boost_enabled);
        debug_struct.field("last_statement", &self.last_statement);
        debug_struct.field("routing_hint", &self.routing_hint);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::execute_sql_request::QueryOptions {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("QueryOptions");
        debug_struct.field("optimizer_version", &self.optimizer_version);
        debug_struct.field(
            "optimizer_statistics_package",
            &self.optimizer_statistics_package,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ExecuteBatchDmlRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ExecuteBatchDmlRequest");
        debug_struct.field("session", &self.session);
        debug_struct.field("transaction", &self.transaction);
        debug_struct.field("statements", &self.statements);
        debug_struct.field("seqno", &self.seqno);
        debug_struct.field("request_options", &self.request_options);
        debug_struct.field("last_statements", &self.last_statements);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::execute_batch_dml_request::Statement {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Statement");
        debug_struct.field("sql", &self.sql);
        debug_struct.field("params", &self.params);
        debug_struct.field("param_types", &self.param_types);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ExecuteBatchDmlResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ExecuteBatchDmlResponse");
        debug_struct.field("result_sets", &self.result_sets);
        debug_struct.field("status", &self.status);
        debug_struct.field("precommit_token", &self.precommit_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::PartitionOptions {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PartitionOptions");
        debug_struct.field("partition_size_bytes", &self.partition_size_bytes);
        debug_struct.field("max_partitions", &self.max_partitions);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::PartitionQueryRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PartitionQueryRequest");
        debug_struct.field("session", &self.session);
        debug_struct.field("transaction", &self.transaction);
        debug_struct.field("sql", &self.sql);
        debug_struct.field("params", &self.params);
        debug_struct.field("param_types", &self.param_types);
        debug_struct.field("partition_options", &self.partition_options);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::PartitionReadRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PartitionReadRequest");
        debug_struct.field("session", &self.session);
        debug_struct.field("transaction", &self.transaction);
        debug_struct.field("table", &self.table);
        debug_struct.field("index", &self.index);
        debug_struct.field("columns", &self.columns);
        debug_struct.field("key_set", &self.key_set);
        debug_struct.field("partition_options", &self.partition_options);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::Partition {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Partition");
        debug_struct.field("partition_token", &self.partition_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::PartitionResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PartitionResponse");
        debug_struct.field("partitions", &self.partitions);
        debug_struct.field("transaction", &self.transaction);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ReadRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ReadRequest");
        debug_struct.field("session", &self.session);
        debug_struct.field("transaction", &self.transaction);
        debug_struct.field("table", &self.table);
        debug_struct.field("index", &self.index);
        debug_struct.field("columns", &self.columns);
        debug_struct.field("key_set", &self.key_set);
        debug_struct.field("limit", &self.limit);
        debug_struct.field("resume_token", &self.resume_token);
        debug_struct.field("partition_token", &self.partition_token);
        debug_struct.field("request_options", &self.request_options);
        debug_struct.field("directed_read_options", &self.directed_read_options);
        debug_struct.field("data_boost_enabled", &self.data_boost_enabled);
        debug_struct.field("order_by", &self.order_by);
        debug_struct.field("lock_hint", &self.lock_hint);
        debug_struct.field("routing_hint", &self.routing_hint);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::BeginTransactionRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BeginTransactionRequest");
        debug_struct.field("session", &self.session);
        debug_struct.field("options", &self.options);
        debug_struct.field("request_options", &self.request_options);
        debug_struct.field("mutation_key", &self.mutation_key);
        debug_struct.field("routing_hint", &self.routing_hint);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::CommitRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CommitRequest");
        debug_struct.field("session", &self.session);
        debug_struct.field("mutations", &self.mutations);
        debug_struct.field("return_commit_stats", &self.return_commit_stats);
        debug_struct.field("max_commit_delay", &self.max_commit_delay);
        debug_struct.field("request_options", &self.request_options);
        debug_struct.field("precommit_token", &self.precommit_token);
        debug_struct.field("routing_hint", &self.routing_hint);
        debug_struct.field("transaction", &self.transaction);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::RollbackRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RollbackRequest");
        debug_struct.field("session", &self.session);
        debug_struct.field("transaction_id", &self.transaction_id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::BatchWriteRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BatchWriteRequest");
        debug_struct.field("session", &self.session);
        debug_struct.field("request_options", &self.request_options);
        debug_struct.field("mutation_groups", &self.mutation_groups);
        debug_struct.field(
            "exclude_txn_from_change_streams",
            &self.exclude_txn_from_change_streams,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::batch_write_request::MutationGroup {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("MutationGroup");
        debug_struct.field("mutations", &self.mutations);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::BatchWriteResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BatchWriteResponse");
        debug_struct.field("indexes", &self.indexes);
        debug_struct.field("status", &self.status);
        debug_struct.field("commit_timestamp", &self.commit_timestamp);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::FetchCacheUpdateRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FetchCacheUpdateRequest");
        debug_struct.field("database", &self.database);
        debug_struct.field("max_recipe_count", &self.max_recipe_count);
        debug_struct.field("max_range_count", &self.max_range_count);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::TransactionOptions {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("TransactionOptions");
        debug_struct.field(
            "exclude_txn_from_change_streams",
            &self.exclude_txn_from_change_streams,
        );
        debug_struct.field("isolation_level", &self.isolation_level);
        debug_struct.field("mode", &self.mode);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::transaction_options::ReadWrite {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ReadWrite");
        debug_struct.field("read_lock_mode", &self.read_lock_mode);
        debug_struct.field(
            "multiplexed_session_previous_transaction_id",
            &self.multiplexed_session_previous_transaction_id,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::transaction_options::PartitionedDml {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PartitionedDml");
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::transaction_options::ReadOnly {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ReadOnly");
        debug_struct.field("return_read_timestamp", &self.return_read_timestamp);
        debug_struct.field("timestamp_bound", &self.timestamp_bound);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::Transaction {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Transaction");
        debug_struct.field("id", &self.id);
        debug_struct.field("read_timestamp", &self.read_timestamp);
        debug_struct.field("precommit_token", &self.precommit_token);
        debug_struct.field("cache_update", &self.cache_update);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::TransactionSelector {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("TransactionSelector");
        debug_struct.field("selector", &self.selector);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::MultiplexedSessionPrecommitToken {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("MultiplexedSessionPrecommitToken");
        debug_struct.field("precommit_token", &self.precommit_token);
        debug_struct.field("seq_num", &self.seq_num);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::Type {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Type");
        debug_struct.field("code", &self.code);
        debug_struct.field("array_element_type", &self.array_element_type);
        debug_struct.field("struct_type", &self.struct_type);
        debug_struct.field("type_annotation", &self.type_annotation);
        debug_struct.field("proto_type_fqn", &self.proto_type_fqn);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::StructType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("StructType");
        debug_struct.field("fields", &self.fields);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::struct_type::Field {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Field");
        debug_struct.field("name", &self.name);
        debug_struct.field("r#type", &self.r#type);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}