Struct ydb_grpc::generated::ydb::table::v1::table_service_client::TableServiceClient

pub struct TableServiceClient<T> { /* private fields */ }

Implementations

impl TableServiceClient<Channel>

pub async fn connect<D>(dst: D) -> Result<Self, Error>where
    D: TryInto<Endpoint>,
    D::Error: Into<StdError>,

Attempt to create a new client by connecting to a given endpoint.

impl<T> TableServiceClient<T>where
    T: GrpcService<BoxBody>,
    T::Error: Into<StdError>,
    T::ResponseBody: Body<Data = Bytes> + Send + 'static,
    <T::ResponseBody as Body>::Error: Into<StdError> + Send,

pub fn new(inner: T) -> Self

Examples found in repository

src/generated/ydb.table.v1.rs (line 18)

        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
        where
            D: std::convert::TryInto<tonic::transport::Endpoint>,
            D::Error: Into<StdError>,
        {
            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
            Ok(Self::new(conn))
        }
    }
    impl<T> TableServiceClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::BoxBody>,
        T::Error: Into<StdError>,
        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
        <T::ResponseBody as Body>::Error: Into<StdError> + Send,
    {
        pub fn new(inner: T) -> Self {
            let inner = tonic::client::Grpc::new(inner);
            Self { inner }
        }
        pub fn with_origin(inner: T, origin: Uri) -> Self {
            let inner = tonic::client::Grpc::with_origin(inner, origin);
            Self { inner }
        }
        pub fn with_interceptor<F>(
            inner: T,
            interceptor: F,
        ) -> TableServiceClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T::ResponseBody: Default,
            T: tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
                Response = http::Response<
                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
                >,
            >,
            <T as tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
            >>::Error: Into<StdError> + Send + Sync,
        {
            TableServiceClient::new(InterceptedService::new(inner, interceptor))
        }

pub fn with_origin(inner: T, origin: Uri) -> Self

pub fn with_interceptor<F>(
    inner: T,
    interceptor: F
) -> TableServiceClient<InterceptedService<T, F>>where
    F: Interceptor,
    T::ResponseBody: Default,
    T: Service<Request<BoxBody>, Response = Response<<T as GrpcService<BoxBody>>::ResponseBody>>,
    <T as Service<Request<BoxBody>>>::Error: Into<StdError> + Send + Sync,

pub fn send_compressed(self, encoding: CompressionEncoding) -> Self

Compress requests with the given encoding. This requires the server to support it otherwise it might respond with an error.

pub fn accept_compressed(self, encoding: CompressionEncoding) -> Self

Enable decompressing responses.

pub async fn create_session(
    &mut self,
    request: impl IntoRequest<CreateSessionRequest>
) -> Result<Response<CreateSessionResponse>, Status>

Create new session. Implicit session creation is forbidden, so user must create new session before execute any query, otherwise BAD_SESSION status will be returned. Simultaneous execution of requests are forbiden. Sessions are volatile, can be invalidated by server, for example in case of fatal errors. All requests with this session will fail with BAD_SESSION status. So, client must be able to handle BAD_SESSION status.

pub async fn delete_session(
    &mut self,
    request: impl IntoRequest<DeleteSessionRequest>
) -> Result<Response<DeleteSessionResponse>, Status>

Ends a session, releasing server resources associated with it.

pub async fn keep_alive(
    &mut self,
    request: impl IntoRequest<KeepAliveRequest>
) -> Result<Response<KeepAliveResponse>, Status>

Idle sessions can be kept alive by calling KeepAlive periodically.

pub async fn create_table(
    &mut self,
    request: impl IntoRequest<CreateTableRequest>
) -> Result<Response<CreateTableResponse>, Status>

Creates new table.

pub async fn drop_table(
    &mut self,
    request: impl IntoRequest<DropTableRequest>
) -> Result<Response<DropTableResponse>, Status>

Drop table.

pub async fn alter_table(
    &mut self,
    request: impl IntoRequest<AlterTableRequest>
) -> Result<Response<AlterTableResponse>, Status>

Modifies schema of given table.

pub async fn copy_table(
    &mut self,
    request: impl IntoRequest<CopyTableRequest>
) -> Result<Response<CopyTableResponse>, Status>

Creates copy of given table.

pub async fn copy_tables(
    &mut self,
    request: impl IntoRequest<CopyTablesRequest>
) -> Result<Response<CopyTablesResponse>, Status>

Creates consistent copy of given tables.

pub async fn rename_tables(
    &mut self,
    request: impl IntoRequest<RenameTablesRequest>
) -> Result<Response<RenameTablesResponse>, Status>

Creates consistent move of given tables.

pub async fn describe_table(
    &mut self,
    request: impl IntoRequest<DescribeTableRequest>
) -> Result<Response<DescribeTableResponse>, Status>

Returns information about given table (metadata).

pub async fn explain_data_query(
    &mut self,
    request: impl IntoRequest<ExplainDataQueryRequest>
) -> Result<Response<ExplainDataQueryResponse>, Status>

Explains data query. SessionId of previously created session must be provided.

pub async fn prepare_data_query(
    &mut self,
    request: impl IntoRequest<PrepareDataQueryRequest>
) -> Result<Response<PrepareDataQueryResponse>, Status>

Prepares data query, returns query id. SessionId of previously created session must be provided.

pub async fn execute_data_query(
    &mut self,
    request: impl IntoRequest<ExecuteDataQueryRequest>
) -> Result<Response<ExecuteDataQueryResponse>, Status>

Executes data query. SessionId of previously created session must be provided.

pub async fn execute_scheme_query(
    &mut self,
    request: impl IntoRequest<ExecuteSchemeQueryRequest>
) -> Result<Response<ExecuteSchemeQueryResponse>, Status>

Executes scheme query. SessionId of previously created session must be provided.

pub async fn begin_transaction(
    &mut self,
    request: impl IntoRequest<BeginTransactionRequest>
) -> Result<Response<BeginTransactionResponse>, Status>

Begins new transaction.

pub async fn commit_transaction(
    &mut self,
    request: impl IntoRequest<CommitTransactionRequest>
) -> Result<Response<CommitTransactionResponse>, Status>

Commits specified active transaction.

pub async fn rollback_transaction(
    &mut self,
    request: impl IntoRequest<RollbackTransactionRequest>
) -> Result<Response<RollbackTransactionResponse>, Status>

Performs a rollback of the specified active transaction.

pub async fn describe_table_options(
    &mut self,
    request: impl IntoRequest<DescribeTableOptionsRequest>
) -> Result<Response<DescribeTableOptionsResponse>, Status>

Describe supported table options.

pub async fn stream_read_table(
    &mut self,
    request: impl IntoRequest<ReadTableRequest>
) -> Result<Response<Streaming<ReadTableResponse>>, Status>

Streaming read table

pub async fn bulk_upsert(
    &mut self,
    request: impl IntoRequest<BulkUpsertRequest>
) -> Result<Response<BulkUpsertResponse>, Status>

Upserts a batch of rows non-transactionally. Returns success only when all rows were successfully upserted. In case of an error some rows might be upserted and some might not.

pub async fn stream_execute_scan_query(
    &mut self,
    request: impl IntoRequest<ExecuteScanQueryRequest>
) -> Result<Response<Streaming<ExecuteScanQueryPartialResponse>>, Status>

Executes scan query with streaming result.

Trait Implementations

impl<T: Clone> Clone for TableServiceClient<T>

fn clone(&self) -> TableServiceClient<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for TableServiceClient<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.