Struct Optional 

pub struct Optional<'outer, 'inner, S> { /* private fields */ }

This is the argument type used by the optional combinator.

Joining more optional columns can be done with the Optional::and method. Finally it is possible to return expressions or selections using Optional::then and Optional::then_select.

Implementations

impl<'outer, 'inner, S> Optional<'outer, 'inner, S>

pub fn and<T: EqTyp>( &mut self, col: impl IntoExpr<'inner, S, Typ = Option<T>>, ) -> Expr<'inner, S, T>

Join an optional column to the current row.

If the joined column is None, then the whole row will become None, from that moment forward.

let (total1, total2) = txn.query_one(optional(|row| {
    let val1 = row.and(Some(100));
    let val2 = row.and(Some(20));
    let total = val1.add(val2);
    let total1 = row.then(&total);

    let _ = row.and(None::<i64>);
    let total2 = row.then(total);

     (total1, total2)
}));
assert_eq!(total1, Some(120));
assert_eq!(total2, None);

pub fn is_none(&self) -> Expr<'outer, S, bool>

Return a bool column indicating whether the current row does not exists.

let (none1, none2) = txn.query_one(optional(|row| {
    let none1 = row.is_none();
    let _ = row.and(None::<i64>);
    let none2 = row.is_none();
    (none1, none2)
}));
assert_eq!(none1, false);
assert_eq!(none2, true);

pub fn is_some(&self) -> Expr<'outer, S, bool>

Return a bool column indicating whether the current row exists.

let (some1, some2) = txn.query_one(optional(|row| {
    let some1 = row.is_some();
    let _ = row.and(None::<i64>);
    let some2 = row.is_some();
    (some1, some2)
}));
assert_eq!(some1, true);
assert_eq!(some2, false);

pub fn and_then<T: EqTyp>( &self, col: impl IntoExpr<'inner, S, Typ = Option<T>>, ) -> Expr<'outer, S, Option<T>>

This is much like combining Self::and with Self::then, but it allows returning an optional value without mutating the Optional row.

let (val1, val2) = txn.query_one(optional(|row| {
   let val1 = row.and_then(None::<i64>);
   let val2 = row.and_then(Some(1));
   (val1, val2)
}));
assert_eq!(val1, None);
assert_eq!(val2, Some(1));

pub fn then<T: EqTyp + 'outer>( &self, col: impl IntoExpr<'inner, S, Typ = T>, ) -> Expr<'outer, S, Option<T>>

Return Some column if the current row exists and None column otherwise.

let (val1, val2) = txn.query_one(optional(|row| {
   let val1 = row.then(1);
   let _ = row.and(None::<i64>);
   let val2 = row.then(1);
   (val1, val2)
}));
assert_eq!(val1, Some(1));
assert_eq!(val2, None);

pub fn then_select<Out: 'static>( &self, d: impl IntoSelect<'inner, S, Out = Out>, ) -> Select<'outer, S, Option<Out>>

Returns a Select with optional result. Useful for returning multiple values in a single Option.

let pair = txn.query_one(optional(|row| {
   let val1 = row.and(Some(1));
   let val2 = row.and(Some(2));
   row.then_select((val1, val2))
}));
assert_eq!(pair, Some((1, 2)));