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 crate::Error;
use crate::Result;

const DEFAULT_HOST: &str = "https://spanner.googleapis.com";

mod info {
    const NAME: &str = env!("CARGO_PKG_NAME");
    const VERSION: &str = env!("CARGO_PKG_VERSION");
    pub(crate) static X_GOOG_API_CLIENT_HEADER: std::sync::LazyLock<String> =
        std::sync::LazyLock::new(|| {
            let ac = gaxi::api_header::XGoogApiClient {
                name: NAME,
                version: VERSION,
                library_type: gaxi::api_header::GAPIC,
            };
            ac.grpc_header_value()
        });
}

/// Implements [Spanner](super::stub::Spanner) using a Tonic-generated client.
#[derive(Clone)]
pub struct Spanner {
    pub(crate) inner: gaxi::grpc::Client,
}

impl std::fmt::Debug for Spanner {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
        f.debug_struct("Spanner")
            .field("inner", &self.inner)
            .finish()
    }
}

impl Spanner {
    pub async fn new(config: gaxi::options::ClientConfig) -> crate::ClientBuilderResult<Self> {
        let inner = if gaxi::options::tracing_enabled(&config) {
            gaxi::grpc::Client::new_with_instrumentation(
                config,
                DEFAULT_HOST,
                &super::tracing::info::INSTRUMENTATION_CLIENT_INFO,
            )
            .await?
        } else {
            gaxi::grpc::Client::new(config, DEFAULT_HOST).await?
        };
        Ok(Self { inner })
    }
}

impl super::stub::Spanner for Spanner {
    async fn create_session(
        &self,
        req: crate::model::CreateSessionRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Session>> {
        use gaxi::{
            grpc::tonic::{Extensions, GrpcMethod},
            prost::ToProto,
        };
        let options = google_cloud_gax::options::internal::set_default_idempotency(options, false);
        let extensions = {
            let mut e = Extensions::new();
            e.insert(GrpcMethod::new(
                "google.spanner.v1.Spanner",
                "CreateSession",
            ));
            e
        };
        let path = http::uri::PathAndQuery::from_static("/google.spanner.v1.Spanner/CreateSession");
        let x_goog_request_params = [Some(&req)
            .map(|m| &m.database)
            .map(|s| s.as_str())
            .map(|v| format!("database={v}"))]
        .into_iter()
        .flatten()
        .fold(String::new(), |b, p| b + "&" + &p);

        type TR = crate::google::spanner::v1::Session;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            let attributes = gaxi::observability::ClientRequestAttributes::default()
                .set_rpc_method("google.spanner.v1.Spanner/CreateSession");
            let resource_name = (|| {
                Some(format!(
                    "//spanner.googleapis.com/{}",
                    Some(&req).map(|m| &m.database).map(|s| s.as_str())?,
                ))
            })();
            let attributes = if let Some(rn) = resource_name.filter(|s| !s.is_empty()) {
                attributes.set_resource_name(rn)
            } else {
                attributes
            };
            recorder.on_client_request(attributes);
        }
        self.inner
            .execute(
                extensions,
                path,
                req.to_proto().map_err(Error::deser)?,
                options,
                &info::X_GOOG_API_CLIENT_HEADER,
                &x_goog_request_params,
            )
            .await
            .and_then(gaxi::grpc::to_gax_response::<TR, crate::model::Session>)
    }

