sift-query-sqlx 0.1.0

PostgreSQL renderer and sqlx executor for SiftQuery
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

use super::typed;
use sift_query_core::{CustomOperator, ValueType};

use sift_query_core::ConfigError;

#[cfg(feature = "postgres-types")]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ArrayQuery {
    Contains,
    ContainedBy,
    Overlap,
}
#[cfg(feature = "postgres-types")]
pub fn array(value_type: ValueType, mode: ArrayQuery) -> Result<CustomOperator, ConfigError> {
    if !matches!(value_type, ValueType::ArrayI64 | ValueType::ArrayText) {
        return Err(ConfigError::Invalid(
            "expected a native array field".to_owned(),
        ));
    }
    let (name, template) = match mode {
        ArrayQuery::Contains => ("array_contains", "{field} @> {0}"),
        ArrayQuery::ContainedBy => ("array_contained_by", "{field} <@ {0}"),
        ArrayQuery::Overlap => ("array_overlap", "{field} && {0}"),
    };
    let name = if value_type == ValueType::ArrayText {
        match mode {
            ArrayQuery::Contains => "array_text_contains",
            ArrayQuery::ContainedBy => "array_text_contained_by",
            ArrayQuery::Overlap => "array_text_overlap",
        }
    } else {
        name
    };
    Ok(typed(name, template, value_type, value_type))
}

#[cfg(feature = "postgres-types")]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum RangeQuery {
    Contains,
    ContainsElement,
    ContainedBy,
    Overlap,
    Left,
    Right,
    Adjacent,
}
#[cfg(feature = "postgres-types")]
pub fn range(mode: RangeQuery) -> CustomOperator {
    let (name, template, input) = match mode {
        RangeQuery::Contains => ("range_contains", "{field} @> {0}", ValueType::Int8Range),
        RangeQuery::ContainsElement => ("range_element", "{field} @> {0}", ValueType::I64),
        RangeQuery::ContainedBy => ("range_contained_by", "{field} <@ {0}", ValueType::Int8Range),
        RangeQuery::Overlap => ("range_overlap", "{field} && {0}", ValueType::Int8Range),
        RangeQuery::Left => ("range_left", "{field} << {0}", ValueType::Int8Range),
        RangeQuery::Right => ("range_right", "{field} >> {0}", ValueType::Int8Range),
        RangeQuery::Adjacent => ("range_adjacent", "{field} -|- {0}", ValueType::Int8Range),
    };
    typed(name, template, ValueType::Int8Range, input)
}
#[cfg(feature = "postgres-types")]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum NetworkQuery {
    Contains,
    ContainsOrEqual,
    ContainedBy,
    ContainedByOrEqual,
    Overlap,
}
#[cfg(feature = "postgres-types")]
pub fn network(mode: NetworkQuery) -> CustomOperator {
    let (name, template) = match mode {
        NetworkQuery::Contains => ("net_contains", "{field} >> {0}"),
        NetworkQuery::ContainsOrEqual => ("net_contains_eq", "{field} >>= {0}"),
        NetworkQuery::ContainedBy => ("net_contained_by", "{field} << {0}"),
        NetworkQuery::ContainedByOrEqual => ("net_contained_by_eq", "{field} <<= {0}"),
        NetworkQuery::Overlap => ("net_overlap", "{field} && {0}"),
    };
    typed(name, template, ValueType::Network, ValueType::Network)
}