rorm 0.10.0

A asynchronous declarative ORM written in pure rust.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

use crate::conditions::collections::CollectionOperator;
use crate::conditions::{BinaryOperator, Condition, Value};
use crate::internal::query_context::flat_conditions::FlatCondition;
use crate::internal::query_context::ConditionBuilder;

/// An "IN" expression
///
/// The implementation will definitely change,
/// but it's better to have some form of "IN" than none.
#[derive(Clone, Debug)]
pub struct In<A, B> {
    /// SQL operator to use
    pub operator: InOperator,
    /// The left side of the operator
    pub fst_arg: A,
    /// The mulidple values on the operator's right side
    pub snd_arg: Vec<B>,
}

/// The operator of an "IN" expression
#[derive(Copy, Clone, Debug)]
pub enum InOperator {
    /// Representation of "{} IN ({}, ...)" in SQL
    In,
    /// Representation of "{} NOT IN ({}, ...)" in SQL
    NotIn,
}

impl<'a, A, B> Condition<'a> for In<A, B>
where
    A: Condition<'a>,
    B: Condition<'a>,
{
    fn build(&self, mut builder: ConditionBuilder<'_, 'a>) {
        let bool_fallback;
        let collection_operator;
        let binary_operator;
        match self.operator {
            InOperator::In => {
                bool_fallback = false;
                collection_operator = CollectionOperator::Or;
                binary_operator = BinaryOperator::Equals;
            }
            InOperator::NotIn => {
                bool_fallback = true;
                collection_operator = CollectionOperator::And;
                binary_operator = BinaryOperator::NotEquals;
            }
        }

        if self.snd_arg.is_empty() {
            Value::Bool(bool_fallback).build(builder);
        } else {
            builder.push_condition(FlatCondition::StartCollection(collection_operator));
            for snd_arg in self.snd_arg.iter() {
                builder.push_condition(FlatCondition::BinaryCondition(binary_operator));
                self.fst_arg.build(builder.reborrow());
                snd_arg.build(builder.reborrow());
            }
            builder.push_condition(FlatCondition::EndCollection);
        }
    }
}