5611876656

pending completion

Build # 5611876656

Build Type

Pull #1776

github

Committed by

chubei

Commit Message

chore: Remove `Schema::identifier`

Pull Request Pull Request #1776: chore: Remove `Schema::identifier`

Run Details

1470 of 1470 new or added lines in 98 files covered. (100.0%)

43423 of 57848 relevant lines covered (75.06%)

33086.85 hits per line

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

93.83

/dozer-sql/src/pipeline/expression/tests/expression_builder_test.rs

use crate::pipeline::expression::builder::ExpressionBuilder;
use crate::pipeline::expression::execution::Expression;
use crate::pipeline::expression::operator::BinaryOperatorType;
use crate::pipeline::expression::scalar::common::ScalarFunctionType;
use crate::pipeline::tests::utils::get_select;

use crate::pipeline::expression::aggregate::AggregateFunctionType;
use dozer_types::types::{Field, FieldDefinition, FieldType, Schema, SourceDefinition};
use sqlparser::ast::SelectItem;

#[test]
fn test_simple_function() {
    let sql = "SELECT CONCAT(a, b) FROM t0";
    let schema = Schema::default()
        .field(
            FieldDefinition::new(
                "a".to_string(),
                FieldType::String,
                false,
                SourceDefinition::Dynamic,
            ),
            false,
        )
        .field(
            FieldDefinition::new(
                "b".to_string(),
                FieldType::String,
                false,
                SourceDefinition::Dynamic,
            ),
            false,
        )
        .to_owned();

    let mut builder = ExpressionBuilder::new(schema.fields.len());
    let e = match &get_select(sql).unwrap().projection[0] {
        SelectItem::UnnamedExpr(e) => builder.build(true, e, &schema).unwrap(),
        _ => panic!("Invalid expr"),
    };

    assert_eq!(
        builder,
        ExpressionBuilder {
            offset: schema.fields.len(),
            aggregations: vec![]
        }
    );
    assert_eq!(
        e,
        Expression::ScalarFunction {
            fun: ScalarFunctionType::Concat,
            args: vec![
                Expression::Column { index: 0 },
                Expression::Column { index: 1 }
            ]
        }
    );
}

#[test]
fn test_simple_aggr_function() {
    let sql = "SELECT SUM(field0) FROM t0";
    let schema = Schema::default()
        .field(
            FieldDefinition::new(
                "field0".to_string(),
                FieldType::Int,
                false,
                SourceDefinition::Dynamic,
            ),
            false,
        )
        .to_owned();

    let mut builder = ExpressionBuilder::new(schema.fields.len());
    let e = match &get_select(sql).unwrap().projection[0] {
        SelectItem::UnnamedExpr(e) => builder.build(true, e, &schema).unwrap(),
        _ => panic!("Invalid expr"),
    };

    assert_eq!(
        builder,
        ExpressionBuilder {
            offset: schema.fields.len(),
            aggregations: vec![Expression::AggregateFunction {
                fun: AggregateFunctionType::Sum,
                args: vec![Expression::Column { index: 0 }]
            }]
        }
    );
    assert_eq!(e, Expression::Column { index: 1 });
}

#[test]
fn test_2_nested_aggr_function() {
    let sql = "SELECT SUM(ROUND(field1, 2)) FROM t0";
    let schema = Schema::default()
        .field(
            FieldDefinition::new(
                "field0".to_string(),
                FieldType::Float,
                false,
                SourceDefinition::Dynamic,
            ),
            false,
        )
        .field(
            FieldDefinition::new(
                "field1".to_string(),
                FieldType::Float,
                false,
                SourceDefinition::Dynamic,
            ),
            false,
        )
        .to_owned();

    let mut builder = ExpressionBuilder::new(schema.fields.len());
    let e = match &get_select(sql).unwrap().projection[0] {
        SelectItem::UnnamedExpr(e) => builder.build(true, e, &schema).unwrap(),
        _ => panic!("Invalid expr"),
    };

    assert_eq!(
        builder,
        ExpressionBuilder {
            offset: schema.fields.len(),
            aggregations: vec![Expression::AggregateFunction {
                fun: AggregateFunctionType::Sum,
                args: vec![Expression::ScalarFunction {
                    fun: ScalarFunctionType::Round,
                    args: vec![
                        Expression::Column { index: 1 },
                        Expression::Literal(Field::Int(2))
                    ]
                }]
            }]
        }
    );
    assert_eq!(e, Expression::Column { index: 2 });
}

