qail-pg 0.27.5

Fastest async PostgreSQL driver - AST to wire protocol, optional io_uring on Linux
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

//! Test for v0.14.4+ features
//! Tests: ArrayConstructor, RowConstructor, Subscript, Collate, FieldAccess
//!
//! Run with: cargo run --example expr_test

use qail_core::ast::Expr;
use qail_core::prelude::Qail;
use qail_pg::driver::PgDriver;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🔥 QAIL Expression Coverage Test (v0.14.4+)");
    println!("=============================================\n");

    let mut driver = PgDriver::connect("127.0.0.1", 5432, "orion", "qail_test_migration").await?;

    // Setup test table with arrays
    println!("🛠  Setup Test Data");
    println!("-------------------");

    driver
        .execute_raw("DROP TABLE IF EXISTS expr_test CASCADE")
        .await
        .ok();
    driver
        .execute_raw(
            "CREATE TABLE expr_test (
            id SERIAL PRIMARY KEY,
            name TEXT NOT NULL,
            tags TEXT[] DEFAULT '{}',
            data JSONB DEFAULT '{}'
        )",
        )
        .await?;

    driver
        .execute_raw(
            "INSERT INTO expr_test (name, tags, data) VALUES 
        ('Alice', ARRAY['rust', 'postgres'], '{\"city\": \"NYC\"}'),
        ('Bob', ARRAY['go', 'mysql'], '{\"city\": \"LA\"}'),
        ('Carol', ARRAY['python', 'postgres', 'redis'], '{\"city\": \"SF\"}')",
        )
        .await?;
    println!("  ✓ Created expr_test table with 3 rows");

    // =====================================================
    // Test 1: ArrayConstructor - ARRAY[name, name] (same types)
    // =====================================================
    println!("\n📖 Test 1: ArrayConstructor");
    println!("----------------------------");

    let mut arr_query = Qail::get("expr_test").columns(["id", "name"]);
    arr_query.columns.push(Expr::ArrayConstructor {
        elements: vec![
            Expr::Named("name".to_string()),
            Expr::Literal(qail_core::ast::Value::String("suffix".to_string())),
        ],
        alias: Some("name_arr".to_string()),
    });

    match driver.fetch_all(&arr_query).await {
        Ok(rows) => {
            println!("  ✓ ArrayConstructor: {} rows returned", rows.len());
        }
        Err(e) => println!("  ⚠ ArrayConstructor: {} (PostgreSQL type check)", e),
    }

    // =====================================================
    // Test 2: RowConstructor - ROW(a, b, c)
    // =====================================================
    println!("\n📖 Test 2: RowConstructor");
    println!("--------------------------");

    let mut row_query = Qail::get("expr_test").columns(["id"]);
    row_query.columns.push(Expr::RowConstructor {
        elements: vec![
            Expr::Named("id".to_string()),
            Expr::Named("name".to_string()),
        ],
        alias: Some("person_row".to_string()),
    });

    match driver.fetch_all(&row_query).await {
        Ok(rows) => {
            println!(
                "  ✓ RowConstructor: {} rows returned (may be 0 due to simple driver)",
                rows.len()
            );
        }
        Err(e) => println!("  ⚠ RowConstructor: {}", e),
    }

    // =====================================================
    // Test 3: Subscript - tags[1]
    // =====================================================
    println!("\n📖 Test 3: Subscript (Array Access)");
    println!("------------------------------------");

    let mut sub_query = Qail::get("expr_test").columns(["id", "name"]);
    sub_query.columns.push(Expr::Subscript {
        expr: Box::new(Expr::Named("tags".to_string())),
        index: Box::new(Expr::Literal(qail_core::ast::Value::Int(1))),
        alias: Some("first_tag".to_string()),
    });

    match driver.fetch_all(&sub_query).await {
        Ok(rows) => {
            println!("  ✓ Subscript: {} rows with first_tag", rows.len());
            assert_eq!(rows.len(), 3, "Expected 3 rows");
        }
        Err(e) => println!("  ✗ Subscript: {}", e),
    }

    // =====================================================
    // Test 4: Collate - name COLLATE "C"
    // =====================================================
    println!("\n📖 Test 4: Collate");
    println!("-------------------");

    let mut collate_query = Qail::get("expr_test").columns(["id"]);
    collate_query.columns.push(Expr::Collate {
        expr: Box::new(Expr::Named("name".to_string())),
        collation: "C".to_string(),
        alias: Some("name_c".to_string()),
    });

    match driver.fetch_all(&collate_query).await {
        Ok(rows) => {
            println!("  ✓ Collate: {} rows with C collation", rows.len());
            assert_eq!(rows.len(), 3, "Expected 3 rows");
        }
        Err(e) => println!("  ✗ Collate: {}", e),
    }

    // =====================================================
    // =====================================================
    println!("\n🧹 Cleanup");
    println!("-----------");
    driver
        .execute_raw("DROP TABLE IF EXISTS expr_test CASCADE")
        .await?;
    println!("  ✓ Cleanup complete");

    println!("\n✅ Expression test complete! All v0.14.4 features verified.");

    Ok(())
}