qqq-cli 0.8.0

Local-first task queue for coding agent sessions
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

use super::{Expr, Kind, compatible};
use anyhow::{Result, bail, ensure};

pub(super) fn tag_sql(parameter: &str) -> String {
    format!(
        "EXISTS (SELECT 1 FROM json_each(tasks.tags) AS task_tag
         WHERE task_tag.value COLLATE BINARY = {parameter})"
    )
}

fn arity(name: &str, args: &[Expr], min: usize, max: usize) -> Result<()> {
    ensure!(
        (min..=max).contains(&args.len()),
        "{name} expects {min}..={max} arguments, got {}",
        args.len()
    );
    Ok(())
}
fn require(name: &str, args: &[Expr], kind: Kind) -> Result<()> {
    ensure!(
        args.iter()
            .all(|arg| arg.kind == kind || arg.kind == Kind::Nil),
        "{name} requires {kind:?} arguments"
    );
    Ok(())
}

pub(super) fn compile(name: &str, args: Vec<Expr>) -> Result<Expr> {
    use Kind::{Boolean, Number, Text};
    let kind = match name {
        "like" | "glob" => {
            arity(name, &args, 2, if name == "like" { 3 } else { 2 })?;
            require(name, &args, Text)?;
            let operator = if name == "like" { "LIKE" } else { "GLOB" };
            let escape = args
                .get(2)
                .map(|arg| format!(" ESCAPE ({})", arg.sql))
                .unwrap_or_default();
            return Ok(Expr {
                sql: format!(
                    "COALESCE((({}) {operator} ({}){escape}),0)",
                    args[0].sql, args[1].sql
                ),
                kind: Boolean,
            });
        }
        "lower" | "upper" | "length" => {
            arity(name, &args, 1, 1)?;
            require(name, &args, Text)?;
            if name == "length" { Number } else { Text }
        }
        "trim" | "ltrim" | "rtrim" => {
            arity(name, &args, 1, 2)?;
            require(name, &args, Text)?;
            Text
        }
        "replace" => {
            arity(name, &args, 3, 3)?;
            require(name, &args, Text)?;
            Text
        }
        "instr" => {
            arity(name, &args, 2, 2)?;
            require(name, &args, Text)?;
            Number
        }
        "substr" => {
            arity(name, &args, 2, 3)?;
            require(name, &args[..1], Text)?;
            require(name, &args[1..], Number)?;
            Text
        }
        "abs" | "round" => {
            arity(name, &args, 1, if name == "abs" { 1 } else { 2 })?;
            require(name, &args, Number)?;
            Number
        }
        "coalesce" | "nullif" | "min" | "max" => {
            arity(name, &args, 2, if name == "nullif" { 2 } else { 127 })?;
            let mut kind = Kind::Nil;
            for arg in &args {
                kind = compatible(kind, arg.kind)?;
            }
            if matches!(name, "min" | "max") {
                ensure!(kind != Boolean, "{name} requires numbers or strings");
            }
            if name == "nullif" { args[0].kind } else { kind }
        }
        "date" | "time" | "datetime" | "julianday" | "unixepoch" | "strftime" => {
            let start = usize::from(name == "strftime");
            arity(name, &args, start, 127)?;
            if start == 1 {
                require(name, &args[..1], Text)?;
            }
            if let Some(time) = args.get(start) {
                ensure!(
                    matches!(time.kind, Text | Number | Kind::Nil),
                    "{name} time value requires text or number"
                );
            }
            if args.len() > start + 1 {
                require(name, &args[start + 1..], Text)?;
            }
            if matches!(name, "julianday" | "unixepoch") {
                Number
            } else {
                Text
            }
        }
        _ => bail!("unknown function `{name}`; see docs/filter-functions.md"),
    };
    // Every accepted name above is a literal allowlist entry, never caller SQL.
    let sql = format!(
        "{name}({})",
        args.iter()
            .map(|arg| arg.sql.as_str())
            .collect::<Vec<_>>()
            .join(",")
    );
    Ok(Expr { sql, kind })
}