Struct google_cloud_rust_raw::spanner::v1::spanner_grpc::SpannerClient

pub struct SpannerClient { /* fields omitted */ }

Implementations

impl SpannerClient

pub fn new(channel: Channel) -> Self

pub fn create_session_opt(
    &self,
    req: &CreateSessionRequest,
    opt: CallOption
) -> Result<Session>

pub fn create_session(&self, req: &CreateSessionRequest) -> Result<Session>

pub fn create_session_async_opt(
    &self,
    req: &CreateSessionRequest,
    opt: CallOption
) -> Result<ClientUnaryReceiver<Session>>

pub fn create_session_async(
    &self,
    req: &CreateSessionRequest
) -> Result<ClientUnaryReceiver<Session>>

pub fn batch_create_sessions_opt(
    &self,
    req: &BatchCreateSessionsRequest,
    opt: CallOption
) -> Result<BatchCreateSessionsResponse>

pub fn batch_create_sessions(
    &self,
    req: &BatchCreateSessionsRequest
) -> Result<BatchCreateSessionsResponse>

pub fn batch_create_sessions_async_opt(
    &self,
    req: &BatchCreateSessionsRequest,
    opt: CallOption
) -> Result<ClientUnaryReceiver<BatchCreateSessionsResponse>>

pub fn batch_create_sessions_async(
    &self,
    req: &BatchCreateSessionsRequest
) -> Result<ClientUnaryReceiver<BatchCreateSessionsResponse>>

pub fn get_session_opt(
    &self,
    req: &GetSessionRequest,
    opt: CallOption
) -> Result<Session>

pub fn get_session(&self, req: &GetSessionRequest) -> Result<Session>

pub fn get_session_async_opt(
    &self,
    req: &GetSessionRequest,
    opt: CallOption
) -> Result<ClientUnaryReceiver<Session>>

pub fn get_session_async(
    &self,
    req: &GetSessionRequest
) -> Result<ClientUnaryReceiver<Session>>

pub fn list_sessions_opt(
    &self,
    req: &ListSessionsRequest,
    opt: CallOption
) -> Result<ListSessionsResponse>

pub fn list_sessions(
    &self,
    req: &ListSessionsRequest
) -> Result<ListSessionsResponse>

pub fn list_sessions_async_opt(
    &self,
    req: &ListSessionsRequest,
    opt: CallOption
) -> Result<ClientUnaryReceiver<ListSessionsResponse>>

pub fn list_sessions_async(
    &self,
    req: &ListSessionsRequest
) -> Result<ClientUnaryReceiver<ListSessionsResponse>>

pub fn delete_session_opt(
    &self,
    req: &DeleteSessionRequest,
    opt: CallOption
) -> Result<Empty>

pub fn delete_session(&self, req: &DeleteSessionRequest) -> Result<Empty>

pub fn delete_session_async_opt(
    &self,
    req: &DeleteSessionRequest,
    opt: CallOption
) -> Result<ClientUnaryReceiver<Empty>>

pub fn delete_session_async(
    &self,
    req: &DeleteSessionRequest
) -> Result<ClientUnaryReceiver<Empty>>

pub fn execute_sql_opt(
    &self,
    req: &ExecuteSqlRequest,
    opt: CallOption
) -> Result<ResultSet>

pub fn execute_sql(&self, req: &ExecuteSqlRequest) -> Result<ResultSet>

pub fn execute_sql_async_opt(
    &self,
    req: &ExecuteSqlRequest,
    opt: CallOption
) -> Result<ClientUnaryReceiver<ResultSet>>

pub fn execute_sql_async(
    &self,
    req: &ExecuteSqlRequest
) -> Result<ClientUnaryReceiver<ResultSet>>

pub fn execute_streaming_sql_opt(
    &self,
    req: &ExecuteSqlRequest,
    opt: CallOption
) -> Result<ClientSStreamReceiver<PartialResultSet>>

pub fn execute_streaming_sql(
    &self,
    req: &ExecuteSqlRequest
) -> Result<ClientSStreamReceiver<PartialResultSet>>

pub fn execute_batch_dml_opt(
    &self,
    req: &ExecuteBatchDmlRequest,
    opt: CallOption
) -> Result<ExecuteBatchDmlResponse>