    async fn batch_create_sessions(
        &self,
        req: crate::model::BatchCreateSessionsRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::BatchCreateSessionsResponse>> {
        use gaxi::{
            grpc::tonic::{Extensions, GrpcMethod},
            prost::ToProto,
        };
        let options = google_cloud_gax::options::internal::set_default_idempotency(options, false);
        let extensions = {
            let mut e = Extensions::new();
            e.insert(GrpcMethod::new(
                "google.spanner.v1.Spanner",
                "BatchCreateSessions",
            ));
            e
        };
        let path =
            http::uri::PathAndQuery::from_static("/google.spanner.v1.Spanner/BatchCreateSessions");
        let x_goog_request_params = [Some(&req)
            .map(|m| &m.database)
            .map(|s| s.as_str())
            .map(|v| format!("database={v}"))]
        .into_iter()
        .flatten()
        .fold(String::new(), |b, p| b + "&" + &p);

        type TR = crate::google::spanner::v1::BatchCreateSessionsResponse;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            let attributes = gaxi::observability::ClientRequestAttributes::default()
                .set_rpc_method("google.spanner.v1.Spanner/BatchCreateSessions");
            let resource_name = (|| {
                Some(format!(
                    "//spanner.googleapis.com/{}",
                    Some(&req).map(|m| &m.database).map(|s| s.as_str())?,
                ))
            })();
            let attributes = if let Some(rn) = resource_name.filter(|s| !s.is_empty()) {
                attributes.set_resource_name(rn)
            } else {
                attributes
            };
            recorder.on_client_request(attributes);
        }
        self.inner
            .execute(
                extensions,
                path,
                req.to_proto().map_err(Error::deser)?,
                options,
                &info::X_GOOG_API_CLIENT_HEADER,
                &x_goog_request_params,
            )
            .await
            .and_then(gaxi::grpc::to_gax_response::<TR, crate::model::BatchCreateSessionsResponse>)
    }

    async fn get_session(
        &self,
        req: crate::model::GetSessionRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Session>> {
        use gaxi::{
            grpc::tonic::{Extensions, GrpcMethod},
            prost::ToProto,
        };
        let options = google_cloud_gax::options::internal::set_default_idempotency(options, true);
        let extensions = {
            let mut e = Extensions::new();
            e.insert(GrpcMethod::new("google.spanner.v1.Spanner", "GetSession"));
            e
        };
        let path = http::uri::PathAndQuery::from_static("/google.spanner.v1.Spanner/GetSession");
        let x_goog_request_params = [Some(&req)
            .map(|m| &m.name)
            .map(|s| s.as_str())
            .map(|v| format!("name={v}"))]
        .into_iter()
        .flatten()
        .fold(String::new(), |b, p| b + "&" + &p);

        type TR = crate::google::spanner::v1::Session;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            let attributes = gaxi::observability::ClientRequestAttributes::default()
                .set_rpc_method("google.spanner.v1.Spanner/GetSession");
            let resource_name = (|| {
                Some(format!(
                    "//spanner.googleapis.com/{}",
                    Some(&req).map(|m| &m.name).map(|s| s.as_str())?,
                ))
            })();
            let attributes = if let Some(rn) = resource_name.filter(|s| !s.is_empty()) {
                attributes.set_resource_name(rn)
            } else {
                attributes
            };
            recorder.on_client_request(attributes);
        }
        self.inner
            .execute(
                extensions,
                path,
                req.to_proto().map_err(Error::deser)?,
                options,
                &info::X_GOOG_API_CLIENT_HEADER,
                &x_goog_request_params,
            )
            .await
            .and_then(gaxi::grpc::to_gax_response::<TR, crate::model::Session>)
    }

    async fn list_sessions(
        &self,
        req: crate::model::ListSessionsRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::ListSessionsResponse>> {
        use gaxi::{
            grpc::tonic::{Extensions, GrpcMethod},
            prost::ToProto,
        };
        let options = google_cloud_gax::options::internal::set_default_idempotency(options, true);
        let extensions = {
            let mut e = Extensions::new();
            e.insert(GrpcMethod::new("google.spanner.v1.Spanner", "ListSessions"));
            e
        };
        let path = http::uri::PathAndQuery::from_static("/google.spanner.v1.Spanner/ListSessions");
        let x_goog_request_params = [Some(&req)
            .map(|m| &m.database)
            .map(|s| s.as_str())
            .map(|v| format!("database={v}"))]
        .into_iter()
        .flatten()
        .fold(String::new(), |b, p| b + "&" + &p);

        type TR = crate::google::spanner::v1::ListSessionsResponse;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            let attributes = gaxi::observability::ClientRequestAttributes::default()
                .set_rpc_method("google.spanner.v1.Spanner/ListSessions");
            let resource_name = (|| {
                Some(format!(
                    "//spanner.googleapis.com/{}",
                    Some(&req).map(|m| &m.database).map(|s| s.as_str())?,
                ))
            })();
            let attributes = if let Some(rn) = resource_name.filter(|s| !s.is_empty()) {
                attributes.set_resource_name(rn)
            } else {
                attributes
            };
            recorder.on_client_request(attributes);
        }
        self.inner
            .execute(
                extensions,
                path,
                req.to_proto().map_err(Error::deser)?,
                options,
                &info::X_GOOG_API_CLIENT_HEADER,
                &x_goog_request_params,
            )
            .await
            .and_then(gaxi::grpc::to_gax_response::<TR, crate::model::ListSessionsResponse>)
    }

