rqb 0.1.2

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

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);
    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 push_all_source_fields(source: &Source, items: &mut Vec<SelectItem>) {
    source.for_each_field(|meta| items.push(select_item_for_meta(*meta)));
}

pub(super) fn push_default_source_fields(source: &Source, items: &mut Vec<SelectItem>) {
    let qualifier = source.explicit_alias();
    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<T>(field: &FieldRef<T>) -> Option<String> {
    match &field.qualifier {
        Some(qualifier) => Some(format!("{qualifier}_{}", field.meta.api)),
        None => field_alias(field.meta),
    }
}