Struct skytable::query::Pipeline

pub struct Pipeline { /* private fields */ }

Pipeline

A pipeline can be used to send multiple queries at once to the server. Queries in a pipeline are executed independently of one another, but they are executed serially unless otherwise configured

Implementations

impl Pipeline

pub const fn new() -> Self

Create a new pipeline

pub fn query_count(&self) -> usize

Returns the number of queries that were appended to this pipeline

pub fn push_owned(&mut self, q: Query)

Same as Self::push, but passes ownership to the Pipeline

pub fn push(&mut self, q: &Query)

Add a query to this pipeline

Note: It’s not possible to get the query back from the pipeline since it’s not indexed (and doing so would be an unnecessary waste of space and time). That’s why we take a reference which allows the caller to continue owning the Query item

pub fn add(self, q: &Query) -> Self

Add a query to this pipeline (builder pattern)

This is intended to be used with the “builder pattern”. For example:

use skytable::{query, Pipeline};

let pipeline = Pipeline::new()
    .add(&query!("create space myspace"))
    .add(&query!("drop space myspace"));
assert_eq!(pipeline.query_count(), 2);

Trait Implementations

impl<Q: AsRef<Query>> Extend<Q> for Pipeline

fn extend<T: IntoIterator<Item = Q>>(&mut self, iter: T)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<Q: AsRef<Query>, I> From<I> for Pipeline

where I: Iterator<Item = Q>,

fn from(iter: I) -> Self

Converts to this type from the input type.

impl<Q: AsRef<Query>> FromIterator<Q> for Pipeline

fn from_iter<T: IntoIterator<Item = Q>>(iter: T) -> Self

Creates a value from an iterator.