tellaro-query-language 2.0.0

A flexible, human-friendly query language for searching and filtering structured data
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
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223

//! Tests for array operators with post-processing.
//!
//! This module tests ANY, ALL, NONE operators with array fields
//! and verifies post-processing preserves original data.

use serde_json::json;
use tellaro_query_language::Tql;

/// Test ANY operator with single value (array)
#[test]
fn test_any_operator_with_single_value() {
    let tql = Tql::new();
    let data = vec![
        json!({"tags": ["python"]}), // Single element array
        json!({"tags": ["java"]}),
    ];

    // ANY works on arrays - single element array should match
    let results = tql
        .query(&data, "any tags eq 'python'")
        .expect("Query should succeed");
    assert_eq!(results.len(), 1);
    assert!(results[0].get("tags").and_then(|t| t.as_array()).is_some());
}

/// Test ANY operator with array field
#[test]
fn test_any_operator_with_array_field() {
    let tql = Tql::new();
    let data = vec![
        json!({"tags": ["python", "rust"]}),
        json!({"tags": ["java", "javascript"]}),
        json!({"tags": ["python", "go"]}),
    ];

    let results = tql
        .query(&data, "any tags eq 'python'")
        .expect("Query should succeed");
    assert_eq!(results.len(), 2);
}

/// Test ALL operator with array field
#[test]
fn test_all_operator_with_array_field() {
    let tql = Tql::new();
    let data = vec![
        json!({"scores": [100, 100, 100]}), // All 100
        json!({"scores": [100, 90, 100]}),  // Not all 100
        json!({"scores": [100]}),           // Single 100
    ];

    let results = tql
        .query(&data, "all scores eq 100")
        .expect("Query should succeed");
    assert_eq!(results.len(), 2); // First and third records
}

/// Test NONE operator with array field
#[test]
fn test_none_operator_with_array_field() {
    let tql = Tql::new();
    let data = vec![
        json!({"status": ["error", "warning"]}),
        json!({"status": ["info", "debug"]}),
        json!({"status": ["error"]}),
    ];

    let results = tql
        .query(&data, "none status eq 'error'")
        .expect("Query should succeed");
    assert_eq!(results.len(), 1);
    assert!(results[0]
        .get("status")
        .and_then(|s| s.as_array())
        .map(|a| a.iter().all(|v| v.as_str() != Some("error")))
        .unwrap_or(false));
}

/// Test array operators with comparison operators (not just eq)
#[test]
fn test_array_operators_with_comparison_operators() {
    let tql = Tql::new();
    let data = vec![
        json!({"scores": [50, 75, 90]}),
        json!({"scores": [30, 40, 50]}),
        json!({"scores": [80, 85, 95]}),
    ];

    // Any score > 70
    let results = tql
        .query(&data, "any scores gt 70")
        .expect("Query should succeed");
    assert_eq!(results.len(), 2); // First and third

    // All scores < 60
    let results = tql
        .query(&data, "all scores lt 60")
        .expect("Query should succeed");
    assert_eq!(results.len(), 1); // Second only
}

/// Test array operators with logical operators
#[test]
fn test_array_operators_with_logical_operators() {
    let tql = Tql::new();
    let data = vec![
        json!({"tags": ["python", "data"], "active": true}),
        json!({"tags": ["java"], "active": false}),
        json!({"tags": ["python", "web"], "active": true}),
    ];

    let results = tql
        .query(&data, "any tags eq 'python' and active = true")
        .expect("Query should succeed");
    assert_eq!(results.len(), 2);
}

/// Test array operators preserve original data
#[test]
fn test_array_operators_preserve_original_data() {
    let tql = Tql::new();
    let data = vec![json!({
        "id": 1,
        "tags": ["a", "b", "c"],
        "metadata": {"key": "value"}
    })];

    let results = tql
        .query(&data, "any tags eq 'b'")
        .expect("Query should succeed");
    assert_eq!(results.len(), 1);

    // Verify original data is preserved
    let record = &results[0];
    assert_eq!(record.get("id").and_then(|v| v.as_i64()), Some(1));
    assert!(record.get("tags").and_then(|t| t.as_array()).is_some());
    assert!(record.get("metadata").and_then(|m| m.get("key")).is_some());
}

/// Test array operators with nested fields
#[test]
fn test_array_operators_with_nested_fields() {
    let tql = Tql::new();
    let data = vec![
        json!({"user": {"roles": ["admin", "user"]}}),
        json!({"user": {"roles": ["guest"]}}),
        json!({"user": {"roles": ["admin", "moderator"]}}),
    ];

    let results = tql
        .query(&data, "any user.roles eq 'admin'")
        .expect("Query should succeed");
    assert_eq!(results.len(), 2);
}

/// Test array operators with empty arrays
#[test]
fn test_array_operators_with_empty_arrays() {
    let tql = Tql::new();
    let data = vec![
        json!({"tags": []}),
        json!({"tags": ["a"]}),
        json!({"tags": ["a", "b"]}),
    ];

    // ANY on empty array should return false
    let results = tql
        .query(&data, "any tags eq 'a'")
        .expect("Query should succeed");
    assert_eq!(results.len(), 2); // Second and third

    // NONE on empty array should return true (vacuous truth)
    let results = tql
        .query(&data, "none tags eq 'z'")
        .expect("Query should succeed");
    assert_eq!(results.len(), 3); // All records
}

/// Test ANY with contains operator
#[test]
fn test_any_with_contains() {
    let tql = Tql::new();
    let data = vec![
        json!({"names": ["Alice", "Bob"]}),
        json!({"names": ["Charlie", "David"]}),
    ];

    let results = tql
        .query(&data, "any names contains 'li'")
        .expect("Query should succeed");
    assert_eq!(results.len(), 2); // Alice and Charlie both contain 'li'
}

/// Test ALL with contains operator
#[test]
fn test_all_with_contains() {
    let tql = Tql::new();
    let data = vec![
        json!({"words": ["apple", "application"]}), // All contain 'appl'
        json!({"words": ["apple", "banana"]}),      // Not all contain 'appl'
    ];

    let results = tql
        .query(&data, "all words contains 'appl'")
        .expect("Query should succeed");
    assert_eq!(results.len(), 1);
}

/// Test multiple array operators in same query
#[test]
fn test_multiple_array_operators() {
    let tql = Tql::new();
    let data = vec![
        json!({"tags": ["a", "b"], "scores": [10, 20]}),
        json!({"tags": ["c"], "scores": [30, 40]}),
        json!({"tags": ["a"], "scores": [50]}),
    ];

    let results = tql
        .query(&data, "any tags eq 'a' and any scores gt 15")
        .expect("Query should succeed");
    assert_eq!(results.len(), 2); // First and third (third has score 50)
}