athena_rs 0.83.0

Database gateway API
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

use crate::parser::query_builder::Condition;
use crate::utils::format::camel_to_snake_case;
use serde_json::Value;

/// Internal representation of a simple equality filter provided by gateway requests.
///
#[derive(Debug)]
pub struct RequestCondition {
    pub eq_column: String,
    pub eq_value: Value,
}

/// Checks if a string is in camelCase format.
///
/// Returns `true` if the string contains at least one uppercase letter
/// that is not at the start of the string, indicating camelCase format.
fn is_camel_case(s: &str) -> bool {
    s.chars()
        .skip(1) // Skip the first character
        .any(|c| c.is_ascii_uppercase())
}

impl RequestCondition {
    /// `RequestCondition` new implementation
    ///
    /// ## Arguments
    /// - `eq_column`: String
    /// - `eq_value`: Value
    ///
    pub fn new(eq_column: String, eq_value: Value) -> Self {
        Self {
            eq_column,
            eq_value,
        }
    }
}

/// Converts normalized request conditions into Postgres query conditions.
///
/// If the column name is already in camelCase format, it bypasses the converter
/// and queries the database with the actual camelCase column name.
pub fn to_query_conditions(
    conditions: &[RequestCondition],
    convert_camel_case: bool,
) -> Vec<Condition> {
    conditions
        .iter()
        .map(|condition: &RequestCondition| {
            // Check if the column is already in camelCase - if so, bypass conversion
            let is_already_camel_case: bool = is_camel_case(&condition.eq_column);
            let column_name: String = if convert_camel_case && !is_already_camel_case {
                let converted: String = camel_to_snake_case(&condition.eq_column);
                converted
            } else {
                condition.eq_column.clone()
            };
            let query_condition: Condition =
                Condition::eq(&column_name, condition.eq_value.clone());
            query_condition
        })
        .collect()
}