#[test]
fn test_3_nested_aggr_function() {
    let sql = "SELECT ROUND(SUM(ROUND(field1, 2))) FROM t0";
    let schema = Schema::default()
        .field(
            FieldDefinition::new(
                "field0".to_string(),
                FieldType::Float,
                false,
                SourceDefinition::Dynamic,
            ),
            false,
        )
        .field(
            FieldDefinition::new(
                "field1".to_string(),
                FieldType::Float,
                false,
                SourceDefinition::Dynamic,
            ),
            false,
        )
        .to_owned();

    let mut builder = ExpressionBuilder::new(schema.fields.len());
    let e = match &get_select(sql).unwrap().projection[0] {
        SelectItem::UnnamedExpr(e) => builder.build(true, e, &schema).unwrap(),
        _ => panic!("Invalid expr"),
    };

    assert_eq!(
        builder,
        ExpressionBuilder {
            offset: schema.fields.len(),
            aggregations: vec![Expression::AggregateFunction {
                fun: AggregateFunctionType::Sum,
                args: vec![Expression::ScalarFunction {
                    fun: ScalarFunctionType::Round,
                    args: vec![
                        Expression::Column { index: 1 },
                        Expression::Literal(Field::Int(2))
                    ]
                }]
            }]
        }
    );
    assert_eq!(
        e,
        Expression::ScalarFunction {
            fun: ScalarFunctionType::Round,
            args: vec![Expression::Column { index: 2 }]
        }
    );
}

#[test]
fn test_3_nested_aggr_function_dup() {
    let sql = "SELECT CONCAT(SUM(ROUND(field1, 2)), SUM(ROUND(field1, 2))) FROM t0";
    let schema = Schema::default()
        .field(
            FieldDefinition::new(
                "field0".to_string(),
                FieldType::Float,
                false,
                SourceDefinition::Dynamic,
            ),
            false,
        )
        .field(
            FieldDefinition::new(
                "field1".to_string(),
                FieldType::Float,
                false,
                SourceDefinition::Dynamic,
            ),
            false,
        )
        .to_owned();

    let mut builder = ExpressionBuilder::new(schema.fields.len());
    let e = match &get_select(sql).unwrap().projection[0] {
        SelectItem::UnnamedExpr(e) => builder.build(true, e, &schema).unwrap(),
        _ => panic!("Invalid expr"),
    };

    assert_eq!(
        builder,
        ExpressionBuilder {
            offset: schema.fields.len(),
            aggregations: vec![Expression::AggregateFunction {
                fun: AggregateFunctionType::Sum,
                args: vec![Expression::ScalarFunction {
                    fun: ScalarFunctionType::Round,
                    args: vec![
                        Expression::Column { index: 1 },
                        Expression::Literal(Field::Int(2))
                    ]
                }]
            }]
        }
    );
    assert_eq!(
        e,
        Expression::ScalarFunction {
            fun: ScalarFunctionType::Concat,
            args: vec![
                Expression::Column { index: 2 },
                Expression::Column { index: 2 }
            ]
        }
    );
}

#[test]
fn test_3_nested_aggr_function_and_sum() {
    let sql = "SELECT ROUND(SUM(ROUND(field1, 2))) + SUM(field0) FROM t0";
    let schema = Schema::default()
        .field(
            FieldDefinition::new(
                "field0".to_string(),
                FieldType::Float,
                false,
                SourceDefinition::Dynamic,
            ),
            false,
        )
        .field(
            FieldDefinition::new(
                "field1".to_string(),
                FieldType::Float,
                false,
                SourceDefinition::Dynamic,
            ),
            false,
        )
        .to_owned();

    let mut builder = ExpressionBuilder::new(schema.fields.len());
    let e = match &get_select(sql).unwrap().projection[0] {
        SelectItem::UnnamedExpr(e) => builder.build(true, e, &schema).unwrap(),
        _ => panic!("Invalid expr"),
    };

    assert_eq!(
        builder,
        ExpressionBuilder {
            offset: schema.fields.len(),
            aggregations: vec![
                Expression::AggregateFunction {
                    fun: AggregateFunctionType::Sum,
                    args: vec![Expression::ScalarFunction {
                        fun: ScalarFunctionType::Round,
                        args: vec![
                            Expression::Column { index: 1 },
                            Expression::Literal(Field::Int(2))
                        ]
                    }]
                },
                Expression::AggregateFunction {
                    fun: AggregateFunctionType::Sum,
                    args: vec![Expression::Column { index: 0 }]
                }
            ]
        }
    );
    assert_eq!(
        e,
        Expression::BinaryOperator {
            operator: BinaryOperatorType::Add,
            left: Box::new(Expression::ScalarFunction {
                fun: ScalarFunctionType::Round,
                args: vec![Expression::Column { index: 2 }]
            }),
            right: Box::new(Expression::Column { index: 3 })
        }
    );
}

