Struct Select

pub struct Select<'r, C: Connection, R, T = ()> { /* private fields */ }

A select future

Implementations

impl<C, R, T> Select<'_, C, R, T>

where C: Connection,

pub fn into_owned(self) -> Select<'static, C, R, T>

Converts to an owned type which can easily be moved to a different thread

impl<C> Select<'_, C, Value>

where C: Connection,

pub fn range(self, range: impl Into<KeyRange>) -> Self

Restricts the records selected to those in the specified range

impl<C, R> Select<'_, C, Vec<R>>

where C: Connection,

pub fn range(self, range: impl Into<KeyRange>) -> Self

Restricts the records selected to those in the specified range

impl<'r, C, R> Select<'r, C, R>

where C: Connection, R: DeserializeOwned,

pub fn live(self) -> Select<'r, C, R, Live>

Turns a normal select query into a live query

Examples

// Select the namespace/database to use
db.use_ns("namespace").use_db("database").await?;

// Listen to all updates on a table
let mut stream = db.select("person").live().await?;

// Listen to updates on a range of records
let mut stream = db.select("person").range("jane".."john").live().await?;

// Listen to updates on a specific record
let mut stream = db.select(("person", "h5wxrf2ewk8xjxosxtyc")).live().await?;

// The returned stream implements `futures::Stream` so we can
// use it with `futures::StreamExt`, for example.
while let Some(result) = stream.next().await {
    handle(result);
}

// Handle the result of the live query notification
fn handle(result: Result<Notification<Person>>) {
    match result {
        Ok(notification) => println!("{notification:?}"),
        Err(error) => eprintln!("{error}"),
    }
}

Trait Implementations

impl<'r, C: Debug + Connection, R: Debug, T: Debug> Debug for Select<'r, C, R, T>

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

Formats the value using the given formatter.

impl<'r, Client, R> IntoFuture for Select<'r, Client, Option<R>>

where Client: Connection, R: DeserializeOwned,

type Output = Result<Option<R>, Error>

The output that the future will produce on completion.

type IntoFuture = Pin<Box<dyn Future<Output = <Select<'r, Client, Option<R>> as IntoFuture>::Output> + Sync + Send + 'r>>

Which kind of future are we turning this into?

fn into_future(self) -> Self::IntoFuture

Creates a future from a value.

impl<'r, Client, R> IntoFuture for Select<'r, Client, Option<R>, Live>

where Client: Connection, R: DeserializeOwned,

type Output = Result<Stream<Option<R>>, Error>

The output that the future will produce on completion.

type IntoFuture = Pin<Box<dyn Future<Output = <Select<'r, Client, Option<R>, Live> as IntoFuture>::Output> + Sync + Send + 'r>>

Which kind of future are we turning this into?

fn into_future(self) -> Self::IntoFuture

Creates a future from a value.

impl<'r, Client> IntoFuture for Select<'r, Client, Value>

where Client: Connection,

type Output = Result<Value, Error>

The output that the future will produce on completion.

type IntoFuture = Pin<Box<dyn Future<Output = <Select<'r, Client, Value> as IntoFuture>::Output> + Sync + Send + 'r>>

Which kind of future are we turning this into?

fn into_future(self) -> Self::IntoFuture

Creates a future from a value.

impl<'r, Client> IntoFuture for Select<'r, Client, Value, Live>

where Client: Connection,

type Output = Result<Stream<Value>, Error>

The output that the future will produce on completion.

type IntoFuture = Pin<Box<dyn Future<Output = <Select<'r, Client, Value, Live> as IntoFuture>::Output> + Sync + Send + 'r>>

Which kind of future are we turning this into?

fn into_future(self) -> Self::IntoFuture

Creates a future from a value.

impl<'r, Client, R> IntoFuture for Select<'r, Client, Vec<R>>

where Client: Connection, R: DeserializeOwned,

type Output = Result<Vec<R>, Error>

The output that the future will produce on completion.

type IntoFuture = Pin<Box<dyn Future<Output = <Select<'r, Client, Vec<R>> as IntoFuture>::Output> + Sync + Send + 'r>>

Which kind of future are we turning this into?

fn into_future(self) -> Self::IntoFuture

Creates a future from a value.

impl<'r, Client, R> IntoFuture for Select<'r, Client, Vec<R>, Live>

where Client: Connection, R: DeserializeOwned,

type Output = Result<Stream<Vec<R>>, Error>

The output that the future will produce on completion.

type IntoFuture = Pin<Box<dyn Future<Output = <Select<'r, Client, Vec<R>, Live> as IntoFuture>::Output> + Sync + Send + 'r>>

Which kind of future are we turning this into?

fn into_future(self) -> Self::IntoFuture

Creates a future from a value.