3975475267

Build Type

github

Committed by GitHub

Commit Message

Merge cbe01669c into 02f99a9c0

Pull Request Pull Request #699: feature: Atomatically trim record history in `RecordWriter`

Run Details

229 of 229 new or added lines in 6 files covered. (100.0%)

22375 of 33744 relevant lines covered (66.31%)

45958.9 hits per line

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

92.41

/dozer-api/src/grpc/shared_impl/filter/mod.rs

use dozer_cache::cache::expression::{FilterExpression, Operator};
use dozer_types::{
    json_value_to_field,
    ordered_float::OrderedFloat,
    types::{Field, Schema},
};

use crate::grpc::types::{value, Operation, OperationType, Record, Value};

pub fn op_satisfies_filter(
    op: &Operation,
    filter: Option<&FilterExpression>,
    schema: &Schema,
) -> bool {
    if let Some(filter) = filter {
        if op.typ == OperationType::Insert as i32 || op.typ == OperationType::Delete as i32 {
            record_satisfies_filter(op.new.as_ref().unwrap(), filter, schema)
        } else if op.typ == OperationType::Update as i32 {
            record_satisfies_filter(op.old.as_ref().unwrap(), filter, schema)
                || record_satisfies_filter(op.new.as_ref().unwrap(), filter, schema)
        } else {
            false
        }
    } else {
        true
    }
}

fn record_satisfies_filter(record: &Record, filter: &FilterExpression, schema: &Schema) -> bool {
    match filter {
        FilterExpression::And(filters) => filters
            .iter()
            .all(|filter| record_satisfies_filter(record, filter, schema)),
        FilterExpression::Simple(field_name, operator, value) => {
            let Some((field_index, field_definition)) = schema
                .fields
                .iter()
                .enumerate()
                .find(|(_, field)| field.name == *field_name)
             else {
                return false;
            };

            let Some(filed_value) = record.values.get(field_index) else {
                return false;
            };

            let Ok(value) = json_value_to_field(value.clone(), field_definition.typ, field_definition.nullable) else {
                return false;
            };

            field_satisfies_op(filed_value, *operator, &value)
        }
    }
}

fn field_satisfies_op(field: &Value, operator: Operator, value: &Field) -> bool {
    match operator {
        Operator::LT => match (field.value.as_ref().unwrap(), value) {
            (value::Value::UintValue(n), Field::UInt(m)) => n < m,
            (value::Value::IntValue(n), Field::Int(m)) => n < m,
            (value::Value::FloatValue(n), Field::Float(m)) => &OrderedFloat(*n as f64) < m,
            (value::Value::BoolValue(n), Field::Boolean(m)) => n < m,
            (value::Value::StringValue(n), Field::String(m)) => n < m,
            (value::Value::BytesValue(n), Field::Binary(m)) => n < m,
            (value::Value::DoubleValue(n), Field::Float(m)) => &OrderedFloat(*n) < m,
            _ => false,
        },
        Operator::LTE => match (field.value.as_ref().unwrap(), value) {
            (value::Value::UintValue(n), Field::UInt(m)) => n <= m,
            (value::Value::IntValue(n), Field::Int(m)) => n <= m,
            (value::Value::FloatValue(n), Field::Float(m)) => &OrderedFloat(*n as f64) <= m,
            (value::Value::BoolValue(n), Field::Boolean(m)) => n <= m,
            (value::Value::StringValue(n), Field::String(m)) => n <= m,
            (value::Value::BytesValue(n), Field::Binary(m)) => n <= m,
            (value::Value::DoubleValue(n), Field::Float(m)) => &OrderedFloat(*n) <= m,
            _ => false,
        },
        Operator::EQ => match (field.value.as_ref().unwrap(), value) {
            (value::Value::UintValue(n), Field::UInt(m)) => n == m,
            (value::Value::IntValue(n), Field::Int(m)) => n == m,
            (value::Value::FloatValue(n), Field::Float(m)) => &OrderedFloat(*n as f64) == m,
            (value::Value::BoolValue(n), Field::Boolean(m)) => n == m,
            (value::Value::StringValue(n), Field::String(m)) => n == m,
            (value::Value::BytesValue(n), Field::Binary(m)) => n == m,
            (value::Value::DoubleValue(n), Field::Float(m)) => &OrderedFloat(*n) == m,
            _ => false,
        },
        Operator::GT => match (field.value.as_ref().unwrap(), value) {
            (value::Value::UintValue(n), Field::UInt(m)) => n > m,
            (value::Value::IntValue(n), Field::Int(m)) => n > m,
            (value::Value::FloatValue(n), Field::Float(m)) => &OrderedFloat(*n as f64) > m,
            (value::Value::BoolValue(n), Field::Boolean(m)) => n > m,
            (value::Value::StringValue(n), Field::String(m)) => n > m,
            (value::Value::BytesValue(n), Field::Binary(m)) => n > m,
            (value::Value::DoubleValue(n), Field::Float(m)) => &OrderedFloat(*n) > m,
            _ => false,
        },
        Operator::GTE => match (field.value.as_ref().unwrap(), value) {
            (value::Value::UintValue(n), Field::UInt(m)) => n >= m,
            (value::Value::IntValue(n), Field::Int(m)) => n >= m,
            (value::Value::FloatValue(n), Field::Float(m)) => &OrderedFloat(*n as f64) >= m,
            (value::Value::BoolValue(n), Field::Boolean(m)) => n >= m,
            (value::Value::StringValue(n), Field::String(m)) => n >= m,
            (value::Value::BytesValue(n), Field::Binary(m)) => n >= m,
            (value::Value::DoubleValue(n), Field::Float(m)) => &OrderedFloat(*n) >= m,
            _ => false,
        },
        Operator::Contains => match (field.value.as_ref().unwrap(), value) {
            (value::Value::StringValue(n), Field::String(m)) => n.contains(m),
            _ => false,
        },
        Operator::MatchesAll | Operator::MatchesAny => unimplemented!(),
    }
}