    async fn delete_session(
        &self,
        req: crate::model::DeleteSessionRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<()>> {
        use gaxi::{
            grpc::tonic::{Extensions, GrpcMethod},
            prost::ToProto,
        };
        let options = google_cloud_gax::options::internal::set_default_idempotency(options, true);
        let extensions = {
            let mut e = Extensions::new();
            e.insert(GrpcMethod::new(
                "google.spanner.v1.Spanner",
                "DeleteSession",
            ));
            e
        };
        let path = http::uri::PathAndQuery::from_static("/google.spanner.v1.Spanner/DeleteSession");
        let x_goog_request_params = [Some(&req)
            .map(|m| &m.name)
            .map(|s| s.as_str())
            .map(|v| format!("name={v}"))]
        .into_iter()
        .flatten()
        .fold(String::new(), |b, p| b + "&" + &p);

        type TR = ();
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            let attributes = gaxi::observability::ClientRequestAttributes::default()
                .set_rpc_method("google.spanner.v1.Spanner/DeleteSession");
            let resource_name = (|| {
                Some(format!(
                    "//spanner.googleapis.com/{}",
                    Some(&req).map(|m| &m.name).map(|s| s.as_str())?,
                ))
            })();
            let attributes = if let Some(rn) = resource_name.filter(|s| !s.is_empty()) {
                attributes.set_resource_name(rn)
            } else {
                attributes
            };
            recorder.on_client_request(attributes);
        }
        self.inner
            .execute(
                extensions,
                path,
                req.to_proto().map_err(Error::deser)?,
                options,
                &info::X_GOOG_API_CLIENT_HEADER,
                &x_goog_request_params,
            )
            .await
            .and_then(gaxi::grpc::to_gax_response::<TR, ()>)
    }

    async fn execute_sql(
        &self,
        req: crate::model::ExecuteSqlRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::ResultSet>> {
        use gaxi::{
            grpc::tonic::{Extensions, GrpcMethod},
            prost::ToProto,
        };
        let options = google_cloud_gax::options::internal::set_default_idempotency(options, false);
        let extensions = {
            let mut e = Extensions::new();
            e.insert(GrpcMethod::new("google.spanner.v1.Spanner", "ExecuteSql"));
            e
        };
        let path = http::uri::PathAndQuery::from_static("/google.spanner.v1.Spanner/ExecuteSql");
        let x_goog_request_params = [Some(&req)
            .map(|m| &m.session)
            .map(|s| s.as_str())
            .map(|v| format!("session={v}"))]
        .into_iter()
        .flatten()
        .fold(String::new(), |b, p| b + "&" + &p);

        type TR = crate::google::spanner::v1::ResultSet;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            let attributes = gaxi::observability::ClientRequestAttributes::default()
                .set_rpc_method("google.spanner.v1.Spanner/ExecuteSql");
            let resource_name = (|| {
                Some(format!(
                    "//spanner.googleapis.com/{}",
                    Some(&req).map(|m| &m.session).map(|s| s.as_str())?,
                ))
            })();
            let attributes = if let Some(rn) = resource_name.filter(|s| !s.is_empty()) {
                attributes.set_resource_name(rn)
            } else {
                attributes
            };
            recorder.on_client_request(attributes);
        }
        self.inner
            .execute(
                extensions,
                path,
                req.to_proto().map_err(Error::deser)?,
                options,
                &info::X_GOOG_API_CLIENT_HEADER,
                &x_goog_request_params,
            )
            .await
            .and_then(gaxi::grpc::to_gax_response::<TR, crate::model::ResultSet>)
    }

