rqb 0.1.7

sqlx-first typed Postgres query builder.
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
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

pub(super) use crate::source::{Join, JoinKind};
pub(super) use crate::{
    BindValue, BoolExpr, Cte, Field, FieldRef, IntoFieldMetas, Meta, Param, Source, ValueExpr, cte,
    raw as raw_sql, subquery,
};
pub(super) use crate::{Error, Result};

macro_rules! impl_filter_methods {
    ($ty:ty) => {
        impl $ty {
            /// Adds a `WHERE` predicate, composing with existing predicates using `AND`.
            #[inline]
            pub fn filter(mut self, filter: BoolExpr) -> Self {
                self.filter = Some(BoolExpr::and_option(self.filter, filter));
                self
            }

            /// Adds a `WHERE` predicate, composing with existing predicates using `OR`.
            ///
            /// Use `filter(or([...]))` when only part of the current predicate tree
            /// should be OR-grouped.
            #[inline]
            pub fn or_filter(mut self, filter: BoolExpr) -> Self {
                self.filter = Some(BoolExpr::or_option(self.filter, filter));
                self
            }

            /// Replaces the entire `WHERE` predicate.
            #[inline]
            pub fn replace_filter(mut self, filter: BoolExpr) -> Self {
                self.filter = Some(filter);
                self
            }

            /// Adds a `WHERE` predicate only when `condition` is true.
            #[inline]
            pub fn filter_if(self, condition: bool, filter: BoolExpr) -> Self {
                if condition { self.filter(filter) } else { self }
            }

            /// Adds a `WHERE` predicate built from an optional value.
            pub fn filter_option<T>(self, value: Option<T>, f: impl FnOnce(T) -> BoolExpr) -> Self {
                match value {
                    Some(value) => self.filter(f(value)),
                    None => self,
                }
            }

            /// Adds an OR-composed `WHERE` predicate only when `condition` is true.
            #[inline]
            pub fn or_filter_if(self, condition: bool, filter: BoolExpr) -> Self {
                if condition {
                    self.or_filter(filter)
                } else {
                    self
                }
            }

            /// Adds an OR-composed `WHERE` predicate built from an optional value.
            pub fn or_filter_option<T>(
                self,
                value: Option<T>,
                f: impl FnOnce(T) -> BoolExpr,
            ) -> Self {
                match value {
                    Some(value) => self.or_filter(f(value)),
                    None => self,
                }
            }
        }
    };
}

mod ast;
mod conflict;
mod constructors;
mod delete;
mod helpers;
mod insert;
mod items;
mod merge;
mod raw_stmt;
mod select;
mod set;
mod update;
mod validate;

pub use ast::{
    Assignment, Changeset, ColumnConflictBuilder, ConflictFields, ConstraintConflictBuilder,
    Delete, Insert, Insertable, LockMode, MatchedMergeBuilder, Merge,
    NotMatchedBySourceMergeBuilder, NotMatchedMergeBuilder, OrderItem, RawStmt, Select, SetQuery,
    Stmt, Update,
};
pub(crate) use ast::{
    AssignmentValue, ConflictAction, ConflictClause, ConflictTarget, FetchClause, GroupByItem,
    InsertBody, IntoAssignments, LockWait, MergeAction, MergeWhen, NullsPosition, OrderDirection,
    RowLimit, RowLock, SelectItem, SetOperator,
};
pub use constructors::{
    delete_from, except, except_all, insert, intersect, intersect_all, merge_into, raw, select,
    union, union_all, update,
};
pub use insert::InsertRow;
pub use items::{ColumnList, IntoColumn, IntoColumns};

use helpers::*;

#[cfg(test)]
mod tests;