Struct cdrs_async::Session

pub struct Session<T> { /* fields omitted */ }

Session structure which allows clients making requests to a server.

Methods

impl Session<TransportTcp>

pub async fn connect<Addr: ToString>(
    addr: Addr,
    compressor: Compression,
    authenticator: Authenticator
) -> Result<Self>

impl Session<TransportTls>

pub async fn connect_tls<Addr: ToString>(
    __arg0: (Addr, TlsConnector),
    compressor: Compression,
    authenticator: Authenticator
) -> Result<Self>

Trait Implementations

impl<T: CDRSTransport> BatchExecutor for Session<T>

fn batch_with_params_tw<'life0, 'async_trait>(
    self: Pin<&'life0 mut Self>,
    batch: QueryBatch,
    with_tracing: bool,
    with_warnings: bool
) -> Pin<Box<dyn Future<Output = Result<Frame>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

fn batch_with_params<'life0, 'async_trait>(
    self: Pin<&'life0 mut Self>,
    batch: QueryBatch
) -> Pin<Box<dyn Future<Output = Result<Frame>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T: CDRSTransport> ExecExecutor for Session<T>

fn exec_with_params_tw<'life0, 'life1, 'async_trait>(
    self: Pin<&'life0 mut Self>,
    prepared: &'life1 PreparedQuery,
    query_parameters: QueryParams,
    with_tracing: bool,
    with_warnings: bool
) -> Pin<Box<dyn Future<Output = Result<Frame>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

fn exec_with_params<'life0, 'life1, 'async_trait>(
    self: Pin<&'life0 mut Self>,
    prepared: &'life1 CBytesShort,
    query_parameters: QueryParams
) -> Pin<Box<dyn Future<Output = Result<Frame>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

fn exec_with_values_tw<'life0, 'life1, 'async_trait, V: Into<QueryValues> + Send>(
    self: Pin<&'life0 mut Self>,
    prepared: &'life1 CBytesShort,
    values: V,
    with_tracing: bool,
    with_warnings: bool
) -> Pin<Box<dyn Future<Output = Result<Frame>> + Send + 'async_trait>> where
    V: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

fn exec_with_values<'life0, 'life1, 'async_trait, V: Into<QueryValues> + Send>(
    self: Pin<&'life0 mut Self>,
    prepared: &'life1 CBytesShort,
    values: V
) -> Pin<Box<dyn Future<Output = Result<Frame>> + Send + 'async_trait>> where
    V: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

fn exec_tw<'life0, 'life1, 'async_trait>(
    self: Pin<&'life0 mut Self>,
    prepared: &'life1 CBytesShort,
    with_tracing: bool,
    with_warnings: bool
) -> Pin<Box<dyn Future<Output = Result<Frame>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

fn exec<'life0, 'life1, 'async_trait>(
    self: Pin<&'life0 mut Self>,
    prepared: &'life1 CBytesShort
) -> Pin<Box<dyn Future<Output = Result<Frame>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

impl<T: CDRSTransport> PrepareExecutor for Session<T>

fn prepare_tw<'life0, 'async_trait, Q: ToString + Send>(
    self: Pin<&'life0 mut Self>,
    query: Q,
    with_tracing: bool,
    with_warnings: bool
) -> Pin<Box<dyn Future<Output = Result<PreparedQuery>> + Send + 'async_trait>> where
    Q: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

It prepares a query for execution, along with query itself the method takes with_tracing and with_warnings flags to get tracing information and warnings.

fn prepare<'life0, 'async_trait, Q: ToString + Send>(
    self: Pin<&'life0 mut Self>,
    query: Q
) -> Pin<Box<dyn Future<Output = Result<PreparedQuery>> + Send + 'async_trait>> where
    Q: 'async_trait,
    'life0: 'async_trait,
    Self: Send + 'async_trait, 

It prepares query without additional tracing information and warnings.

impl<T: CDRSTransport> QueryExecutor for Session<T>

fn query_with_params_tw<'life0, 'async_trait, Q: ToString + Send>(
    self: Pin<&'life0 mut Self>,
    query: Q,
    query_params: QueryParams,
    with_tracing: bool,
    with_warnings: bool
) -> Pin<Box<dyn Future<Output = Result<Frame>> + Send + 'async_trait>> where
    Q: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

fn query<'life0, 'async_trait, Q: ToString + Send>(
    self: Pin<&'life0 mut Self>,
    query: Q
) -> Pin<Box<dyn Future<Output = Result<Frame>> + Send + 'async_trait>> where
    Q: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

Executes a query with default parameters: * TDB

fn query_tw<'life0, 'async_trait, Q: ToString + Send>(
    self: Pin<&'life0 mut Self>,
    query: Q,
    with_tracing: bool,
    with_warnings: bool
) -> Pin<Box<dyn Future<Output = Result<Frame>> + Send + 'async_trait>> where
    Q: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

Executes a query with ability to trace it and see warnings, and default parameters: * TBD

fn query_with_values<'life0, 'async_trait, Q: ToString + Send, V: Into<QueryValues> + Send>(
    self: Pin<&'life0 mut Self>,
    query: Q,
    values: V
) -> Pin<Box<dyn Future<Output = Result<Frame>> + Send + 'async_trait>> where
    Q: 'async_trait,
    V: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

Executes a query with bounded values (either with or without names).

fn query_with_values_tw<'life0, 'async_trait, Q: ToString + Send, V: Into<QueryValues> + Send>(
    self: Pin<&'life0 mut Self>,
    query: Q,
    values: V,
    with_tracing: bool,
    with_warnings: bool
) -> Pin<Box<dyn Future<Output = Result<Frame>> + Send + 'async_trait>> where
    Q: 'async_trait,
    V: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

Executes a query with bounded values (either with or without names) and ability to see warnings, trace a request and default parameters.

fn query_with_params<'life0, 'async_trait, Q: ToString + Send>(
    self: Pin<&'life0 mut Self>,
    query: Q,
    query_params: QueryParams
) -> Pin<Box<dyn Future<Output = Result<Frame>> + Send + 'async_trait>> where
    Q: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

Executes a query with query params without warnings and tracing.