cratestack-sqlx 0.3.3

Rust-native schema-first framework for typed HTTP APIs, generated clients, and backend services.
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
110
111
112

//! Per-kind filter rendering for spatial / JSON / coalesce filters —
//! each is a distinct SQL shape (PostGIS function call, jsonb operator
//! chain, COALESCE() comparison) and lives in its own helper to keep
//! the top-level filter dispatcher readable.

use std::fmt::Write;

use cratestack_sql::FilterOp;

pub(super) fn render_spatial_filter_sql(
    filter: &cratestack_sql::SpatialFilter,
    sql: &mut String,
    bind_index: &mut usize,
) {
    match filter {
        cratestack_sql::SpatialFilter::CoversGeographyPoint { column, .. } => {
            let _ = write!(
                sql,
                "ST_Covers({column}::geography, ST_MakePoint(${lng}, ${lat})::geography)",
                lng = *bind_index,
                lat = *bind_index + 1,
            );
            *bind_index += 2;
        }
        cratestack_sql::SpatialFilter::DWithinGeographyPoint { column, .. } => {
            let _ = write!(
                sql,
                "ST_DWithin({column}::geography, ST_MakePoint(${lng}, ${lat})::geography, ${rad})",
                lng = *bind_index,
                lat = *bind_index + 1,
                rad = *bind_index + 2,
            );
            *bind_index += 3;
        }
    }
}

pub(super) fn render_json_filter_sql(
    filter: &cratestack_sql::JsonFilter,
    sql: &mut String,
    bind_index: &mut usize,
) {
    match filter {
        cratestack_sql::JsonFilter::HasKey { column, key: _ } => {
            let _ = write!(sql, "{column} ? ${bind_index}");
            *bind_index += 1;
        }
        cratestack_sql::JsonFilter::GetText {
            column,
            key: _,
            op,
            value: _,
        } => {
            let _ = write!(sql, "{column} ->> ${bind_index}");
            *bind_index += 1;
            match op {
                FilterOp::Eq => render_json_text_binary_sql("=", sql, bind_index),
                FilterOp::Ne => render_json_text_binary_sql("!=", sql, bind_index),
                FilterOp::Lt => render_json_text_binary_sql("<", sql, bind_index),
                FilterOp::Lte => render_json_text_binary_sql("<=", sql, bind_index),
                FilterOp::Gt => render_json_text_binary_sql(">", sql, bind_index),
                FilterOp::Gte => render_json_text_binary_sql(">=", sql, bind_index),
                FilterOp::IsNull => sql.push_str(" IS NULL"),
                FilterOp::IsNotNull => sql.push_str(" IS NOT NULL"),
                FilterOp::In
                | FilterOp::Contains
                | FilterOp::StartsWith
                | FilterOp::EqOrNull => {
                    unreachable!("JsonFilter::GetText built with unsupported op {:?}", op);
                }
            }
        }
    }
}

fn render_json_text_binary_sql(operator: &str, sql: &mut String, bind_index: &mut usize) {
    let _ = write!(sql, " {operator} ${bind_index}");
    *bind_index += 1;
}

pub(super) fn render_coalesce_filter_sql(
    filter: &cratestack_sql::CoalesceFilter,
    sql: &mut String,
    bind_index: &mut usize,
) {
    sql.push_str("COALESCE(");
    for (idx, column) in filter.columns.iter().enumerate() {
        if idx > 0 {
            sql.push_str(", ");
        }
        sql.push_str(column);
    }
    sql.push(')');
    match filter.op {
        FilterOp::Eq => render_coalesce_binary_sql("=", sql, bind_index),
        FilterOp::Ne => render_coalesce_binary_sql("!=", sql, bind_index),
        FilterOp::Lt => render_coalesce_binary_sql("<", sql, bind_index),
        FilterOp::Lte => render_coalesce_binary_sql("<=", sql, bind_index),
        FilterOp::Gt => render_coalesce_binary_sql(">", sql, bind_index),
        FilterOp::Gte => render_coalesce_binary_sql(">=", sql, bind_index),
        FilterOp::IsNull => sql.push_str(" IS NULL"),
        FilterOp::IsNotNull => sql.push_str(" IS NOT NULL"),
        FilterOp::In | FilterOp::Contains | FilterOp::StartsWith | FilterOp::EqOrNull => {
            unreachable!("CoalesceFilter built with unsupported op {:?}", filter.op);
        }
    }
}

fn render_coalesce_binary_sql(operator: &str, sql: &mut String, bind_index: &mut usize) {
    let _ = write!(sql, " {operator} ${bind_index}");
    *bind_index += 1;
}