Struct ydb_unofficial::client::TableClientWithSession

pub struct TableClientWithSession<'a, C: Credentials> { /* private fields */ }

TableServiceClient with active session. for each method (that requires session_id) table client injects session_id field Session may be invalid. In this case you need to recreate that client with YdbConnection::table

Implementations

impl<'a, C: Credentials + Send> TableClientWithSession<'a, C>

pub async fn create_table( &mut self, req: CreateTableRequest ) -> Result<Response<CreateTableResponse>, YdbError>

pub async fn drop_table( &mut self, req: DropTableRequest ) -> Result<Response<DropTableResponse>, YdbError>

pub async fn alter_table( &mut self, req: AlterTableRequest ) -> Result<Response<AlterTableResponse>, YdbError>

pub async fn copy_table( &mut self, req: CopyTableRequest ) -> Result<Response<CopyTableResponse>, YdbError>

pub async fn rename_tables( &mut self, req: RenameTablesRequest ) -> Result<Response<RenameTablesResponse>, YdbError>

pub async fn describe_table( &mut self, req: DescribeTableRequest ) -> Result<Response<DescribeTableResponse>, YdbError>

pub async fn execute_data_query( &mut self, req: ExecuteDataQueryRequest ) -> Result<Response<ExecuteDataQueryResponse>, YdbError>

pub async fn execute_scheme_query( &mut self, req: ExecuteSchemeQueryRequest ) -> Result<Response<ExecuteSchemeQueryResponse>, YdbError>

pub async fn explain_data_query( &mut self, req: ExplainDataQueryRequest ) -> Result<Response<ExplainDataQueryResponse>, YdbError>

pub async fn prepare_data_query( &mut self, req: PrepareDataQueryRequest ) -> Result<Response<PrepareDataQueryResponse>, YdbError>

pub async fn keep_alive( &mut self, req: KeepAliveRequest ) -> Result<Response<KeepAliveResponse>, YdbError>

pub async fn begin_transaction( &mut self, req: BeginTransactionRequest ) -> Result<Response<BeginTransactionResponse>, YdbError>

pub async fn commit_transaction( &mut self, req: CommitTransactionRequest ) -> Result<Response<CommitTransactionResponse>, YdbError>

pub async fn rollback_transaction( &mut self, req: RollbackTransactionRequest ) -> Result<Response<RollbackTransactionResponse>, YdbError>

pub async fn delete_session( &mut self, req: DeleteSessionRequest ) -> Result<Response<DeleteSessionResponse>, YdbError>

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

Trait Implementations

impl<'a, C: Debug + Credentials> Debug for TableClientWithSession<'a, C>

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

Formats the value using the given formatter.

impl<'c> Executor<'c> for TableClientWithSession<'c, UpdatableToken>

Available on crate feature sqlx only.

type Database = Ydb

fn execute<'e, 'q: 'e, E>( self, query: E ) -> BoxFuture<'e, Result<YdbQueryResult, Error>>where E: Execute<'q, Self::Database> + 'q, 'c: 'e,

Execute the query and return the total number of rows affected.

fn execute_many<'e, 'q: 'e, E>( self, query: E ) -> BoxStream<'e, Result<YdbQueryResult, Error>>where E: Execute<'q, Self::Database> + 'q, 'c: 'e,

Execute multiple queries and return the rows affected from each query, in a stream.

fn fetch_many<'e, 'q: 'e, E>( self, _query: E ) -> BoxStream<'e, Result<Either<YdbQueryResult, YdbRow>, Error>>where E: Execute<'q, Self::Database> + 'q, 'c: 'e,

Execute multiple queries and return the generated results as a stream from each query, in a stream.

fn fetch_optional<'e, 'q: 'e, E>( self, _query: E ) -> BoxFuture<'e, Result<Option<YdbRow>, Error>>where E: Execute<'q, Self::Database> + 'q, 'c: 'e,

Execute the query and returns at most one row.

fn prepare_with<'e, 'q: 'e>( self, _sql: &'q str, _parameters: &'e [YdbTypeInfo] ) -> BoxFuture<'e, Result<YdbStatement, Error>>where 'c: 'e,

Prepare the SQL query, with parameter type information, to inspect the type information about its parameters and results.

fn fetch<'e, 'q, E>( self, query: E ) -> Pin<Box<dyn Stream<Item = Result<<Self::Database as Database>::Row, Error>> + Send + 'e, Global>>where 'q: 'e, 'c: 'e, E: 'q + Execute<'q, Self::Database>,

Execute the query and return the generated results as a stream.

fn fetch_all<'e, 'q, E>( self, query: E ) -> Pin<Box<dyn Future<Output = Result<Vec<<Self::Database as Database>::Row, Global>, Error>> + Send + 'e, Global>>where 'q: 'e, 'c: 'e, E: 'q + Execute<'q, Self::Database>,

Execute the query and return all the generated results, collected into a Vec.

fn fetch_one<'e, 'q, E>( self, query: E ) -> Pin<Box<dyn Future<Output = Result<<Self::Database as Database>::Row, Error>> + Send + 'e, Global>>where 'q: 'e, 'c: 'e, E: 'q + Execute<'q, Self::Database>,

Execute the query and returns exactly one row.

fn prepare<'e, 'q>( self, query: &'q str ) -> Pin<Box<dyn Future<Output = Result<<Self::Database as HasStatement<'q>>::Statement, Error>> + Send + 'e, Global>>where 'q: 'e, 'c: 'e,

Prepare the SQL query to inspect the type information of its parameters and results.