Struct TableClient 

pub struct TableClient { /* private fields */ }

Client for YDB table service (SQL queries)

Table service used for work with data abd DB struct with SQL queries.

TableClient contains options for make queries. See TableClient::retry_transaction for examples.

Implementations

impl TableClient

pub fn clone_with_timeouts(&self, timeouts: TimeoutSettings) -> Self

pub fn clone_with_retry_timeout(&self, timeout: Duration) -> Self

Clone the table client and set new retry timeouts

pub fn clone_with_no_retry(&self) -> Self

Clone the table client and deny retries

pub fn clone_with_idempotent_operations(&self, idempotent: bool) -> Self

Clone the table client and set feature operations as idempotent (can retry in more cases)

pub fn clone_with_transaction_options(&self, opts: TransactionOptions) -> Self

pub async fn retry_execute_scan_query( &self, query: Query, ) -> YdbResult<StreamResult>

Execute scan query. The method will auto-retry errors while start query execution, but no retries after server start streaming result.

pub async fn retry_execute_scheme_query<T: Into<String>>( &self, query: T, ) -> YdbResult<()>

Execute scheme query with retry policy

pub async fn retry_execute_bulk_upsert( &self, table_path: String, rows: Vec<Value>, ) -> YdbResult<()>

Execute bulk upsert with retry policy

pub async fn retry_transaction<CallbackFuture, CallbackResult>( &self, callback: impl Fn(Box<dyn Transaction>) -> CallbackFuture, ) -> YdbResultWithCustomerErr<CallbackResult>

where CallbackFuture: Future<Output = YdbResultWithCustomerErr<CallbackResult>>,

Retry callback in transaction

retries callback as retry policy. every call of callback will within new transaction retry will call callback next time if:

1. allow by retry policy
2. callback return retriable error

Example with move lambda args:

    let res: Option<i32> = table_client.retry_transaction(|mut t| async move {
        let value: Value = t.query(Query::new("SELECT 1 + 1 as sum")).await?
            .into_only_row()?
            .remove_field_by_name("sum")?;
        let res: Option<i32> = value.try_into()?;
        return Ok(res);
    }).await?;
    assert_eq!(Some(2), res);

Example without move lambda args - it allow to borrow external items:

    let mut attempts: AtomicUsize = AtomicUsize::new(0);
    let res: Option<i32> = table_client.retry_transaction(|mut t| async {
        let mut t = t; // explicit move lambda argument inside async code block for borrow checker
        attempts.fetch_add(1, Ordering::Relaxed); // can borrow outer values istead of move
        let value: Value = t.query(Query::new("SELECT 1 + 1 as sum")).await?
            .into_only_row()?
            .remove_field_by_name("sum")?;
        let res: Option<i32> = value.try_into()?;
        return Ok(res);
    }).await?;
    assert_eq!(Some(2), res);
    assert_eq!(1, attempts.load(Ordering::Relaxed));

pub fn with_error_on_truncate(self, error_on_truncate: bool) -> Self

pub async fn copy_table( &self, source_path: String, destination_path: String, ) -> YdbResult<()>

pub async fn copy_tables(&self, tables: Vec<CopyTableItem>) -> YdbResult<()>

Trait Implementations

impl Clone for TableClient

fn clone(&self) -> TableClient

Returns a duplicate of the value.

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

Performs copy-assignment from source.