4283045331

Build Type

push

github

Committed by GitHub

Commit Message

feat: Support timestamp diff (#1074)

Run Details

58 of 58 new or added lines in 2 files covered. (100.0%)

27146 of 37535 relevant lines covered (72.32%)

33460.71 hits per line

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

10.98

/dozer-sql/src/pipeline/expression/mathematical.rs

use crate::pipeline::errors::PipelineError;
use crate::pipeline::expression::execution::{Expression, ExpressionExecutor};
use dozer_types::types::Schema;
use dozer_types::{
    ordered_float::OrderedFloat,
    types::{Field, Record},
};
use num_traits::cast::*;

macro_rules! define_math_operator {
    ($id:ident, $op:expr, $fct:expr, $t: expr) => {
        pub fn $id(
            schema: &Schema,
            left: &Expression,
            right: &Expression,
            record: &Record,
        ) -> Result<Field, PipelineError> {
            let left_p = left.evaluate(&record, schema)?;
            let right_p = right.evaluate(&record, schema)?;

            match left_p {
                Field::Timestamp(left_v) => match right_p {
                    Field::Timestamp(right_v) => match $op {
                        "-" => {
                            let duration = left_v - right_v;
                            Ok(Field::Int(duration.num_milliseconds()))
                        }
                        _ => Err(PipelineError::InvalidOperandType($op.to_string())),
                    },
                    _ => Err(PipelineError::InvalidOperandType($op.to_string())),
                },
                Field::Float(left_v) => match right_p {
                    Field::Int(right_v) => Ok(Field::Float($fct(
                        left_v,
                        OrderedFloat::<f64>::from_i64(right_v).ok_or(
                            PipelineError::InvalidOperandType(format!(
                                "Unable to cast {} to float",
                                right_v
                            )),
                        )?,
                    ))),
                    Field::UInt(right_v) => Ok(Field::Float($fct(
                        left_v,
                        OrderedFloat::<f64>::from_u64(right_v).ok_or(
                            PipelineError::InvalidOperandType(format!(
                                "Unable to cast {} to float",
                                right_v
                            )),
                        )?,
                    ))),
                    Field::Float(right_v) => Ok(Field::Float($fct(left_v, right_v))),
                    _ => Err(PipelineError::InvalidOperandType($op.to_string())),
                },
                Field::Int(left_v) => match right_p {
                    Field::Int(right_v) => {
                        return match ($t) {
                            1 => Ok(Field::Float($fct(
                                OrderedFloat::<f64>::from_i64(left_v).ok_or(
                                    PipelineError::InvalidOperandType(format!(
                                        "Unable to cast {} to float",
                                        left_v
                                    )),
                                )?,
                                OrderedFloat::<f64>::from_i64(right_v).ok_or(
                                    PipelineError::InvalidOperandType(format!(
                                        "Unable to cast {} to float",
                                        right_v
                                    )),
                                )?,
                            ))),
                            _ => Ok(Field::Int($fct(left_v, right_v))),
                        };
                    }
                    Field::UInt(right_v) => {
                        return match ($t) {
                            1 => Ok(Field::Float($fct(
                                OrderedFloat::<f64>::from_i64(left_v).ok_or(
                                    PipelineError::InvalidOperandType(format!(
                                        "Unable to cast {} to float",
                                        left_v
                                    )),
                                )?,
                                OrderedFloat::<f64>::from_u64(right_v).ok_or(
                                    PipelineError::InvalidOperandType(format!(
                                        "Unable to cast {} to float",
                                        right_v
                                    )),
                                )?,
                            ))),
                            _ => Ok(Field::Int($fct(left_v, right_v as i64))),
                        };
                    }
                    Field::Float(right_v) => Ok(Field::Float($fct(
                        OrderedFloat::<f64>::from_i64(left_v).ok_or(
                            PipelineError::InvalidOperandType(format!(
                                "Unable to cast {} to float",
                                left_v
                            )),
                        )?,
                        right_v,
                    ))),
                    _ => Err(PipelineError::InvalidOperandType($op.to_string())),
                },
                Field::UInt(left_v) => match right_p {
                    Field::Int(right_v) => {
                        return match ($t) {
                            1 => Ok(Field::Float($fct(
                                OrderedFloat::<f64>::from_u64(left_v).ok_or(
                                    PipelineError::InvalidOperandType(format!(
                                        "Unable to cast {} to float",
                                        left_v
                                    )),
                                )?,
                                OrderedFloat::<f64>::from_i64(right_v).ok_or(
                                    PipelineError::InvalidOperandType(format!(
                                        "Unable to cast {} to float",
                                        right_v
                                    )),
                                )?,
                            ))),
                            _ => Ok(Field::Int($fct(left_v as i64, right_v))),
                        };
                    }
                    Field::UInt(right_v) => {
                        return match ($t) {
                            1 => Ok(Field::Float($fct(
                                OrderedFloat::<f64>::from_u64(left_v).ok_or(
                                    PipelineError::InvalidOperandType(format!(
                                        "Unable to cast {} to float",
                                        left_v
                                    )),
                                )?,
                                OrderedFloat::<f64>::from_u64(right_v).ok_or(
                                    PipelineError::InvalidOperandType(format!(
                                        "Unable to cast {} to float",
                                        right_v
                                    )),
                                )?,
                            ))),
                            _ => Ok(Field::UInt($fct(left_v, right_v))),
                        };
                    }
                    Field::Float(right_v) => Ok(Field::Float($fct(
                        OrderedFloat::<f64>::from_u64(left_v).ok_or(
                            PipelineError::InvalidOperandType(format!(
                                "Unable to cast {} to float",
                                left_v
                            )),
                        )?,
                        right_v,
                    ))),
                    _ => Err(PipelineError::InvalidOperandType($op.to_string())),
                },
                _ => Err(PipelineError::InvalidOperandType($op.to_string())),
            }
        }
    };
}

define_math_operator!(evaluate_add, "+", |a, b| { a + b }, 0);
define_math_operator!(evaluate_sub, "-", |a, b| { a - b }, 0);
define_math_operator!(evaluate_mul, "*", |a, b| { a * b }, 0);
define_math_operator!(evaluate_div, "/", |a, b| { a / b }, 1);
define_math_operator!(evaluate_mod, "%", |a, b| { a % b }, 0);

pub fn evaluate_plus(
    schema: &Schema,
    expression: &Expression,
    record: &Record,
) -> Result<Field, PipelineError> {
    let expression_result = expression.evaluate(record, schema)?;
    match expression_result {
        Field::Int(v) => Ok(Field::Int(v)),
        Field::Float(v) => Ok(Field::Float(v)),
        _ => Err(PipelineError::InvalidOperandType("+".to_string())),
    }
}

pub fn evaluate_minus(
    schema: &Schema,
    expression: &Expression,
    record: &Record,
) -> Result<Field, PipelineError> {
    let expression_result = expression.evaluate(record, schema)?;
    match expression_result {
        Field::Int(v) => Ok(Field::Int(-v)),
        Field::Float(v) => Ok(Field::Float(-v)),
        _ => Err(PipelineError::InvalidOperandType("-".to_string())),
    }
}

1	use crate::pipeline::errors::PipelineError;
2	use crate::pipeline::expression::execution::{Expression, ExpressionExecutor};
3	use dozer_types::types::Schema;
4	use dozer_types::{
5	ordered_float::OrderedFloat,
6	types::{Field, Record},
7	};
8	use num_traits::cast::*;
9
10	macro_rules! define_math_operator {
11	($id:ident, $op:expr, $fct:expr, $t: expr) => {
12	pub fn $id(	4✔
13	schema: &Schema,	4✔
14	left: &Expression,	4✔
15	right: &Expression,	4✔
16	record: &Record,	4✔
17	) -> Result<Field, PipelineError> {	4✔
18	let left_p = left.evaluate(&record, schema)?;	4✔
19	let right_p = right.evaluate(&record, schema)?;	4✔
20
21	match left_p {	4✔
22	Field::Timestamp(left_v) => match right_p {	2✔
23	Field::Timestamp(right_v) => match $op {	2✔
24	"-" => {	2✔
25	let duration = left_v - right_v;	2✔
26	Ok(Field::Int(duration.num_milliseconds()))	2✔
27	}	×
28	_ => Err(PipelineError::InvalidOperandType($op.to_string())),	×
29	},	×
30	_ => Err(PipelineError::InvalidOperandType($op.to_string())),	×
31	},
32	Field::Float(left_v) => match right_p {	×
33	Field::Int(right_v) => Ok(Field::Float($fct(	×
34	left_v,	×
35	OrderedFloat::<f64>::from_i64(right_v).ok_or(	×
36	PipelineError::InvalidOperandType(format!(	×
37	"Unable to cast {} to float",	×
38	right_v	×
39	)),	×
40	)?,	×
41	))),	×
42	Field::UInt(right_v) => Ok(Field::Float($fct(	×
43	left_v,	×
44	OrderedFloat::<f64>::from_u64(right_v).ok_or(	×
45	PipelineError::InvalidOperandType(format!(	×
46	"Unable to cast {} to float",	×
47	right_v	×
48	)),	×
49	)?,	×
50	))),	×
51	Field::Float(right_v) => Ok(Field::Float($fct(left_v, right_v))),	×
52	_ => Err(PipelineError::InvalidOperandType($op.to_string())),	×
53	},	×
54	Field::Int(left_v) => match right_p {	2✔
55	Field::Int(right_v) => {	2✔
56	return match ($t) {	×
57	1 => Ok(Field::Float($fct(	×
58	OrderedFloat::<f64>::from_i64(left_v).ok_or(	×
59	PipelineError::InvalidOperandType(format!(	×
60	"Unable to cast {} to float",	×
61	left_v	×
62	)),	×
63	)?,	×
64	OrderedFloat::<f64>::from_i64(right_v).ok_or(	×
65	PipelineError::InvalidOperandType(format!(	×
66	"Unable to cast {} to float",	×
67	right_v	×
68	)),	×
69	)?,	×
70	))),	×
71	_ => Ok(Field::Int($fct(left_v, right_v))),	2✔
72	};	×
73	}	×
74	Field::UInt(right_v) => {	×
75	return match ($t) {	×
76	1 => Ok(Field::Float($fct(	×
77	OrderedFloat::<f64>::from_i64(left_v).ok_or(	×
78	PipelineError::InvalidOperandType(format!(	×
79	"Unable to cast {} to float",	×
80	left_v	×
81	)),	×
82	)?,	×
83	OrderedFloat::<f64>::from_u64(right_v).ok_or(	×
84	PipelineError::InvalidOperandType(format!(	×
85	"Unable to cast {} to float",	×
86	right_v	×
87	)),	×
88	)?,	×
89	))),	×
90	_ => Ok(Field::Int($fct(left_v, right_v as i64))),	×
91	};
92	}	×
93	Field::Float(right_v) => Ok(Field::Float($fct(	×
94	OrderedFloat::<f64>::from_i64(left_v).ok_or(	×
95	PipelineError::InvalidOperandType(format!(	×
96	"Unable to cast {} to float",	×
97	left_v	×
98	)),	×
99	)?,	×
100	right_v,	×
101	))),	×
102	_ => Err(PipelineError::InvalidOperandType($op.to_string())),	×
103	},	×
104	Field::UInt(left_v) => match right_p {	×
105	Field::Int(right_v) => {	×
106	return match ($t) {	×
107	1 => Ok(Field::Float($fct(	×
108	OrderedFloat::<f64>::from_u64(left_v).ok_or(	×
109	PipelineError::InvalidOperandType(format!(	×
110	"Unable to cast {} to float",	×
111	left_v	×
112	)),	×
113	)?,	×
114	OrderedFloat::<f64>::from_i64(right_v).ok_or(	×
115	PipelineError::InvalidOperandType(format!(	×
116	"Unable to cast {} to float",	×
117	right_v	×
118	)),	×
119	)?,	×
120	))),	×
121	_ => Ok(Field::Int($fct(left_v as i64, right_v))),	×
122	};	×
123	}	×
124	Field::UInt(right_v) => {	×
125	return match ($t) {	×
126	1 => Ok(Field::Float($fct(	×
127	OrderedFloat::<f64>::from_u64(left_v).ok_or(	×
128	PipelineError::InvalidOperandType(format!(	×
129	"Unable to cast {} to float",	×
130	left_v	×
131	)),	×
132	)?,	×
133	OrderedFloat::<f64>::from_u64(right_v).ok_or(	×
134	PipelineError::InvalidOperandType(format!(	×
135	"Unable to cast {} to float",	×
136	right_v	×
137	)),	×
138	)?,	×
139	))),	×
140	_ => Ok(Field::UInt($fct(left_v, right_v))),	×
141	};
142	}	×
143	Field::Float(right_v) => Ok(Field::Float($fct(	×
144	OrderedFloat::<f64>::from_u64(left_v).ok_or(	×
145	PipelineError::InvalidOperandType(format!(	×
146	"Unable to cast {} to float",	×
147	left_v	×
148	)),	×
149	)?,	×
150	right_v,	×
151	))),	×
152	_ => Err(PipelineError::InvalidOperandType($op.to_string())),	×
153	},	×
154	_ => Err(PipelineError::InvalidOperandType($op.to_string())),	×
155	}
156	}	4✔
157	};	×
158	}	×
159		×
160	define_math_operator!(evaluate_add, "+", \|a, b\| { a + b }, 0);	2✔
161	define_math_operator!(evaluate_sub, "-", \|a, b\| { a - b }, 0);	×
162	define_math_operator!(evaluate_mul, "", \|a, b\| { a b }, 0);	×
163	define_math_operator!(evaluate_div, "/", \|a, b\| { a / b }, 1);	×
164	define_math_operator!(evaluate_mod, "%", \|a, b\| { a % b }, 0);	×
165		×
166	pub fn evaluate_plus(	×
167	schema: &Schema,	×
168	expression: &Expression,	×
169	record: &Record,	×
170	) -> Result<Field, PipelineError> {	×
171	let expression_result = expression.evaluate(record, schema)?;	×
172	match expression_result {	×
173	Field::Int(v) => Ok(Field::Int(v)),	×
174	Field::Float(v) => Ok(Field::Float(v)),	×
175	_ => Err(PipelineError::InvalidOperandType("+".to_string())),	×
176	}	×
177	}	×
178		×
179	pub fn evaluate_minus(	×
180	schema: &Schema,	×
181	expression: &Expression,	×
182	record: &Record,	×
183	) -> Result<Field, PipelineError> {	×
184	let expression_result = expression.evaluate(record, schema)?;	×
185	match expression_result {	×
186	Field::Int(v) => Ok(Field::Int(-v)),	×
187	Field::Float(v) => Ok(Field::Float(-v)),	×
188	_ => Err(PipelineError::InvalidOperandType("-".to_string())),	×
189	}
190	}	×

getdozer / dozer / 4283045331

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