    async fn execute_batch_dml(
        &self,
        req: crate::model::ExecuteBatchDmlRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::ExecuteBatchDmlResponse>> {
        use gaxi::{
            grpc::tonic::{Extensions, GrpcMethod},
            prost::ToProto,
        };
        let options = google_cloud_gax::options::internal::set_default_idempotency(options, false);
        let extensions = {
            let mut e = Extensions::new();
            e.insert(GrpcMethod::new(
                "google.spanner.v1.Spanner",
                "ExecuteBatchDml",
            ));
            e
        };
        let path =
            http::uri::PathAndQuery::from_static("/google.spanner.v1.Spanner/ExecuteBatchDml");
        let x_goog_request_params = [Some(&req)
            .map(|m| &m.session)
            .map(|s| s.as_str())
            .map(|v| format!("session={v}"))]
        .into_iter()
        .flatten()
        .fold(String::new(), |b, p| b + "&" + &p);

        type TR = crate::google::spanner::v1::ExecuteBatchDmlResponse;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            let attributes = gaxi::observability::ClientRequestAttributes::default()
                .set_rpc_method("google.spanner.v1.Spanner/ExecuteBatchDml");
            let resource_name = (|| {
                Some(format!(
                    "//spanner.googleapis.com/{}",
                    Some(&req).map(|m| &m.session).map(|s| s.as_str())?,
                ))
            })();
            let attributes = if let Some(rn) = resource_name.filter(|s| !s.is_empty()) {
                attributes.set_resource_name(rn)
            } else {
                attributes
            };
            recorder.on_client_request(attributes);
        }
        self.inner
            .execute(
                extensions,
                path,
                req.to_proto().map_err(Error::deser)?,
                options,
                &info::X_GOOG_API_CLIENT_HEADER,
                &x_goog_request_params,
            )
            .await
            .and_then(gaxi::grpc::to_gax_response::<TR, crate::model::ExecuteBatchDmlResponse>)
    }

    async fn read(
        &self,
        req: crate::model::ReadRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::ResultSet>> {
        use gaxi::{
            grpc::tonic::{Extensions, GrpcMethod},
            prost::ToProto,
        };
        let options = google_cloud_gax::options::internal::set_default_idempotency(options, false);
        let extensions = {
            let mut e = Extensions::new();
            e.insert(GrpcMethod::new("google.spanner.v1.Spanner", "Read"));
            e
        };
        let path = http::uri::PathAndQuery::from_static("/google.spanner.v1.Spanner/Read");
        let x_goog_request_params = [Some(&req)
            .map(|m| &m.session)
            .map(|s| s.as_str())
            .map(|v| format!("session={v}"))]
        .into_iter()
        .flatten()
        .fold(String::new(), |b, p| b + "&" + &p);

        type TR = crate::google::spanner::v1::ResultSet;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            let attributes = gaxi::observability::ClientRequestAttributes::default()
                .set_rpc_method("google.spanner.v1.Spanner/Read");
            let resource_name = (|| {
                Some(format!(
                    "//spanner.googleapis.com/{}",
                    Some(&req).map(|m| &m.session).map(|s| s.as_str())?,
                ))
            })();
            let attributes = if let Some(rn) = resource_name.filter(|s| !s.is_empty()) {
                attributes.set_resource_name(rn)
            } else {
                attributes
            };
            recorder.on_client_request(attributes);
        }
        self.inner
            .execute(
                extensions,
                path,
                req.to_proto().map_err(Error::deser)?,
                options,
                &info::X_GOOG_API_CLIENT_HEADER,
                &x_goog_request_params,
            )
            .await
            .and_then(gaxi::grpc::to_gax_response::<TR, crate::model::ResultSet>)
    }