#[test]
fn test_3_nested_aggr_function_and_sum_3() {
    let sql = "SELECT (ROUND(SUM(ROUND(field1, 2))) + SUM(field0)) + field0 FROM t0";
    let schema = Schema::default()
        .field(
            FieldDefinition::new(
                "field0".to_string(),
                FieldType::Float,
                false,
                SourceDefinition::Dynamic,
            ),
            false,
        )
        .field(
            FieldDefinition::new(
                "field1".to_string(),
                FieldType::Float,
                false,
                SourceDefinition::Dynamic,
            ),
            false,
        )
        .to_owned();

    let mut builder = ExpressionBuilder::new(schema.fields.len());
    let e = match &get_select(sql).unwrap().projection[0] {
        SelectItem::UnnamedExpr(e) => builder.build(true, e, &schema).unwrap(),
        _ => panic!("Invalid expr"),
    };

    assert_eq!(
        builder,
        ExpressionBuilder {
            offset: schema.fields.len(),
            aggregations: vec![
                Expression::AggregateFunction {
                    fun: AggregateFunctionType::Sum,
                    args: vec![Expression::ScalarFunction {
                        fun: ScalarFunctionType::Round,
                        args: vec![
                            Expression::Column { index: 1 },
                            Expression::Literal(Field::Int(2))
                        ]
                    }]
                },
                Expression::AggregateFunction {
                    fun: AggregateFunctionType::Sum,
                    args: vec![Expression::Column { index: 0 }]
                }
            ]
        }
    );
    assert_eq!(
        e,
        Expression::BinaryOperator {
            operator: BinaryOperatorType::Add,
            left: Box::new(Expression::BinaryOperator {
                operator: BinaryOperatorType::Add,
                left: Box::new(Expression::ScalarFunction {
                    fun: ScalarFunctionType::Round,
                    args: vec![Expression::Column { index: 2 }]
                }),
                right: Box::new(Expression::Column { index: 3 })
            }),
            right: Box::new(Expression::Column { index: 0 })
        }
    );
}

#[test]
#[ignore]
#[should_panic]
fn test_wrong_nested_aggregations() {
    let sql = "SELECT SUM(SUM(field0)) FROM t0";
    let schema = Schema::default()
        .field(
            FieldDefinition::new(
                "field0".to_string(),
                FieldType::Float,
                false,
                SourceDefinition::Dynamic,
            ),
            false,
        )
        .to_owned();

    let mut builder = ExpressionBuilder::new(schema.fields.len());
    let _e = match &get_select(sql).unwrap().projection[0] {
        SelectItem::UnnamedExpr(e) => builder.build(true, e, &schema).unwrap(),
        _ => panic!("Invalid expr"),
    };
}

#[test]
fn test_name_resolution() {
    let sql = "SELECT CONCAT(table0.a, connection1.table0.b, a) FROM t0";
    let schema = Schema::default()
        .field(
            FieldDefinition::new(
                "a".to_string(),
                FieldType::String,
                false,
                SourceDefinition::Table {
                    connection: "connection1".to_string(),
                    name: "table0".to_string(),
                },
            ),
            false,
        )
        .field(
            FieldDefinition::new(
                "b".to_string(),
                FieldType::String,
                false,
                SourceDefinition::Table {
                    connection: "connection1".to_string(),
                    name: "table0".to_string(),
                },
            ),
            false,
        )
        .to_owned();

    let mut builder = ExpressionBuilder::new(schema.fields.len());
    let e = match &get_select(sql).unwrap().projection[0] {
        SelectItem::UnnamedExpr(e) => builder.build(true, e, &schema).unwrap(),
        _ => panic!("Invalid expr"),
    };

    assert_eq!(
        builder,
        ExpressionBuilder {
            offset: schema.fields.len(),
            aggregations: vec![]
        }
    );
    assert_eq!(
        e,
        Expression::ScalarFunction {
            fun: ScalarFunctionType::Concat,
            args: vec![
                Expression::Column { index: 0 },
                Expression::Column { index: 1 },
                Expression::Column { index: 0 }
            ]
        }
    );
}

