Function parse 

pub fn parse(input: &str) -> QailResult<QailCmd>

Parse a complete QAIL query string (v2 syntax only).

Uses keyword-based syntax: get table fields * where col = value

Examples found in repository

examples/test_floats.rs (line 15)

fn main() {
    let tests = [
        ("Simple float", "get stats fields 100.0 as val"),
        ("Zero float", "get stats fields 0.0 as val"),
        ("Pi", "get stats fields 3.14 as val"),
        ("CASE with floats", "get stats fields case when x > 0 then 100.0 else 0.0 end as rate"),
    ];
    
    for (name, test) in tests {
        println!("{}:", name);
        match parse(test) {
            Ok(cmd) => println!("  ✅ {}\n", cmd.to_sql()),
            Err(e) => println!("  ❌ {}\n", e),
        }
    }
}

examples/test_param_repro.rs (line 6)

fn main() {
    let query = "get::t 'coalesce(uc.unread_count, 0)@unread_count";
    
    match parse(query) {
        Ok(cmd) => {
            let res = cmd.to_sql_parameterized();
            println!("SQL: {}", res.sql);
            if res.sql.contains("coalesce(uc.unread_count, 0) AS \"unread_count\"") || res.sql.contains("COALESCE(uc.unread_count, 0) AS \"unread_count\"") {
                println!("SUCCESS: Alias found correctly.");
            } else {
                println!("FAILURE: Alias missing in parameterized SQL.");
                std::process::exit(1);
            }
        }
        Err(e) => {
            eprintln!("Parse error: {}", e);
            std::process::exit(1);
        }
    }
}

examples/test_joins.rs (line 7)

fn main() {
    let q2 = "get a left join b on b.x = a.x left join c on c.y = a.y fields a.id";
    println!("2 JOINs: {}", parse(q2).map(|_| "OK".to_string()).unwrap_or_else(|e| e.to_string()));
    
    let q3 = "get a left join b on b.x = a.x left join c on c.y = a.y left join d on d.z = a.z fields a.id";
    println!("3 JOINs: {}", parse(q3).map(|_| "OK".to_string()).unwrap_or_else(|e| e.to_string()));
    
    let q7 = "get a left join b on b.x = a.x left join c on c.y = a.y left join d on d.z = a.z left join e on e.w = a.w left join f on f.v = a.v left join g on g.u = a.u left join h on h.t = a.t fields a.id";
    println!("7 JOINs: {}", parse(q7).map(|c| format!("OK - {} joins", c.joins.len())).unwrap_or_else(|e| e.to_string()));
}

examples/test_cte_parse.rs (line 10)

fn main() {
    // Complete WhatsApp insights query with all 6 columns
    let query = "with stats as (get whatsapp_messages fields count(distinct phone_number) as total_contacts, count(*) as total_messages, count(*) filter (where direction = 'outbound' and created_at > now() - 24h) as messages_sent_24h, count(*) filter (where direction = 'inbound' and created_at > now() - 24h) as messages_received_24h, count(*) filter (where direction = 'inbound' and status = 'received') as unread_messages, count(*) filter (where direction = 'outbound' and created_at > now() - 24h and status in ('delivered', 'read')) as successful_deliveries_24h) get stats";
    
    println!("Complete WhatsApp Insights Query (6 columns):");
    match parse(query) {
        Ok(cmd) => println!("✅\n{}", cmd.to_sql()),
        Err(e) => println!("❌ {}", e),
    }
}

examples/test_subquery.rs (line 12)

fn main() {
    println!("=== Testing INSERT...SELECT ===\n");
    
    // Test 1: Basic INSERT SELECT
    let query1 = "add archive fields id, name from (get users fields id, name where active = false)";
    println!("Query 1: {}", query1);
    match parse(query1) {
        Ok(cmd) => {
            println!("  source_query: {:?}", cmd.source_query.is_some());
            println!("  SQL: {}\n", cmd.to_sql());
        }
        Err(e) => println!("  Parse error: {:?}\n", e),
    }
    
    println!("=== Testing Subquery in SET ===\n");
    
    // Test 2: Subquery in UPDATE
    let query2 = "set orders values total = (get items fields sum(price) where order_id = orders.id) where id = :id";
    println!("Query 2: {}", query2);
    match parse(query2) {
        Ok(cmd) => println!("  SQL: {}\n", cmd.to_sql()),
        Err(e) => println!("  Parse error: {:?}\n", e),
    }
    
    // Test 3: Simple subquery value
    let query3 = "set users values role_id = (get roles fields id where name = 'admin') where user_id = :id";
    println!("Query 3: {}", query3);
    match parse(query3) {
        Ok(cmd) => println!("  SQL: {}\n", cmd.to_sql()),
        Err(e) => println!("  Parse error: {:?}\n", e),
    }
}

examples/audit_syntax.rs (line 12)

fn main() {
    println!("=== Testing DISTINCT ON with Expressions ===\n");
    
    // Test 1: Simple DISTINCT ON (column)
    let q1 = "get distinct on (phone_number) messages fields phone_number, content order by phone_number, created_at desc";
    println!("Test 1 (DISTINCT ON column):");
    match parse(q1) {
        Ok(cmd) => println!("  OK: {}\n", cmd.to_sql()),
        Err(e) => println!("  ERR: {}\n", e),
    }
    
    // Test 2: DISTINCT ON with CASE WHEN expression
    let q2 = r#"get distinct on (case when phone like '0%' then '62' || substring(phone from 2) else phone end) orders 
        fields phone, name order by case when phone like '0%' then '62' || substring(phone from 2) else phone end, created_at desc"#;
    println!("Test 2 (DISTINCT ON CASE WHEN):");
    match parse(q2) {
        Ok(cmd) => println!("  OK: {}\n", cmd.to_sql()),
        Err(e) => println!("  ERR: {}\n", e),
    }
    
    // Test 3: DISTINCT ON with function
    let q3 = "get distinct on (lower(email)) users fields email, name order by lower(email), id";
    println!("Test 3 (DISTINCT ON function):");
    match parse(q3) {
        Ok(cmd) => println!("  OK: {}\n", cmd.to_sql()),
        Err(e) => println!("  ERR: {}\n", e),
    }
}

Additional examples can be found in:

• examples/test_coalesce.rs
• examples/test_order_by.rs
• examples/test_full_insights.rs
• examples/test_upsert.rs
• examples/test_multi_cte.rs
• examples/test_case_when.rs
• examples/test_string_funcs.rs
• examples/test_conversations.rs