qail-core 0.28.0

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

//! Test String Functions

use qail_core::parse;
use qail_core::transpiler::ToSql;

fn main() {
    println!("=== Testing String Functions ===\n");

    // Test 1: SUBSTRING
    let query1 = "get users fields substring(phone from 2) as phone_trimmed";
    println!("Query 1 (SUBSTRING):");
    match parse(query1) {
        Ok(cmd) => println!("  SQL: {}\n", cmd.to_sql()),
        Err(e) => println!("  Error: {}\n", e),
    }

    // Test 2: String concatenation
    let query2 = "get users fields first_name || ' ' || last_name as full_name";
    println!("Query 2 (Concat ||):");
    match parse(query2) {
        Ok(cmd) => println!("  SQL: {}\n", cmd.to_sql()),
        Err(e) => println!("  Error: {}\n", e),
    }

    // Test 2b: Simple function with one arg
    let query2b = "get x fields upper(name)";
    println!("Query 2b (UPPER - simple):");
    match parse(query2b) {
        Ok(cmd) => println!("  SQL: {}\n", cmd.to_sql()),
        Err(e) => println!("  Error: {}\n", e),
    }

    // Test 2c: Function with two identifier args
    let query2c = "get x fields coalesce(a, b)";
    println!("Query 2c (COALESCE - two idents):");
    match parse(query2c) {
        Ok(cmd) => println!("  SQL: {}\n", cmd.to_sql()),
        Err(e) => println!("  Error: {}\n", e),
    }

    // Test 2d: Function with string literal arg
    let query2d = "get x fields coalesce(name, 'Unknown')";
    println!("Query 2d (COALESCE - with string literal):");
    match parse(query2d) {
        Ok(cmd) => println!("  SQL: {}\n", cmd.to_sql()),
        Err(e) => println!("  Error: {}\n", e),
    }

    // Test 3: REPLACE with only identifiers
    let query3a = "get users fields replace(phone, old, new)";
    println!("Query 3a (REPLACE - identifiers only):");
    match parse(query3a) {
        Ok(cmd) => println!("  SQL: {}\n", cmd.to_sql()),
        Err(e) => println!("  Error: {}\n", e),
    }

    // Test 3b: REPLACE with string literals
    let query3 = "get users fields replace(phone, '+', '')";
    println!("Query 3 (REPLACE - with strings):");
    match parse(query3) {
        Ok(cmd) => println!("  SQL: {}\n", cmd.to_sql()),
        Err(e) => println!("  Error: {}\n", e),
    }
}