athena_rs 3.4.7

Database driver
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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

//! ## `operator` for the query builder.
//!
//! This module contains the operators for the query builder.
//!
//! ### `ConditionOperator`
//! The `ConditionOperator` enum is used to represent the operators for the query builder.
//!
//! #### `Eq`
//! The `Eq` operator is used to represent the equality operator.
//!
//! #### `Neq`
//! The `Neq` operator is used to represent the not equal operator.
//!
//! #### `Gt`
//! The `Gt` operator is used to represent the greater than operator.
//!
//! #### `Gte`
//! The `Gte` operator is used to represent the greater than or equal to operator.
//!
//! #### `Lt`
//! The `Lt` operator is used to represent the less than operator.
//!
//! #### `Lte`
//! The `Lte` operator is used to represent the less than or equal to operator.
//!
//! #### `Like`
//! The `Like` operator is used to represent the like operator.
//!
//! #### `ILike`
//! The `ILike` operator is used to represent the case-insensitive like operator.
//!
//! #### `Is`
//! The `Is` operator is used to represent the is operator.
//!
//! #### `In`
//! The `In` operator is used to represent the in operator.
//!
//! #### `Contains`
//! The `Contains` operator is used to represent the contains operator.
//!

use serde_json::Value;

use crate::parser::query_builder::{
    Condition, ConditionOperator, build_array_clause, build_in_clause, build_is_clause,
    create_placeholder_clause,
};

/// ## `format_condition_clause`
/// # Condition Operator Descriptions
///
/// * `ConditionOperator::Eq` - Formats an equality condition.
/// * `ConditionOperator::Neq` - Formats a not equal condition.
/// * `ConditionOperator::Gt` - Formats a greater than condition.
/// * `ConditionOperator::Gte` - Formates a greater than or equal to condition.
/// * `ConditionOperator::Lt` - Formats a less than condition.
/// * `ConditionOperator::Lte` - Formats a less than or equal to condition.
/// * `ConditionOperator::Like` - Formats a like condition.
/// * `ConditionOperator::ILike` - Formats a case-insensitive like condition.
/// * `ConditionOperator::Is` - Formats an is condition.
/// * `ConditionOperator::In` - Formats an in condition.
/// * `ConditionOperator::Contains` - Formats a contains condition.
/// * `ConditionOperator::Contained` - Formats a contained condition.
///
pub(crate) fn format_condition_clause(
    column: &str,
    condition: &Condition,
    idx: &mut usize,
    values: &mut Vec<Value>,
) -> Option<String> {
    let clause: String = match condition.operator {
        ConditionOperator::Eq => create_placeholder_clause(
            column,
            idx,
            values,
            condition,
            condition.values.first()?,
            "=",
        )?,
        ConditionOperator::Neq => create_placeholder_clause(
            column,
            idx,
            values,
            condition,
            condition.values.first()?,
            "<>",
        )?,
        ConditionOperator::Gt => create_placeholder_clause(
            column,
            idx,
            values,
            condition,
            condition.values.first()?,
            ">",
        )?,
        ConditionOperator::Gte => create_placeholder_clause(
            column,
            idx,
            values,
            condition,
            condition.values.first()?,
            ">=",
        )?,
        ConditionOperator::Lt => create_placeholder_clause(
            column,
            idx,
            values,
            condition,
            condition.values.first()?,
            "<",
        )?,
        ConditionOperator::Lte => create_placeholder_clause(
            column,
            idx,
            values,
            condition,
            condition.values.first()?,
            "<=",
        )?,
        ConditionOperator::Like => create_placeholder_clause(
            column,
            idx,
            values,
            condition,
            condition.values.first()?,
            "LIKE",
        )?,
        ConditionOperator::ILike => create_placeholder_clause(
            column,
            idx,
            values,
            condition,
            condition.values.first()?,
            "ILIKE",
        )?,
        ConditionOperator::Is => build_is_clause(column, condition, idx, values)?,
        ConditionOperator::In => build_in_clause(column, condition, idx, values)?,
        ConditionOperator::Contains => build_array_clause(column, condition, idx, values, "@>")?,
        ConditionOperator::Contained => build_array_clause(column, condition, idx, values, "<@")?,
    };

    let clause = if condition.negated {
        format!("NOT ({})", clause)
    } else {
        clause
    };

    Some(clause)
}