#[cfg(test)]
mod tests;

1	use dozer_cache::cache::expression::{FilterExpression, Operator};
2	use dozer_types::{
3	json_value_to_field,
4	ordered_float::OrderedFloat,
5	types::{Field, Schema},
6	};
7
8	use crate::grpc::types::{value, Operation, OperationType, Record, Value};
9
10	pub fn op_satisfies_filter(
11	op: &Operation,
12	filter: Option<&FilterExpression>,
13	schema: &Schema,
14	) -> bool {
15	if let Some(filter) = filter {	9✔
16	if op.typ == OperationType::Insert as i32 \|\| op.typ == OperationType::Delete as i32 {	9✔
17	record_satisfies_filter(op.new.as_ref().unwrap(), filter, schema)	6✔
18	} else if op.typ == OperationType::Update as i32 {	3✔
19	record_satisfies_filter(op.old.as_ref().unwrap(), filter, schema)	3✔
20	\|\| record_satisfies_filter(op.new.as_ref().unwrap(), filter, schema)	2✔
21	} else {
22	false	×
23	}
24	} else {
25	true	×
26	}
27	}	9✔
28
29	fn record_satisfies_filter(record: &Record, filter: &FilterExpression, schema: &Schema) -> bool {	19✔
30	match filter {	19✔
31	FilterExpression::And(filters) => filters	2✔
32	.iter()	2✔
33	.all(\|filter\| record_satisfies_filter(record, filter, schema)),	4✔
34	FilterExpression::Simple(field_name, operator, value) => {	17✔
35	let Some((field_index, field_definition)) = schema	17✔
36	.fields	17✔
37	.iter()	17✔
38	.enumerate()	17✔
39	.find(\|(_, field)\| field.name == *field_name)	19✔
40	else {
41	return false;	×
42	};
43
44	let Some(filed_value) = record.values.get(field_index) else {	17✔
45	return false;	×
46	};
47
48	let Ok(value) = json_value_to_field(value.clone(), field_definition.typ, field_definition.nullable) else {	17✔
49	return false;	×
50	};
51
52	field_satisfies_op(filed_value, *operator, &value)	17✔
53	}
54	}
55	}	19✔
56
57	fn field_satisfies_op(field: &Value, operator: Operator, value: &Field) -> bool {	135✔
58	match operator {	135✔
59	Operator::LT => match (field.value.as_ref().unwrap(), value) {	23✔
60	(value::Value::UintValue(n), Field::UInt(m)) => n < m,	3✔
61	(value::Value::IntValue(n), Field::Int(m)) => n < m,	3✔
62	(value::Value::FloatValue(n), Field::Float(m)) => &OrderedFloat(*n as f64) < m,	3✔
63	(value::Value::BoolValue(n), Field::Boolean(m)) => n < m,	4✔
64	(value::Value::StringValue(n), Field::String(m)) => n < m,	3✔
65	(value::Value::BytesValue(n), Field::Binary(m)) => n < m,	3✔
66	(value::Value::DoubleValue(n), Field::Float(m)) => &OrderedFloat(*n) < m,	3✔
67	_ => false,	1✔
68	},
69	Operator::LTE => match (field.value.as_ref().unwrap(), value) {	23✔
70	(value::Value::UintValue(n), Field::UInt(m)) => n <= m,	3✔
71	(value::Value::IntValue(n), Field::Int(m)) => n <= m,	3✔
72	(value::Value::FloatValue(n), Field::Float(m)) => &OrderedFloat(*n as f64) <= m,	3✔
73	(value::Value::BoolValue(n), Field::Boolean(m)) => n <= m,	4✔
74	(value::Value::StringValue(n), Field::String(m)) => n <= m,	3✔
75	(value::Value::BytesValue(n), Field::Binary(m)) => n <= m,	3✔
76	(value::Value::DoubleValue(n), Field::Float(m)) => &OrderedFloat(*n) <= m,	3✔
77	_ => false,	1✔
78	},
79	Operator::EQ => match (field.value.as_ref().unwrap(), value) {	40✔
80	(value::Value::UintValue(n), Field::UInt(m)) => n == m,	5✔
81	(value::Value::IntValue(n), Field::Int(m)) => n == m,	16✔
82	(value::Value::FloatValue(n), Field::Float(m)) => &OrderedFloat(*n as f64) == m,	3✔
83	(value::Value::BoolValue(n), Field::Boolean(m)) => n == m,	4✔
84	(value::Value::StringValue(n), Field::String(m)) => n == m,	5✔
85	(value::Value::BytesValue(n), Field::Binary(m)) => n == m,	3✔
86	(value::Value::DoubleValue(n), Field::Float(m)) => &OrderedFloat(*n) == m,	3✔
87	_ => false,	1✔
88	},
89	Operator::GT => match (field.value.as_ref().unwrap(), value) {	23✔
90	(value::Value::UintValue(n), Field::UInt(m)) => n > m,	3✔
91	(value::Value::IntValue(n), Field::Int(m)) => n > m,	3✔
92	(value::Value::FloatValue(n), Field::Float(m)) => &OrderedFloat(*n as f64) > m,	3✔
93	(value::Value::BoolValue(n), Field::Boolean(m)) => n > m,	4✔
94	(value::Value::StringValue(n), Field::String(m)) => n > m,	3✔
95	(value::Value::BytesValue(n), Field::Binary(m)) => n > m,	3✔
96	(value::Value::DoubleValue(n), Field::Float(m)) => &OrderedFloat(*n) > m,	3✔
97	_ => false,	1✔
98	},
99	Operator::GTE => match (field.value.as_ref().unwrap(), value) {	23✔
100	(value::Value::UintValue(n), Field::UInt(m)) => n >= m,	3✔
101	(value::Value::IntValue(n), Field::Int(m)) => n >= m,	3✔
102	(value::Value::FloatValue(n), Field::Float(m)) => &OrderedFloat(*n as f64) >= m,	3✔
103	(value::Value::BoolValue(n), Field::Boolean(m)) => n >= m,	4✔
104	(value::Value::StringValue(n), Field::String(m)) => n >= m,	3✔
105	(value::Value::BytesValue(n), Field::Binary(m)) => n >= m,	3✔
106	(value::Value::DoubleValue(n), Field::Float(m)) => &OrderedFloat(*n) >= m,	3✔
107	_ => false,	1✔
108	},
109	Operator::Contains => match (field.value.as_ref().unwrap(), value) {	3✔
110	(value::Value::StringValue(n), Field::String(m)) => n.contains(m),	2✔
111	_ => false,	1✔
112	},
113	Operator::MatchesAll \| Operator::MatchesAny => unimplemented!(),	×
114	}
115	}	135✔
116
117	#[cfg(test)]
118	mod tests;

getdozer / dozer / 3975475267

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