4382580286

Build Type

push

github

Committed by GitHub

Commit Message

feat: Separate cache operation log environment and index environments (#1199)

Run Details

1370 of 1370 new or added lines in 33 files covered. (100.0%)

28671 of 41023 relevant lines covered (69.89%)

51121.29 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

72.52

/dozer-cache/src/cache/lmdb/cache/query/tests.rs

use crate::cache::{
    expression::{FilterExpression, Operator, QueryExpression},
    lmdb::tests::utils::{create_cache, insert_rec_1},
    test_utils::{query_from_filter, schema_1, schema_full_text, schema_multi_indices},
    RecordWithId, RoCache, RwCache,
};
use dozer_types::{
    serde_json::{from_value, json, Value},
    types::{Field, Record, Schema},
};

#[test]
fn query_secondary_sorted_inverted() {
    let (cache, schema, _) = create_cache(schema_1);

    let mut record = Record::new(
        schema.identifier,
        vec![
            Field::Int(1),
            Field::String("test".to_string()),
            Field::Int(2),
        ],
        None,
    );

    cache.insert(&mut record).unwrap();
    assert!(record.version.is_some());

    let filter = FilterExpression::And(vec![
        FilterExpression::Simple("a".to_string(), Operator::EQ, Value::from(1)),
        FilterExpression::Simple(
            "b".to_string(),
            Operator::EQ,
            Value::from("test".to_string()),
        ),
    ]);

    // Query with an expression
    let query = query_from_filter(filter);

    let records = cache.query(&query).unwrap();
    assert_eq!(cache.count(&query).unwrap(), 1);
    assert_eq!(records.len(), 1, "must be equal");
    assert_eq!(records[0].record, record, "must be equal");
}

#[test]
fn query_secondary_full_text() {
    let (cache, schema, _) = create_cache(schema_full_text);

    let mut record = Record::new(
        schema.identifier,
        vec![
            Field::String("today is a good day".into()),
            Field::Text("marry has a little lamb".into()),
        ],
        None,
    );

    cache.insert(&mut record).unwrap();
    assert!(record.version.is_some());

    let filter = FilterExpression::Simple("foo".into(), Operator::Contains, "good".into());

    let query = query_from_filter(filter);

    let records = cache.query(&query).unwrap();
    assert_eq!(cache.count(&query).unwrap(), 1);
    assert_eq!(records.len(), 1);
    assert_eq!(records[0].record, record);

    let filter = FilterExpression::Simple("bar".into(), Operator::Contains, "lamb".into());
    let query = query_from_filter(filter);
    let records = cache.query(&query).unwrap();
    assert_eq!(cache.count(&query).unwrap(), 1);
    assert_eq!(records.len(), 1);
    assert_eq!(records[0].record, record);
}

#[test]
fn query_secondary_vars() {
    let (cache, schema, _) = create_cache(schema_1);

    let items = vec![
        (1, Some("yuri".to_string()), Some(521)),
        (2, Some("mega".to_string()), Some(521)),
        (3, Some("james".to_string()), Some(523)),
        (4, Some("james".to_string()), Some(524)),
        (5, Some("steff".to_string()), Some(526)),
        (6, Some("mega".to_string()), Some(527)),
        (7, Some("james".to_string()), Some(528)),
        (8, Some("ava".to_string()), None),
    ];
    // 26 alphabets
    for val in items {
        insert_rec_1(&cache, &schema, val);
    }

    test_query(json!({}), 8, &cache);

    test_query(
        json!({
            "$order_by": { "c": "desc" }
        }),
        8,
        &cache,
    );

    test_query(json!({"$filter":{ "a": {"$eq": 1}}}), 1, &cache);

    test_query(json!({"$filter":{ "a": {"$eq": null}}}), 0, &cache);

    test_query(json!({"$filter":{ "c": {"$eq": 521}}}), 2, &cache);

    test_query(json!({"$filter":{ "c": {"$eq": null}}}), 1, &cache);

    test_query(
        json!({"$filter":{ "a": 1, "b": "yuri".to_string()}}),
        1,
        &cache,
    );

    // No compound index for a,c
    test_query_err(json!({"$filter":{ "a": 1, "c": 521}}), &cache);

    test_query(
        json!({
            "$filter":{ "c": {"$eq": 521}},
            "$order_by": { "c": "asc" }
        }),
        2,
        &cache,
    );

    test_query_record(
        json!({
            "$filter":{ "a": {"$eq": 1}},
            "$order_by": { "b": "asc" }
        }),
        vec![(0, 1, "yuri".to_string(), 521)],
        &schema,
        &cache,
    );

    // Range tests
    test_query(json!({"$filter":{ "c": {"$lte": null}}}), 0, &cache);

    test_query(json!({"$filter":{ "c": {"$lte": 521}}}), 2, &cache);

    test_query(json!({"$filter":{ "c": {"$gte": 521}}}), 7, &cache);

    test_query(json!({"$filter":{ "c": {"$gt": 521}}}), 5, &cache);

    test_query(json!({"$filter":{ "c": {"$lte": 524}}}), 4, &cache);

    test_query(json!({"$filter":{ "c": {"$lt": 524}}}), 3, &cache);

    test_query(json!({"$filter":{ "c": {"$lt": 600}}}), 7, &cache);

    test_query(json!({"$filter":{ "c": {"$gt": 200}}}), 7, &cache);

    test_query_record(
        json!({
            "$filter":{ "c": {"$gt": 526}},
            "$order_by": { "c": "asc" }
        }),
        vec![
            (5, 6, "mega".to_string(), 527),
            (6, 7, "james".to_string(), 528),
        ],
        &schema,
        &cache,
    );

    test_query_record(
        json!({
            "$filter":{ "c": {"$gt": 526}},
            "$order_by": { "c": "desc" }
        }),
        vec![
            (6, 7, "james".to_string(), 528),
            (5, 6, "mega".to_string(), 527),
        ],
        &schema,
        &cache,
    );
}

#[test]
fn query_secondary_multi_indices() {
    let (cache, schema, _) = create_cache(schema_multi_indices);

    for (id, text) in [
        (1, "apple ball cake dance"),
        (2, "ball cake dance egg"),
        (3, "cake dance egg fish"),
        (4, "dance egg fish glove"),
        (5, "egg fish glove heart"),
        (6, "fish glove heart igloo"),
        (7, "glove heart igloo jump"),
    ] {
        let mut record = Record {
            schema_id: schema.identifier,
            values: vec![Field::Int(id), Field::String(text.into())],
            version: None,
        };
        cache.insert(&mut record).unwrap();
        assert!(record.version.is_some());
    }

    let query = query_from_filter(FilterExpression::And(vec![
        FilterExpression::Simple("id".into(), Operator::GT, Value::from(2)),
        FilterExpression::Simple("text".into(), Operator::Contains, Value::from("dance")),
    ]));

    let records = cache.query(&query).unwrap();
    assert_eq!(cache.count(&query).unwrap(), 2);
    assert_eq!(
        records,
        vec![
            RecordWithId::new(
                2,
                Record {
                    schema_id: schema.identifier,
                    values: vec![Field::Int(3), Field::String("cake dance egg fish".into())],
                    version: Some(1)
                }
            ),
            RecordWithId::new(
                3,
                Record {
                    schema_id: schema.identifier,
                    values: vec![Field::Int(4), Field::String("dance egg fish glove".into())],
                    version: Some(1)
                }
            ),
        ]
    );
}

fn test_query_err(query: Value, cache: &dyn RwCache) {
    let query = from_value::<QueryExpression>(query).unwrap();
    let count_result = cache.count(&query);
    let result = cache.query(&query);

    assert!(matches!(
        count_result.unwrap_err(),
        crate::errors::CacheError::Plan(_)
    ),);
    assert!(matches!(
        result.unwrap_err(),
        crate::errors::CacheError::Plan(_)
    ),);
}
fn test_query(query: Value, count: usize, cache: &dyn RwCache) {
    let query = from_value::<QueryExpression>(query).unwrap();
    assert_eq!(cache.count(&query).unwrap(), count);
    let records = cache.query(&query).unwrap();

    assert_eq!(records.len(), count, "Count must be equal : {query:?}");
}

fn test_query_record(
    query: Value,
    expected: Vec<(u64, i64, String, i64)>,
    schema: &Schema,
    cache: &dyn RwCache,
) {
    let query = from_value::<QueryExpression>(query).unwrap();
    assert_eq!(cache.count(&query).unwrap(), expected.len());
    let records = cache.query(&query).unwrap();
    let expected = expected
        .into_iter()
        .map(|(id, a, b, c)| {
            RecordWithId::new(
                id,
                Record::new(
                    schema.identifier,
                    vec![Field::Int(a), Field::String(b), Field::Int(c)],
                    Some(1),
                ),
            )
        })
        .collect::<Vec<_>>();
    assert_eq!(records, expected);
}

1	use crate::cache::{
2	expression::{FilterExpression, Operator, QueryExpression},
3	lmdb::tests::utils::{create_cache, insert_rec_1},
4	test_utils::{query_from_filter, schema_1, schema_full_text, schema_multi_indices},
5	RecordWithId, RoCache, RwCache,
6	};
7	use dozer_types::{
8	serde_json::{from_value, json, Value},
9	types::{Field, Record, Schema},
10	};
11
12	#[test]	1✔
13	fn query_secondary_sorted_inverted() {	1✔
14	let (cache, schema, _) = create_cache(schema_1);	1✔
15		1✔
16	let mut record = Record::new(	1✔
17	schema.identifier,	1✔
18	vec![	1✔
19	Field::Int(1),	1✔
20	Field::String("test".to_string()),	1✔
21	Field::Int(2),	1✔
22	],	1✔
23	None,	1✔
24	);	1✔
25		1✔
26	cache.insert(&mut record).unwrap();	1✔
27	assert!(record.version.is_some());	1✔
28		×
29	let filter = FilterExpression::And(vec![	1✔
30	FilterExpression::Simple("a".to_string(), Operator::EQ, Value::from(1)),	1✔
31	FilterExpression::Simple(	1✔
32	"b".to_string(),	1✔
33	Operator::EQ,	1✔
34	Value::from("test".to_string()),	1✔
35	),	1✔
36	]);	1✔
37		1✔
38	// Query with an expression	1✔
39	let query = query_from_filter(filter);	1✔
40		1✔
41	let records = cache.query(&query).unwrap();	1✔
42	assert_eq!(cache.count(&query).unwrap(), 1);	1✔
43	assert_eq!(records.len(), 1, "must be equal");	1✔
44	assert_eq!(records[0].record, record, "must be equal");	1✔
45	}	1✔
46		×
47	#[test]	1✔
48	fn query_secondary_full_text() {	1✔
49	let (cache, schema, _) = create_cache(schema_full_text);	1✔
50		1✔
51	let mut record = Record::new(	1✔
52	schema.identifier,	1✔
53	vec![	1✔
54	Field::String("today is a good day".into()),	1✔
55	Field::Text("marry has a little lamb".into()),	1✔
56	],	1✔
57	None,	1✔
58	);	1✔
59		1✔
60	cache.insert(&mut record).unwrap();	1✔
61	assert!(record.version.is_some());	1✔
62		×
63	let filter = FilterExpression::Simple("foo".into(), Operator::Contains, "good".into());	1✔
64		1✔
65	let query = query_from_filter(filter);	1✔
66		1✔
67	let records = cache.query(&query).unwrap();	1✔
68	assert_eq!(cache.count(&query).unwrap(), 1);	1✔
69	assert_eq!(records.len(), 1);	1✔
70	assert_eq!(records[0].record, record);	1✔
71		×
72	let filter = FilterExpression::Simple("bar".into(), Operator::Contains, "lamb".into());	1✔
73	let query = query_from_filter(filter);	1✔
74	let records = cache.query(&query).unwrap();	1✔
75	assert_eq!(cache.count(&query).unwrap(), 1);	1✔
76	assert_eq!(records.len(), 1);	1✔
77	assert_eq!(records[0].record, record);	1✔
78	}	1✔
79		×
80	#[test]	1✔
81	fn query_secondary_vars() {	1✔
82	let (cache, schema, _) = create_cache(schema_1);	1✔
83		1✔
84	let items = vec![	1✔
85	(1, Some("yuri".to_string()), Some(521)),	1✔
86	(2, Some("mega".to_string()), Some(521)),	1✔
87	(3, Some("james".to_string()), Some(523)),	1✔
88	(4, Some("james".to_string()), Some(524)),	1✔
89	(5, Some("steff".to_string()), Some(526)),	1✔
90	(6, Some("mega".to_string()), Some(527)),	1✔
91	(7, Some("james".to_string()), Some(528)),	1✔
92	(8, Some("ava".to_string()), None),	1✔
93	];	1✔
94	// 26 alphabets	×
95	for val in items {	9✔
96	insert_rec_1(&cache, &schema, val);	8✔
97	}	8✔
98		×
99	test_query(json!({}), 8, &cache);	1✔
100		1✔
101	test_query(	1✔
102	json!({	1✔
103	"$order_by": { "c": "desc" }	1✔
104	}),	1✔
105	8,	1✔
106	&cache,	1✔
107	);	1✔
108		1✔
109	test_query(json!({"$filter":{ "a": {"$eq": 1}}}), 1, &cache);	1✔
110		1✔
111	test_query(json!({"$filter":{ "a": {"$eq": null}}}), 0, &cache);	1✔
112		1✔
113	test_query(json!({"$filter":{ "c": {"$eq": 521}}}), 2, &cache);	1✔
114		1✔
115	test_query(json!({"$filter":{ "c": {"$eq": null}}}), 1, &cache);	1✔
116		1✔
117	test_query(	1✔
118	json!({"$filter":{ "a": 1, "b": "yuri".to_string()}}),	1✔
119	1,	1✔
120	&cache,	1✔
121	);	1✔
122		1✔
123	// No compound index for a,c	1✔
124	test_query_err(json!({"$filter":{ "a": 1, "c": 521}}), &cache);	1✔
125		1✔
126	test_query(	1✔
127	json!({	1✔
128	"$filter":{ "c": {"$eq": 521}},	1✔
129	"$order_by": { "c": "asc" }	1✔
130	}),	1✔
131	2,	1✔
132	&cache,	1✔
133	);	1✔
134		1✔
135	test_query_record(	1✔
136	json!({	1✔
137	"$filter":{ "a": {"$eq": 1}},	1✔
138	"$order_by": { "b": "asc" }	1✔
139	}),	1✔
140	vec![(0, 1, "yuri".to_string(), 521)],	1✔
141	&schema,	1✔
142	&cache,	1✔
143	);	1✔
144		1✔
145	// Range tests	1✔
146	test_query(json!({"$filter":{ "c": {"$lte": null}}}), 0, &cache);	1✔
147		1✔
148	test_query(json!({"$filter":{ "c": {"$lte": 521}}}), 2, &cache);	1✔
149		1✔
150	test_query(json!({"$filter":{ "c": {"$gte": 521}}}), 7, &cache);	1✔
151		1✔
152	test_query(json!({"$filter":{ "c": {"$gt": 521}}}), 5, &cache);	1✔
153		1✔
154	test_query(json!({"$filter":{ "c": {"$lte": 524}}}), 4, &cache);	1✔
155		1✔
156	test_query(json!({"$filter":{ "c": {"$lt": 524}}}), 3, &cache);	1✔
157		1✔
158	test_query(json!({"$filter":{ "c": {"$lt": 600}}}), 7, &cache);	1✔
159		1✔
160	test_query(json!({"$filter":{ "c": {"$gt": 200}}}), 7, &cache);	1✔
161		1✔
162	test_query_record(	1✔
163	json!({	1✔
164	"$filter":{ "c": {"$gt": 526}},	1✔
165	"$order_by": { "c": "asc" }	1✔
166	}),	1✔
167	vec![	1✔
168	(5, 6, "mega".to_string(), 527),	1✔
169	(6, 7, "james".to_string(), 528),	1✔
170	],	1✔
171	&schema,	1✔
172	&cache,	1✔
173	);	1✔
174		1✔
175	test_query_record(	1✔
176	json!({	1✔
177	"$filter":{ "c": {"$gt": 526}},	1✔
178	"$order_by": { "c": "desc" }	1✔
179	}),	1✔
180	vec![	1✔
181	(6, 7, "james".to_string(), 528),	1✔
182	(5, 6, "mega".to_string(), 527),	1✔
183	],	1✔
184	&schema,	1✔
185	&cache,	1✔
186	);	1✔
187	}	1✔
188		×
189	#[test]	1✔
190	fn query_secondary_multi_indices() {	1✔
191	let (cache, schema, _) = create_cache(schema_multi_indices);	1✔
192		×
193	for (id, text) in [	7✔
194	(1, "apple ball cake dance"),	1✔
195	(2, "ball cake dance egg"),	1✔
196	(3, "cake dance egg fish"),	1✔
197	(4, "dance egg fish glove"),	1✔
198	(5, "egg fish glove heart"),	1✔
199	(6, "fish glove heart igloo"),	1✔
200	(7, "glove heart igloo jump"),	1✔
201	] {	×
202	let mut record = Record {	7✔
203	schema_id: schema.identifier,	7✔
204	values: vec![Field::Int(id), Field::String(text.into())],	7✔
205	version: None,	7✔
206	};	7✔
207	cache.insert(&mut record).unwrap();	7✔
208	assert!(record.version.is_some());	7✔
209	}	×
210		×
211	let query = query_from_filter(FilterExpression::And(vec![	1✔
212	FilterExpression::Simple("id".into(), Operator::GT, Value::from(2)),	1✔
213	FilterExpression::Simple("text".into(), Operator::Contains, Value::from("dance")),	1✔
214	]));	1✔
215		1✔
216	let records = cache.query(&query).unwrap();	1✔
217	assert_eq!(cache.count(&query).unwrap(), 2);	1✔
218	assert_eq!(	1✔
219	records,	1✔
220	vec![	1✔
221	RecordWithId::new(	1✔
222	2,	1✔
223	Record {	1✔
224	schema_id: schema.identifier,	1✔
225	values: vec![Field::Int(3), Field::String("cake dance egg fish".into())],	1✔
226	version: Some(1)	1✔
227	}	1✔
228	),	1✔
229	RecordWithId::new(	1✔
230	3,	1✔
231	Record {	1✔
232	schema_id: schema.identifier,	1✔
233	values: vec![Field::Int(4), Field::String("dance egg fish glove".into())],	1✔
234	version: Some(1)	1✔
235	}	1✔
236	),	1✔
237	]	1✔
238	);	1✔
239	}	1✔
240		×
241	fn test_query_err(query: Value, cache: &dyn RwCache) {	1✔
242	let query = from_value::<QueryExpression>(query).unwrap();	1✔
243	let count_result = cache.count(&query);	1✔
244	let result = cache.query(&query);	1✔
245		×
246	assert!(matches!(	1✔
247	count_result.unwrap_err(),	1✔
248	crate::errors::CacheError::Plan(_)	×
249	),);	×
250	assert!(matches!(	1✔
251	result.unwrap_err(),	1✔
252	crate::errors::CacheError::Plan(_)	×
253	),);	×
254	}	1✔
255	fn test_query(query: Value, count: usize, cache: &dyn RwCache) {	16✔
256	let query = from_value::<QueryExpression>(query).unwrap();	16✔
257	assert_eq!(cache.count(&query).unwrap(), count);	16✔
258	let records = cache.query(&query).unwrap();	16✔
259		16✔
260	assert_eq!(records.len(), count, "Count must be equal : {query:?}");	16✔
261	}	16✔
262		×
263	fn test_query_record(	3✔
264	query: Value,	3✔
265	expected: Vec<(u64, i64, String, i64)>,	3✔
266	schema: &Schema,	3✔
267	cache: &dyn RwCache,	3✔
268	) {	3✔
269	let query = from_value::<QueryExpression>(query).unwrap();	3✔
270	assert_eq!(cache.count(&query).unwrap(), expected.len());	3✔
271	let records = cache.query(&query).unwrap();	3✔
272	let expected = expected	3✔
273	.into_iter()	3✔
274	.map(\|(id, a, b, c)\| {	5✔
275	RecordWithId::new(	5✔
276	id,	5✔
277	Record::new(	5✔
278	schema.identifier,	5✔
279	vec![Field::Int(a), Field::String(b), Field::Int(c)],	5✔
280	Some(1),	5✔
281	),	5✔
282	)	5✔
283	})	5✔
284	.collect::<Vec<_>>();	3✔
285	assert_eq!(records, expected);	3✔
286	}	3✔

getdozer / dozer / 4382580286

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous