Struct tarantool_rs::Stream

pub struct Stream { /* private fields */ }

Abstraction, providing sequential processing of requests.

With streams there is a guarantee that the server instance will not handle the next request in a stream until it has completed the previous one (docs).

Example

use tarantool_rs::{Connection, Executor, ExecutorExt};

let connection = Connection::builder().build("localhost:3301").await.unwrap();

// This will print 'fast' and then 'slow'
let eval_slow_fut = connection
    .eval("fiber = require('fiber'); fiber.sleep(0.5); return ...;", ("slow", ))
    .inspect(|res| println!("{:?}", res));
let eval_fast_fut = connection
    .eval("return ...;", ("fast", ))
    .inspect(|res| println!("{:?}", res));
let _ = tokio::join!(eval_slow_fut, eval_fast_fut);

// This will print 'slow' and then 'fast', since slow request was created first and have smaller sync
let stream = connection.stream();
let eval_slow_fut = stream
    .eval("fiber = require('fiber'); fiber.sleep(0.5); return ...;", ("slow", ))
    .inspect(|res| println!("{:?}", res));
let eval_fast_fut = stream
    .eval("return ...;", ("fast", ))
    .inspect(|res| println!("{:?}", res));
let _ = tokio::join!(eval_slow_fut, eval_fast_fut);

Trait Implementations

impl Clone for Stream

fn clone(&self) -> Stream

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Stream

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

Formats the value using the given formatter.

impl Executor for Stream

fn send_encoded_request<'life0, 'async_trait>( &'life0 self, request: EncodedRequest ) -> Pin<Box<dyn Future<Output = Result<Value>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Send encoded request.

fn stream(&self) -> Stream

Get new Stream.

fn transaction_builder(&self) -> TransactionBuilder

Prepare TransactionBuilder, which can be used to override parameters and create Transaction.

fn transaction<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = Result<Transaction>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Create Transaction with parameters from builder.

fn get_cached_sql_statement_id<'life0, 'life1, 'async_trait>( &'life0 self, statement: &'life1 str ) -> Pin<Box<dyn Future<Output = Option<u64>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,