    async fn begin_transaction(
        &self,
        req: crate::model::BeginTransactionRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Transaction>> {
        use gaxi::{
            grpc::tonic::{Extensions, GrpcMethod},
            prost::ToProto,
        };
        let options = google_cloud_gax::options::internal::set_default_idempotency(options, false);
        let extensions = {
            let mut e = Extensions::new();
            e.insert(GrpcMethod::new(
                "google.spanner.v1.Spanner",
                "BeginTransaction",
            ));
            e
        };
        let path =
            http::uri::PathAndQuery::from_static("/google.spanner.v1.Spanner/BeginTransaction");
        let x_goog_request_params = [Some(&req)
            .map(|m| &m.session)
            .map(|s| s.as_str())
            .map(|v| format!("session={v}"))]
        .into_iter()
        .flatten()
        .fold(String::new(), |b, p| b + "&" + &p);

        type TR = crate::google::spanner::v1::Transaction;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            let attributes = gaxi::observability::ClientRequestAttributes::default()
                .set_rpc_method("google.spanner.v1.Spanner/BeginTransaction");
            let resource_name = (|| {
                Some(format!(
                    "//spanner.googleapis.com/{}",
                    Some(&req).map(|m| &m.session).map(|s| s.as_str())?,
                ))
            })();
            let attributes = if let Some(rn) = resource_name.filter(|s| !s.is_empty()) {
                attributes.set_resource_name(rn)
            } else {
                attributes
            };
            recorder.on_client_request(attributes);
        }
        self.inner
            .execute(
                extensions,
                path,
                req.to_proto().map_err(Error::deser)?,
                options,
                &info::X_GOOG_API_CLIENT_HEADER,
                &x_goog_request_params,
            )
            .await
            .and_then(gaxi::grpc::to_gax_response::<TR, crate::model::Transaction>)
    }

    async fn commit(
        &self,
        req: crate::model::CommitRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::CommitResponse>> {
        use gaxi::{
            grpc::tonic::{Extensions, GrpcMethod},
            prost::ToProto,
        };
        let options = google_cloud_gax::options::internal::set_default_idempotency(options, false);
        let extensions = {
            let mut e = Extensions::new();
            e.insert(GrpcMethod::new("google.spanner.v1.Spanner", "Commit"));
            e
        };
        let path = http::uri::PathAndQuery::from_static("/google.spanner.v1.Spanner/Commit");
        let x_goog_request_params = [Some(&req)
            .map(|m| &m.session)
            .map(|s| s.as_str())
            .map(|v| format!("session={v}"))]
        .into_iter()
        .flatten()
        .fold(String::new(), |b, p| b + "&" + &p);

        type TR = crate::google::spanner::v1::CommitResponse;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            let attributes = gaxi::observability::ClientRequestAttributes::default()
                .set_rpc_method("google.spanner.v1.Spanner/Commit");
            let resource_name = (|| {
                Some(format!(
                    "//spanner.googleapis.com/{}",
                    Some(&req).map(|m| &m.session).map(|s| s.as_str())?,
                ))
            })();
            let attributes = if let Some(rn) = resource_name.filter(|s| !s.is_empty()) {
                attributes.set_resource_name(rn)
            } else {
                attributes
            };
            recorder.on_client_request(attributes);
        }
        self.inner
            .execute(
                extensions,
                path,
                req.to_proto().map_err(Error::deser)?,
                options,
                &info::X_GOOG_API_CLIENT_HEADER,
                &x_goog_request_params,
            )
            .await
            .and_then(gaxi::grpc::to_gax_response::<TR, crate::model::CommitResponse>)
    }

    async fn rollback(
        &self,
        req: crate::model::RollbackRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<()>> {
        use gaxi::{
            grpc::tonic::{Extensions, GrpcMethod},
            prost::ToProto,
        };
        let options = google_cloud_gax::options::internal::set_default_idempotency(options, false);
        let extensions = {
            let mut e = Extensions::new();
            e.insert(GrpcMethod::new("google.spanner.v1.Spanner", "Rollback"));
            e
        };
        let path = http::uri::PathAndQuery::from_static("/google.spanner.v1.Spanner/Rollback");
        let x_goog_request_params = [Some(&req)
            .map(|m| &m.session)
            .map(|s| s.as_str())
            .map(|v| format!("session={v}"))]
        .into_iter()
        .flatten()
        .fold(String::new(), |b, p| b + "&" + &p);

        type TR = ();
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            let attributes = gaxi::observability::ClientRequestAttributes::default()
                .set_rpc_method("google.spanner.v1.Spanner/Rollback");
            let resource_name = (|| {
                Some(format!(
                    "//spanner.googleapis.com/{}",
                    Some(&req).map(|m| &m.session).map(|s| s.as_str())?,
                ))
            })();
            let attributes = if let Some(rn) = resource_name.filter(|s| !s.is_empty()) {
                attributes.set_resource_name(rn)
            } else {
                attributes
            };
            recorder.on_client_request(attributes);
        }
        self.inner
            .execute(
                extensions,
                path,
                req.to_proto().map_err(Error::deser)?,
                options,
                &info::X_GOOG_API_CLIENT_HEADER,
                &x_goog_request_params,
            )
            .await
            .and_then(gaxi::grpc::to_gax_response::<TR, ()>)
    }

