Coverage Report

Created: 2024-10-13 08:39

/Users/andrewlamb/Software/datafusion/datafusion/physical-expr/src/intervals/test_utils.rs
Line
Count
Source (jump to first uncovered line)
1
// Licensed to the Apache Software Foundation (ASF) under one
2
// or more contributor license agreements.  See the NOTICE file
3
// distributed with this work for additional information
4
// regarding copyright ownership.  The ASF licenses this file
5
// to you under the Apache License, Version 2.0 (the
6
// "License"); you may not use this file except in compliance
7
// with the License.  You may obtain a copy of the License at
8
//
9
//http://www.apache.org/licenses/LICENSE-2.0
10
//
11
// Unless required by applicable law or agreed to in writing,
12
// software distributed under the License is distributed on an
13
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
14
// KIND, either express or implied.  See the License for the
15
// specific language governing permissions and limitations
16
// under the License.
17
18
//! Test utilities for the interval arithmetic library
19
20
use std::sync::Arc;
21
22
use crate::expressions::{binary, BinaryExpr, Literal};
23
use crate::PhysicalExpr;
24
use arrow_schema::Schema;
25
use datafusion_common::{DataFusionError, ScalarValue};
26
use datafusion_expr::Operator;
27
28
#[allow(clippy::too_many_arguments)]
29
/// This test function generates a conjunctive statement with two numeric
30
/// terms with the following form:
31
/// left_col (op_1) a  >/>= right_col (op_2) b AND left_col (op_3) c </<= right_col (op_4) d
32
243
pub fn gen_conjunctive_numerical_expr(
33
243
    left_col: Arc<dyn PhysicalExpr>,
34
243
    right_col: Arc<dyn PhysicalExpr>,
35
243
    op: (Operator, Operator, Operator, Operator),
36
243
    a: ScalarValue,
37
243
    b: ScalarValue,
38
243
    c: ScalarValue,
39
243
    d: ScalarValue,
40
243
    bounds: (Operator, Operator),
41
243
) -> Arc<dyn PhysicalExpr> {
42
243
    let (op_1, op_2, op_3, op_4) = op;
43
243
    let left_and_1 = Arc::new(BinaryExpr::new(
44
243
        Arc::clone(&left_col),
45
243
        op_1,
46
243
        Arc::new(Literal::new(a)),
47
243
    ));
48
243
    let left_and_2 = Arc::new(BinaryExpr::new(
49
243
        Arc::clone(&right_col),
50
243
        op_2,
51
243
        Arc::new(Literal::new(b)),
52
243
    ));
53
243
    let right_and_1 =
54
243
        Arc::new(BinaryExpr::new(left_col, op_3, Arc::new(Literal::new(c))));
55
243
    let right_and_2 =
56
243
        Arc::new(BinaryExpr::new(right_col, op_4, Arc::new(Literal::new(d))));
57
243
    let (greater_op, less_op) = bounds;
58
243
59
243
    let left_expr = Arc::new(BinaryExpr::new(left_and_1, greater_op, left_and_2));
60
243
    let right_expr = Arc::new(BinaryExpr::new(right_and_1, less_op, right_and_2));
61
243
    Arc::new(BinaryExpr::new(left_expr, Operator::And, right_expr))
62
243
}
63
64
#[allow(clippy::too_many_arguments)]
65
/// This test function generates a conjunctive statement with
66
/// two scalar values with the following form:
67
/// left_col (op_1) a  > right_col (op_2) b AND left_col (op_3) c < right_col (op_4) d
68
64
pub fn gen_conjunctive_temporal_expr(
69
64
    left_col: Arc<dyn PhysicalExpr>,
70
64
    right_col: Arc<dyn PhysicalExpr>,
71
64
    op_1: Operator,
72
64
    op_2: Operator,
73
64
    op_3: Operator,
74
64
    op_4: Operator,
75
64
    a: ScalarValue,
76
64
    b: ScalarValue,
77
64
    c: ScalarValue,
78
64
    d: ScalarValue,
79
64
    schema: &Schema,
80
64
) -> Result<Arc<dyn PhysicalExpr>, DataFusionError> {
81
64
    let left_and_1 = binary(
82
64
        Arc::clone(&left_col),
83
64
        op_1,
84
64
        Arc::new(Literal::new(a)),
85
64
        schema,
86
64
    )
?0
;
87
64
    let left_and_2 = binary(
88
64
        Arc::clone(&right_col),
89
64
        op_2,
90
64
        Arc::new(Literal::new(b)),
91
64
        schema,
92
64
    )
?0
;
93
64
    let right_and_1 = binary(left_col, op_3, Arc::new(Literal::new(c)), schema)
?0
;
94
64
    let right_and_2 = binary(right_col, op_4, Arc::new(Literal::new(d)), schema)
?0
;
95
64
    let left_expr = Arc::new(BinaryExpr::new(left_and_1, Operator::Gt, left_and_2));
96
64
    let right_expr = Arc::new(BinaryExpr::new(right_and_1, Operator::Lt, right_and_2));
97
64
    Ok(Arc::new(BinaryExpr::new(
98
64
        left_expr,
99
64
        Operator::And,
100
64
        right_expr,
101
64
    )))
102
64
}