qail-core 1.3.2

AST-native query builder - type-safe expressions, zero SQL strings
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

use crate::transpiler::traits::SqlGenerator;

pub(crate) fn split_table_reference(reference: &str) -> Option<(&str, Option<&str>)> {
    let parts = reference.split_whitespace().collect::<Vec<_>>();
    match parts.as_slice() {
        [] => None,
        [table] => Some((table, None)),
        [table, alias] => Some((table, Some(alias))),
        [table, as_keyword, alias] if as_keyword.eq_ignore_ascii_case("as") => {
            Some((table, Some(alias)))
        }
        _ => None,
    }
}

pub(crate) fn render_table_reference(reference: &str, generator: &dyn SqlGenerator) -> String {
    match split_table_reference(reference) {
        Some((table, Some(alias))) => format!(
            "{} {}",
            generator.quote_identifier(table),
            generator.quote_identifier(alias)
        ),
        Some((table, None)) => generator.quote_identifier(table),
        None => generator.quote_identifier(reference),
    }
}

pub(crate) fn table_reference_base(reference: &str) -> &str {
    split_table_reference(reference)
        .map(|(table, _)| table)
        .unwrap_or(reference)
}

pub(crate) fn table_reference_sql_qualifier(reference: &str) -> Option<&str> {
    split_table_reference(reference).map(|(table, alias)| alias.unwrap_or(table))
}

pub(crate) fn qualifier_for_column_reference<'a>(
    reference: &'a str,
    qualifier: &str,
) -> Option<&'a str> {
    let (table, alias) = split_table_reference(reference)?;
    if alias.is_some_and(|alias| alias == qualifier) || table == qualifier {
        Some(alias.unwrap_or(table))
    } else {
        None
    }
}

pub(crate) fn qualifier_for_column_path<'a>(
    reference: &'a str,
    parts: &[&str],
) -> Option<(&'a str, usize)> {
    let (table, alias) = split_table_reference(reference)?;
    if parts.is_empty() {
        return None;
    }

    if let Some(alias) = alias
        && ident_eq(alias, parts[0])
    {
        return Some((alias, 1));
    }

    let table_parts = table.split('.').collect::<Vec<_>>();
    if parts.len() > table_parts.len()
        && table_parts
            .iter()
            .zip(parts)
            .all(|(expected, actual)| ident_eq(expected, actual))
    {
        return Some((alias.unwrap_or(table), table_parts.len()));
    }

    if let Some(bare_table) = table_parts.last()
        && parts.len() > 1
        && ident_eq(bare_table, parts[0])
    {
        return Some((alias.unwrap_or(bare_table), 1));
    }

    None
}

fn ident_eq(left: &str, right: &str) -> bool {
    left.trim_matches('"')
        .eq_ignore_ascii_case(right.trim_matches('"'))
}