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

use super::*;

pub(super) fn extend_assignments(assignments: &mut Vec<Assignment>, next: Vec<Assignment>) {
    for assignment in next {
        push_assignment(assignments, assignment);
    }
}

pub(super) fn push_column(columns: &mut Vec<Meta>, field: Meta) {
    if !columns.iter().any(|existing| existing.db == field.db) {
        columns.push(field);
    }
}

pub(super) fn push_assignment(assignments: &mut Vec<Assignment>, assignment: Assignment) {
    assignments.retain(|existing| existing.field.db != assignment.field.db);
    assignments.push(assignment);
}

pub(super) fn select_item_for_field<T>(field: Field<T>) -> SelectItem {
    let alias = field_alias(field.meta);
    SelectItem {
        expr: field.expr(),
        alias,
    }
}

pub(super) fn select_item_for_ref<T>(field: FieldRef<T>) -> SelectItem {
    let alias = field_ref_alias(field.meta, field.qualifier.as_deref());
    SelectItem {
        expr: field.expr(),
        alias,
    }
}

pub(super) fn select_item_for_meta(meta: Meta) -> SelectItem {
    let alias = field_alias(&meta);
    SelectItem {
        expr: ValueExpr::field(meta, None),
        alias,
    }
}

pub(super) fn select_item_for_source_meta(meta: Meta, qualifier: Option<&str>) -> SelectItem {
    let alias = field_alias(&meta);
    SelectItem {
        expr: ValueExpr::field(meta, qualifier.map(str::to_owned)),
        alias,
    }
}

pub(super) fn normalized_assignments(next: impl IntoAssignments) -> Vec<Assignment> {
    let mut assignments = Vec::new();
    extend_assignments(&mut assignments, next.into_assignments());
    assignments
}

pub(super) fn push_returning_fields(source: &Source, items: &mut Vec<SelectItem>) {
    let qualifier = source.explicit_alias().or_else(|| match source {
        Source::Table { name, .. } | Source::View { name, .. } => name.rsplit('.').next(),
        _ => None,
    });
    source.for_each_field(|meta| items.push(select_item_for_source_meta(*meta, qualifier)));
}

pub(super) fn field_alias(meta: &Meta) -> Option<String> {
    (meta.api != meta.db).then(|| meta.api.to_owned())
}

pub(super) fn field_ref_alias(meta: &Meta, qualifier: Option<&str>) -> Option<String> {
    match qualifier {
        Some(qualifier) => Some(format!("{qualifier}_{}", meta.api)),
        None => field_alias(meta),
    }
}