#[test]
fn test_alias_resolution() {
    let sql = "SELECT CONCAT(alias.a, a) FROM t0";
    let schema = Schema::default()
        .field(
            FieldDefinition::new(
                "a".to_string(),
                FieldType::String,
                false,
                SourceDefinition::Alias {
                    name: "alias".to_string(),
                },
            ),
            false,
        )
        .to_owned();

    let mut builder = ExpressionBuilder::new(schema.fields.len());
    let e = match &get_select(sql).unwrap().projection[0] {
        SelectItem::UnnamedExpr(e) => builder.build(true, e, &schema).unwrap(),
        _ => panic!("Invalid expr"),
    };

    assert_eq!(
        builder,
        ExpressionBuilder {
            offset: schema.fields.len(),
            aggregations: vec![]
        }
    );
    assert_eq!(
        e,
        Expression::ScalarFunction {
            fun: ScalarFunctionType::Concat,
            args: vec![
                Expression::Column { index: 0 },
                Expression::Column { index: 0 }
            ]
        }
    );
}

1	use crate::pipeline::expression::builder::ExpressionBuilder;
2	use crate::pipeline::expression::execution::Expression;
3	use crate::pipeline::expression::operator::BinaryOperatorType;
4	use crate::pipeline::expression::scalar::common::ScalarFunctionType;
5	use crate::pipeline::tests::utils::get_select;
6
7	use crate::pipeline::expression::aggregate::AggregateFunctionType;
8	use dozer_types::types::{Field, FieldDefinition, FieldType, Schema, SourceDefinition};
9	use sqlparser::ast::SelectItem;
10
11	#[test]	1✔
12	fn test_simple_function() {	1✔
13	let sql = "SELECT CONCAT(a, b) FROM t0";	1✔
14	let schema = Schema::default()	1✔
15	.field(	1✔
16	FieldDefinition::new(	1✔
17	"a".to_string(),	1✔
18	FieldType::String,	1✔
19	false,	1✔
20	SourceDefinition::Dynamic,	1✔
21	),	1✔
22	false,	1✔
23	)	1✔
24	.field(	1✔
25	FieldDefinition::new(	1✔
26	"b".to_string(),	1✔
27	FieldType::String,	1✔
28	false,	1✔
29	SourceDefinition::Dynamic,	1✔
30	),	1✔
31	false,	1✔
32	)	1✔
33	.to_owned();	1✔
34		1✔
35	let mut builder = ExpressionBuilder::new(schema.fields.len());	1✔
36	let e = match &get_select(sql).unwrap().projection[0] {	1✔
37	SelectItem::UnnamedExpr(e) => builder.build(true, e, &schema).unwrap(),	1✔
38	_ => panic!("Invalid expr"),	×
39	};
40
41	assert_eq!(	1✔
42	builder,	1✔
43	ExpressionBuilder {	1✔
44	offset: schema.fields.len(),	1✔
45	aggregations: vec![]	1✔
46	}	1✔
47	);	1✔
48	assert_eq!(	1✔
49	e,	1✔
50	Expression::ScalarFunction {	1✔
51	fun: ScalarFunctionType::Concat,	1✔
52	args: vec![	1✔
53	Expression::Column { index: 0 },	1✔
54	Expression::Column { index: 1 }	1✔
55	]	1✔
56	}	1✔
57	);	1✔
58	}	1✔
59
60	#[test]	1✔
61	fn test_simple_aggr_function() {	1✔
62	let sql = "SELECT SUM(field0) FROM t0";	1✔
63	let schema = Schema::default()	1✔
64	.field(	1✔
65	FieldDefinition::new(	1✔
66	"field0".to_string(),	1✔
67	FieldType::Int,	1✔
68	false,	1✔
69	SourceDefinition::Dynamic,	1✔
70	),	1✔
71	false,	1✔
72	)	1✔
73	.to_owned();	1✔
74		1✔
75	let mut builder = ExpressionBuilder::new(schema.fields.len());	1✔
76	let e = match &get_select(sql).unwrap().projection[0] {	1✔
77	SelectItem::UnnamedExpr(e) => builder.build(true, e, &schema).unwrap(),	1✔
78	_ => panic!("Invalid expr"),	×
79	};
80
81	assert_eq!(	1✔
82	builder,	1✔
83	ExpressionBuilder {	1✔
84	offset: schema.fields.len(),	1✔
85	aggregations: vec![Expression::AggregateFunction {	1✔
86	fun: AggregateFunctionType::Sum,	1✔
87	args: vec![Expression::Column { index: 0 }]	1✔
88	}]	1✔
89	}	1✔
90	);	1✔
91	assert_eq!(e, Expression::Column { index: 1 });	1✔
92	}	1✔
93
94	#[test]	1✔
95	fn test_2_nested_aggr_function() {	1✔
96	let sql = "SELECT SUM(ROUND(field1, 2)) FROM t0";	1✔
97	let schema = Schema::default()	1✔
98	.field(	1✔
99	FieldDefinition::new(	1✔
100	"field0".to_string(),	1✔
101	FieldType::Float,	1✔
102	false,	1✔
103	SourceDefinition::Dynamic,	1✔
104	),	1✔
105	false,	1✔
106	)	1✔
107	.field(	1✔
108	FieldDefinition::new(	1✔
109	"field1".to_string(),	1✔
110	FieldType::Float,	1✔
111	false,	1✔
112	SourceDefinition::Dynamic,	1✔
113	),	1✔
114	false,	1✔
115	)	1✔
116	.to_owned();	1✔
117		1✔
118	let mut builder = ExpressionBuilder::new(schema.fields.len());	1✔
119	let e = match &get_select(sql).unwrap().projection[0] {	1✔
120	SelectItem::UnnamedExpr(e) => builder.build(true, e, &schema).unwrap(),	1✔
121	_ => panic!("Invalid expr"),	×
122	};
123
124	assert_eq!(	1✔
125	builder,	1✔
126	ExpressionBuilder {	1✔
127	offset: schema.fields.len(),	1✔
128	aggregations: vec![Expression::AggregateFunction {	1✔
129	fun: AggregateFunctionType::Sum,	1✔
130	args: vec![Expression::ScalarFunction {	1✔
131	fun: ScalarFunctionType::Round,	1✔
132	args: vec![	1✔
133	Expression::Column { index: 1 },	1✔
134	Expression::Literal(Field::Int(2))	1✔
135	]	1✔
136	}]	1✔
137	}]	1✔
138	}	1✔
139	);	1✔
140	assert_eq!(e, Expression::Column { index: 2 });	1✔
141	}	1✔
142
143	#[test]	1✔
144	fn test_3_nested_aggr_function() {	1✔
145	let sql = "SELECT ROUND(SUM(ROUND(field1, 2))) FROM t0";	1✔
146	let schema = Schema::default()	1✔
147	.field(	1✔
148	FieldDefinition::new(	1✔
149	"field0".to_string(),	1✔
150	FieldType::Float,	1✔
151	false,	1✔
152	SourceDefinition::Dynamic,	1✔
153	),	1✔
154	false,	1✔
155	)	1✔
156	.field(	1✔
157	FieldDefinition::new(	1✔
158	"field1".to_string(),	1✔
159	FieldType::Float,	1✔
160	false,	1✔
161	SourceDefinition::Dynamic,	1✔
162	),	1✔
163	false,	1✔
164	)	1✔
165	.to_owned();	1✔
166		1✔
167	let mut builder = ExpressionBuilder::new(schema.fields.len());	1✔
168	let e = match &get_select(sql).unwrap().projection[0] {	1✔
169	SelectItem::UnnamedExpr(e) => builder.build(true, e, &schema).unwrap(),	1✔
170	_ => panic!("Invalid expr"),	×
171	};
172
173	assert_eq!(	1✔
174	builder,	1✔
175	ExpressionBuilder {	1✔
176	offset: schema.fields.len(),	1✔
177	aggregations: vec![Expression::AggregateFunction {	1✔
178	fun: AggregateFunctionType::Sum,	1✔
179	args: vec![Expression::ScalarFunction {	1✔
180	fun: ScalarFunctionType::Round,	1✔
181	args: vec![	1✔
182	Expression::Column { index: 1 },	1✔
183	Expression::Literal(Field::Int(2))	1✔
184	]	1✔
185	}]	1✔
186	}]	1✔
187	}	1✔
188	);	1✔
189	assert_eq!(	1✔
190	e,	1✔
191	Expression::ScalarFunction {	1✔
192	fun: ScalarFunctionType::Round,	1✔
193	args: vec![Expression::Column { index: 2 }]	1✔
194	}	1✔
195	);	1✔
196	}	1✔
197
198	#[test]	1✔
199	fn test_3_nested_aggr_function_dup() {	1✔
200	let sql = "SELECT CONCAT(SUM(ROUND(field1, 2)), SUM(ROUND(field1, 2))) FROM t0";	1✔
201	let schema = Schema::default()	1✔
202	.field(	1✔
203	FieldDefinition::new(	1✔
204	"field0".to_string(),	1✔
205	FieldType::Float,	1✔
206	false,	1✔
207	SourceDefinition::Dynamic,	1✔
208	),	1✔
209	false,	1✔
210	)	1✔
211	.field(	1✔
212	FieldDefinition::new(	1✔
213	"field1".to_string(),	1✔
214	FieldType::Float,	1✔
215	false,	1✔
216	SourceDefinition::Dynamic,	1✔
217	),	1✔
218	false,	1✔
219	)	1✔
220	.to_owned();	1✔
221		1✔
222	let mut builder = ExpressionBuilder::new(schema.fields.len());	1✔
223	let e = match &get_select(sql).unwrap().projection[0] {	1✔
224	SelectItem::UnnamedExpr(e) => builder.build(true, e, &schema).unwrap(),	1✔
225	_ => panic!("Invalid expr"),	×
226	};
227
228	assert_eq!(	1✔
229	builder,	1✔
230	ExpressionBuilder {	1✔
231	offset: schema.fields.len(),	1✔
232	aggregations: vec![Expression::AggregateFunction {	1✔
233	fun: AggregateFunctionType::Sum,	1✔
234	args: vec![Expression::ScalarFunction {	1✔
235	fun: ScalarFunctionType::Round,	1✔
236	args: vec![	1✔
237	Expression::Column { index: 1 },	1✔
238	Expression::Literal(Field::Int(2))	1✔
239	]	1✔
240	}]	1✔
241	}]	1✔
242	}	1✔
243	);	1✔
244	assert_eq!(	1✔
245	e,	1✔
246	Expression::ScalarFunction {	1✔
247	fun: ScalarFunctionType::Concat,	1✔
248	args: vec![	1✔
249	Expression::Column { index: 2 },	1✔
250	Expression::Column { index: 2 }	1✔
251	]	1✔
252	}	1✔
253	);	1✔
254	}	1✔
255
256	#[test]	1✔
257	fn test_3_nested_aggr_function_and_sum() {	1✔
258	let sql = "SELECT ROUND(SUM(ROUND(field1, 2))) + SUM(field0) FROM t0";	1✔
259	let schema = Schema::default()	1✔
260	.field(	1✔
261	FieldDefinition::new(	1✔
262	"field0".to_string(),	1✔
263	FieldType::Float,	1✔
264	false,	1✔
265	SourceDefinition::Dynamic,	1✔
266	),	1✔
267	false,	1✔
268	)	1✔
269	.field(	1✔
270	FieldDefinition::new(	1✔
271	"field1".to_string(),	1✔
272	FieldType::Float,	1✔
273	false,	1✔
274	SourceDefinition::Dynamic,	1✔
275	),	1✔
276	false,	1✔
277	)	1✔
278	.to_owned();	1✔
279		1✔
280	let mut builder = ExpressionBuilder::new(schema.fields.len());	1✔
281	let e = match &get_select(sql).unwrap().projection[0] {	1✔
282	SelectItem::UnnamedExpr(e) => builder.build(true, e, &schema).unwrap(),	1✔
283	_ => panic!("Invalid expr"),	×
284	};
285
286	assert_eq!(	1✔
287	builder,	1✔
288	ExpressionBuilder {	1✔
289	offset: schema.fields.len(),	1✔
290	aggregations: vec![	1✔
291	Expression::AggregateFunction {	1✔
292	fun: AggregateFunctionType::Sum,	1✔
293	args: vec![Expression::ScalarFunction {	1✔
294	fun: ScalarFunctionType::Round,	1✔
295	args: vec![	1✔
296	Expression::Column { index: 1 },	1✔
297	Expression::Literal(Field::Int(2))	1✔
298	]	1✔
299	}]	1✔
300	},	1✔
301	Expression::AggregateFunction {	1✔
302	fun: AggregateFunctionType::Sum,	1✔
303	args: vec![Expression::Column { index: 0 }]	1✔
304	}	1✔
305	]	1✔
306	}	1✔
307	);	1✔
308	assert_eq!(	1✔
309	e,	1✔
310	Expression::BinaryOperator {	1✔
311	operator: BinaryOperatorType::Add,	1✔
312	left: Box::new(Expression::ScalarFunction {	1✔
313	fun: ScalarFunctionType::Round,	1✔
314	args: vec![Expression::Column { index: 2 }]	1✔
315	}),	1✔
316	right: Box::new(Expression::Column { index: 3 })	1✔
317	}	1✔
318	);	1✔
319	}	1✔
320
321	#[test]	1✔
322	fn test_3_nested_aggr_function_and_sum_3() {	1✔
323	let sql = "SELECT (ROUND(SUM(ROUND(field1, 2))) + SUM(field0)) + field0 FROM t0";	1✔
324	let schema = Schema::default()	1✔
325	.field(	1✔
326	FieldDefinition::new(	1✔
327	"field0".to_string(),	1✔
328	FieldType::Float,	1✔
329	false,	1✔
330	SourceDefinition::Dynamic,	1✔
331	),	1✔
332	false,	1✔
333	)	1✔
334	.field(	1✔
335	FieldDefinition::new(	1✔
336	"field1".to_string(),	1✔
337	FieldType::Float,	1✔
338	false,	1✔
339	SourceDefinition::Dynamic,	1✔
340	),	1✔
341	false,	1✔
342	)	1✔
343	.to_owned();	1✔
344		1✔
345	let mut builder = ExpressionBuilder::new(schema.fields.len());	1✔
346	let e = match &get_select(sql).unwrap().projection[0] {	1✔
347	SelectItem::UnnamedExpr(e) => builder.build(true, e, &schema).unwrap(),	1✔
348	_ => panic!("Invalid expr"),	×
349	};
350
351	assert_eq!(	1✔
352	builder,	1✔
353	ExpressionBuilder {	1✔
354	offset: schema.fields.len(),	1✔
355	aggregations: vec![	1✔
356	Expression::AggregateFunction {	1✔
357	fun: AggregateFunctionType::Sum,	1✔
358	args: vec![Expression::ScalarFunction {	1✔
359	fun: ScalarFunctionType::Round,	1✔
360	args: vec![	1✔
361	Expression::Column { index: 1 },	1✔
362	Expression::Literal(Field::Int(2))	1✔
363	]	1✔
364	}]	1✔
365	},	1✔
366	Expression::AggregateFunction {	1✔
367	fun: AggregateFunctionType::Sum,	1✔
368	args: vec![Expression::Column { index: 0 }]	1✔
369	}	1✔
370	]	1✔
371	}	1✔
372	);	1✔
373	assert_eq!(	1✔
374	e,	1✔
375	Expression::BinaryOperator {	1✔
376	operator: BinaryOperatorType::Add,	1✔
377	left: Box::new(Expression::BinaryOperator {	1✔
378	operator: BinaryOperatorType::Add,	1✔
379	left: Box::new(Expression::ScalarFunction {	1✔
380	fun: ScalarFunctionType::Round,	1✔
381	args: vec![Expression::Column { index: 2 }]	1✔
382	}),	1✔
383	right: Box::new(Expression::Column { index: 3 })	1✔
384	}),	1✔
385	right: Box::new(Expression::Column { index: 0 })	1✔
386	}	1✔
387	);	1✔
388	}	1✔
389
390	#[test]	×
391	#[ignore]
392	#[should_panic]
393	fn test_wrong_nested_aggregations() {	×
394	let sql = "SELECT SUM(SUM(field0)) FROM t0";	×
395	let schema = Schema::default()	×
396	.field(	×
397	FieldDefinition::new(	×
398	"field0".to_string(),	×
399	FieldType::Float,	×
400	false,	×
401	SourceDefinition::Dynamic,	×
402	),	×
403	false,	×
404	)	×
405	.to_owned();	×
406		×
407	let mut builder = ExpressionBuilder::new(schema.fields.len());	×
408	let _e = match &get_select(sql).unwrap().projection[0] {	×
409	SelectItem::UnnamedExpr(e) => builder.build(true, e, &schema).unwrap(),	×
410	_ => panic!("Invalid expr"),	×
411	};
412	}	×
413
414	#[test]	1✔
415	fn test_name_resolution() {	1✔
416	let sql = "SELECT CONCAT(table0.a, connection1.table0.b, a) FROM t0";	1✔
417	let schema = Schema::default()	1✔
418	.field(	1✔
419	FieldDefinition::new(	1✔
420	"a".to_string(),	1✔
421	FieldType::String,	1✔
422	false,	1✔
423	SourceDefinition::Table {	1✔
424	connection: "connection1".to_string(),	1✔
425	name: "table0".to_string(),	1✔
426	},	1✔
427	),	1✔
428	false,	1✔
429	)	1✔
430	.field(	1✔
431	FieldDefinition::new(	1✔
432	"b".to_string(),	1✔
433	FieldType::String,	1✔
434	false,	1✔
435	SourceDefinition::Table {	1✔
436	connection: "connection1".to_string(),	1✔
437	name: "table0".to_string(),	1✔
438	},	1✔
439	),	1✔
440	false,	1✔
441	)	1✔
442	.to_owned();	1✔
443		1✔
444	let mut builder = ExpressionBuilder::new(schema.fields.len());	1✔
445	let e = match &get_select(sql).unwrap().projection[0] {	1✔
446	SelectItem::UnnamedExpr(e) => builder.build(true, e, &schema).unwrap(),	1✔
447	_ => panic!("Invalid expr"),	×
448	};
449
450	assert_eq!(	1✔
451	builder,	1✔
452	ExpressionBuilder {	1✔
453	offset: schema.fields.len(),	1✔
454	aggregations: vec![]	1✔
455	}	1✔
456	);	1✔
457	assert_eq!(	1✔
458	e,	1✔
459	Expression::ScalarFunction {	1✔
460	fun: ScalarFunctionType::Concat,	1✔
461	args: vec![	1✔
462	Expression::Column { index: 0 },	1✔
463	Expression::Column { index: 1 },	1✔
464	Expression::Column { index: 0 }	1✔
465	]	1✔
466	}	1✔
467	);	1✔
468	}	1✔
469
470	#[test]	1✔
471	fn test_alias_resolution() {	1✔
472	let sql = "SELECT CONCAT(alias.a, a) FROM t0";	1✔
473	let schema = Schema::default()	1✔
474	.field(	1✔
475	FieldDefinition::new(	1✔
476	"a".to_string(),	1✔
477	FieldType::String,	1✔
478	false,	1✔
479	SourceDefinition::Alias {	1✔
480	name: "alias".to_string(),	1✔
481	},	1✔
482	),	1✔
483	false,	1✔
484	)	1✔
485	.to_owned();	1✔
486		1✔
487	let mut builder = ExpressionBuilder::new(schema.fields.len());	1✔
488	let e = match &get_select(sql).unwrap().projection[0] {	1✔
489	SelectItem::UnnamedExpr(e) => builder.build(true, e, &schema).unwrap(),	1✔
490	_ => panic!("Invalid expr"),	×
491	};
492
493	assert_eq!(	1✔
494	builder,	1✔
495	ExpressionBuilder {	1✔
496	offset: schema.fields.len(),	1✔
497	aggregations: vec![]	1✔
498	}	1✔
499	);	1✔
500	assert_eq!(	1✔
501	e,	1✔
502	Expression::ScalarFunction {	1✔
503	fun: ScalarFunctionType::Concat,	1✔
504	args: vec![	1✔
505	Expression::Column { index: 0 },	1✔
506	Expression::Column { index: 0 }	1✔
507	]	1✔
508	}	1✔
509	);	1✔
510	}	1✔

getdozer / dozer / 5611876656

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