    async fn partition_query(
        &self,
        req: crate::model::PartitionQueryRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::PartitionResponse>> {
        use gaxi::{
            grpc::tonic::{Extensions, GrpcMethod},
            prost::ToProto,
        };
        let options = google_cloud_gax::options::internal::set_default_idempotency(options, false);
        let extensions = {
            let mut e = Extensions::new();
            e.insert(GrpcMethod::new(
                "google.spanner.v1.Spanner",
                "PartitionQuery",
            ));
            e
        };
        let path =
            http::uri::PathAndQuery::from_static("/google.spanner.v1.Spanner/PartitionQuery");
        let x_goog_request_params = [Some(&req)
            .map(|m| &m.session)
            .map(|s| s.as_str())
            .map(|v| format!("session={v}"))]
        .into_iter()
        .flatten()
        .fold(String::new(), |b, p| b + "&" + &p);

        type TR = crate::google::spanner::v1::PartitionResponse;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            let attributes = gaxi::observability::ClientRequestAttributes::default()
                .set_rpc_method("google.spanner.v1.Spanner/PartitionQuery");
            let resource_name = (|| {
                Some(format!(
                    "//spanner.googleapis.com/{}",
                    Some(&req).map(|m| &m.session).map(|s| s.as_str())?,
                ))
            })();
            let attributes = if let Some(rn) = resource_name.filter(|s| !s.is_empty()) {
                attributes.set_resource_name(rn)
            } else {
                attributes
            };
            recorder.on_client_request(attributes);
        }
        self.inner
            .execute(
                extensions,
                path,
                req.to_proto().map_err(Error::deser)?,
                options,
                &info::X_GOOG_API_CLIENT_HEADER,
                &x_goog_request_params,
            )
            .await
            .and_then(gaxi::grpc::to_gax_response::<TR, crate::model::PartitionResponse>)
    }

    async fn partition_read(
        &self,
        req: crate::model::PartitionReadRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::PartitionResponse>> {
        use gaxi::{
            grpc::tonic::{Extensions, GrpcMethod},
            prost::ToProto,
        };
        let options = google_cloud_gax::options::internal::set_default_idempotency(options, false);
        let extensions = {
            let mut e = Extensions::new();
            e.insert(GrpcMethod::new(
                "google.spanner.v1.Spanner",
                "PartitionRead",
            ));
            e
        };
        let path = http::uri::PathAndQuery::from_static("/google.spanner.v1.Spanner/PartitionRead");
        let x_goog_request_params = [Some(&req)
            .map(|m| &m.session)
            .map(|s| s.as_str())
            .map(|v| format!("session={v}"))]
        .into_iter()
        .flatten()
        .fold(String::new(), |b, p| b + "&" + &p);

        type TR = crate::google::spanner::v1::PartitionResponse;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            let attributes = gaxi::observability::ClientRequestAttributes::default()
                .set_rpc_method("google.spanner.v1.Spanner/PartitionRead");
            let resource_name = (|| {
                Some(format!(
                    "//spanner.googleapis.com/{}",
                    Some(&req).map(|m| &m.session).map(|s| s.as_str())?,
                ))
            })();
            let attributes = if let Some(rn) = resource_name.filter(|s| !s.is_empty()) {
                attributes.set_resource_name(rn)
            } else {
                attributes
            };
            recorder.on_client_request(attributes);
        }
        self.inner
            .execute(
                extensions,
                path,
                req.to_proto().map_err(Error::deser)?,
                options,
                &info::X_GOOG_API_CLIENT_HEADER,
                &x_goog_request_params,
            )
            .await
            .and_then(gaxi::grpc::to_gax_response::<TR, crate::model::PartitionResponse>)
    }
}