Struct codd::expression::Project

pub struct Project<S, T, E> where
    S: Tuple,
    T: Tuple,
    E: Expression<S>,  { /* fields omitted */ }

Projects the tuples of an inner sub-expression of type S to tuples of type T.

Example:

use codd::{Database, expression::Project};

let mut db = Database::new();
let fruit = db.add_relation::<String>("R").unwrap();

db.insert(&fruit, vec!["Apple".to_string(), "BANANA".to_string(), "cherry".to_string()].into());

let lower = Project::new(
    &fruit,
    |t| t.to_lowercase(), // projecting closure
);

assert_eq!(vec!["apple", "banana", "cherry"], db.evaluate(&lower).unwrap().into_tuples());

Implementations

impl<S, T, E> Project<S, T, E> where
    S: Tuple,
    T: Tuple,
    E: Expression<S>, 

pub fn new<I>(expression: I, mapper: impl FnMut(&S) -> T + 'static) -> Self where
    I: IntoExpression<S, E>, 

Creates a new Project expression over expression with a closure mapper that projects tuples of expression to the resulting tuples.

pub fn expression(&self) -> &E

Returns a reference to the underlying sub-expression.

Trait Implementations

impl<S: Clone, T: Clone, E: Clone> Clone for Project<S, T, E> where
    S: Tuple,
    T: Tuple,
    E: Expression<S>, 

fn clone(&self) -> Project<S, T, E>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<S, T, E> Debug for Project<S, T, E> where
    S: Tuple,
    T: Tuple,
    E: Expression<S>, 

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

Formats the value using the given formatter.

impl<S, T, E> Expression<T> for Project<S, T, E> where
    S: Tuple,
    T: Tuple,
    E: Expression<S>, 

fn visit<V>(&self, visitor: &mut V) where
    V: Visitor, 

Visits this expression by a Visitor.

fn builder(&self) -> Builder<T, Self>

Returns an expression builder over this expression.

impl<T: Tuple> From<Project<T, T, Mono<T>>> for Mono<T>

fn from(project: Project<T, T, Mono<T>>) -> Self

Performs the conversion.