pub fn execute_batch_dml(
    &self,
    req: &ExecuteBatchDmlRequest
) -> Result<ExecuteBatchDmlResponse>

pub fn execute_batch_dml_async_opt(
    &self,
    req: &ExecuteBatchDmlRequest,
    opt: CallOption
) -> Result<ClientUnaryReceiver<ExecuteBatchDmlResponse>>

pub fn execute_batch_dml_async(
    &self,
    req: &ExecuteBatchDmlRequest
) -> Result<ClientUnaryReceiver<ExecuteBatchDmlResponse>>

pub fn read_opt(&self, req: &ReadRequest, opt: CallOption) -> Result<ResultSet>

pub fn read(&self, req: &ReadRequest) -> Result<ResultSet>

pub fn read_async_opt(
    &self,
    req: &ReadRequest,
    opt: CallOption
) -> Result<ClientUnaryReceiver<ResultSet>>

pub fn read_async(
    &self,
    req: &ReadRequest
) -> Result<ClientUnaryReceiver<ResultSet>>

pub fn streaming_read_opt(
    &self,
    req: &ReadRequest,
    opt: CallOption
) -> Result<ClientSStreamReceiver<PartialResultSet>>

pub fn streaming_read(
    &self,
    req: &ReadRequest
) -> Result<ClientSStreamReceiver<PartialResultSet>>

pub fn begin_transaction_opt(
    &self,
    req: &BeginTransactionRequest,
    opt: CallOption
) -> Result<Transaction>

pub fn begin_transaction(
    &self,
    req: &BeginTransactionRequest
) -> Result<Transaction>

pub fn begin_transaction_async_opt(
    &self,
    req: &BeginTransactionRequest,
    opt: CallOption
) -> Result<ClientUnaryReceiver<Transaction>>

pub fn begin_transaction_async(
    &self,
    req: &BeginTransactionRequest
) -> Result<ClientUnaryReceiver<Transaction>>

pub fn commit_opt(
    &self,
    req: &CommitRequest,
    opt: CallOption
) -> Result<CommitResponse>

pub fn commit(&self, req: &CommitRequest) -> Result<CommitResponse>

pub fn commit_async_opt(
    &self,
    req: &CommitRequest,
    opt: CallOption
) -> Result<ClientUnaryReceiver<CommitResponse>>

pub fn commit_async(
    &self,
    req: &CommitRequest
) -> Result<ClientUnaryReceiver<CommitResponse>>

pub fn rollback_opt(
    &self,
    req: &RollbackRequest,
    opt: CallOption
) -> Result<Empty>

pub fn rollback(&self, req: &RollbackRequest) -> Result<Empty>

pub fn rollback_async_opt(
    &self,
    req: &RollbackRequest,
    opt: CallOption
) -> Result<ClientUnaryReceiver<Empty>>

pub fn rollback_async(
    &self,
    req: &RollbackRequest
) -> Result<ClientUnaryReceiver<Empty>>

pub fn partition_query_opt(
    &self,
    req: &PartitionQueryRequest,
    opt: CallOption
) -> Result<PartitionResponse>

pub fn partition_query(
    &self,
    req: &PartitionQueryRequest
) -> Result<PartitionResponse>

pub fn partition_query_async_opt(
    &self,
    req: &PartitionQueryRequest,
    opt: CallOption
) -> Result<ClientUnaryReceiver<PartitionResponse>>

pub fn partition_query_async(
    &self,
    req: &PartitionQueryRequest
) -> Result<ClientUnaryReceiver<PartitionResponse>>

pub fn partition_read_opt(
    &self,
    req: &PartitionReadRequest,
    opt: CallOption
) -> Result<PartitionResponse>

pub fn partition_read(
    &self,
    req: &PartitionReadRequest
) -> Result<PartitionResponse>

pub fn partition_read_async_opt(
    &self,
    req: &PartitionReadRequest,
    opt: CallOption
) -> Result<ClientUnaryReceiver<PartitionResponse>>

pub fn partition_read_async(
    &self,
    req: &PartitionReadRequest
) -> Result<ClientUnaryReceiver<PartitionResponse>>

pub fn spawn<F>(&self, f: F) where
    F: Future<Output = ()> + Send + 'static, 

Trait Implementations

impl Clone for SpannerClient

fn clone(&self) -> SpannerClient

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.