uqa-execution 0.6.2

Volcano physical operators with row-batch pipelines
Documentation
//
// Unified Query Algebra
//
// Copyright (c) 2023-2026 Cognica, Inc.
//

use super::*;

fn range_field(text: &str, oid: u32, array: bool) -> Value {
    if array {
        Value::Array(
            uqa_core::ArrayValue::try_new(vec![Value::Str(text.into())])
                .unwrap()
                .with_element_type_oid(Some(oid)),
        )
    } else {
        Value::Row(
            uqa_core::RowValue::typed(
                vec![Value::Str(text.into())],
                vec![uqa_core::RecordFieldType {
                    collation_oid: None,
                    oid,
                    type_modifier: -1,
                }],
            )
            .unwrap(),
        )
    }
}

#[test]
fn range_join_preserves_direct_encoded_and_spilled_multiplicities() {
    for (oid, first, equal) in [
        (3906, "[1.0,3.00)", "[1.00,3.0)"),
        (4532, "{[1.0,2.00),[5,6)}", "{[1.00,2.0),[5.0,6.00)}"),
    ] {
        for shape in 0..3 {
            let ty = (shape == 0).then(|| {
                uqa_sql::catalog::type_metadata::builtin_scalar_type(oid)
                    .unwrap()
                    .clone()
            });
            let value = |text: &str| {
                if shape == 0 {
                    Value::Str(text.into())
                } else {
                    range_field(text, oid, shape == 2)
                }
            };
            for (left_count, right_count, budget, computed) in [
                (1, 2, 64 * 1024, false),
                (2, 1, 64 * 1024, false),
                (1, 2, 64 * 1024, true),
                (2, 1, 64 * 1024, true),
                (2, 2, 1, false),
                (2, 2, 1, true),
            ] {
                let left = TableScan::from_typed_rows(
                    vec!["l.k".into()],
                    vec![ty.clone()],
                    vec![row(&[("l.k", value(first))]); left_count],
                );
                let right = TableScan::from_typed_rows(
                    vec!["r.k".into()],
                    vec![ty.clone()],
                    vec![row(&[("r.k", value(equal))]); right_count],
                );
                let expression = |name: &str| {
                    let key = ScalarExpr::Column(name.into());
                    if computed {
                        ScalarExpr::Case {
                            base: None,
                            when: vec![(ScalarExpr::Literal(Value::Bool(true)), key)],
                            else_branch: None,
                        }
                    } else {
                        key
                    }
                };
                let mut join = HashJoin::new_with_work_mem(
                    Box::new(left),
                    Box::new(right),
                    JoinKind::Inner,
                    vec![expression("l.k")],
                    vec![expression("r.k")],
                    evaluator(),
                    row(&[("l.k", Value::Null)]),
                    row(&[("r.k", Value::Null)]),
                    budget,
                );
                join.open().unwrap();
                assert_eq!(join.builds_left_input(), left_count < right_count);
                let first_batch = join.next().unwrap();
                if budget != 1 {
                    let state = join
                        .streaming_unique
                        .as_ref()
                        .expect("unique smaller input must select streaming join");
                    assert!(matches!(
                        (&state.hash_index, computed),
                        (super::super::UniqueHashIndex::Direct(_), false)
                            | (super::super::UniqueHashIndex::Encoded(_), true)
                    ));
                }
                let mut count = first_batch.map_or(0, |batch| batch.len());
                while let Some(batch) = join.next().unwrap() {
                    count += batch.rows.len();
                }
                assert_eq!(count, left_count * right_count);
                assert_eq!(join.hash_index_has_spilled(), budget == 1);
                join.close().unwrap();
            }
        }
    }
}

#[test]
fn spilled_range_full_join_retains_unmatched_and_null_rows() {
    let values = |side, first, other| {
        [
            (1, range_field(first, 3906, false)),
            (2, range_field(first, 3906, false)),
            (3, range_field(other, 3906, false)),
            (4, Value::Null),
        ]
        .into_iter()
        .map(|(id, key)| {
            row(&[
                (side, Value::Int(id)),
                (if side == "l.id" { "l.k" } else { "r.k" }, key),
            ])
        })
        .collect()
    };
    let left = TableScan::from_rows(
        vec!["l.id".into(), "l.k".into()],
        values("l.id", "[1.0,3.00)", "[5,7)"),
    );
    let right = TableScan::from_rows(
        vec!["r.id".into(), "r.k".into()],
        values("r.id", "[1.00,3.0)", "[8,9)"),
    );
    let mut join = HashJoin::new_with_work_mem(
        Box::new(left),
        Box::new(right),
        JoinKind::Full,
        vec![ScalarExpr::Column("l.k".into())],
        vec![ScalarExpr::Column("r.k".into())],
        evaluator(),
        row(&[("l.id", Value::Null), ("l.k", Value::Null)]),
        row(&[("r.id", Value::Null), ("r.k", Value::Null)]),
        1,
    );
    let (_, rows) = run_to_rows(&mut join).unwrap();
    let mut pairs = rows
        .iter()
        .map(|row| (row["l.id"].clone(), row["r.id"].clone()))
        .collect::<Vec<_>>();
    pairs.sort();
    let mut expected = vec![
        (Value::Int(1), Value::Int(1)),
        (Value::Int(1), Value::Int(2)),
        (Value::Int(2), Value::Int(1)),
        (Value::Int(2), Value::Int(2)),
        (Value::Int(3), Value::Null),
        (Value::Int(4), Value::Null),
        (Value::Null, Value::Int(3)),
        (Value::Null, Value::Int(4)),
    ];
    expected.sort();
    assert_eq!(pairs, expected);
    assert!(join.hash_index_has_spilled());
    assert!(join.right_input_has_spilled());
    assert!(join.output_has_spilled());
}

#[test]
fn join_key_types_are_resolved_once_per_open_and_never_during_close() {
    struct CountTypes(AtomicUsize);
    impl crate::ExpressionEvaluator for CountTypes {
        fn evaluate(
            &self,
            expression: &ScalarExpr,
            row: &dyn uqa_sql::expr::RowLookup,
        ) -> ExecResult<Value> {
            TestEvaluator.evaluate(expression, row)
        }
        fn expression_type(
            &self,
            expression: &ScalarExpr,
            schema: &RowSchema,
        ) -> Result<Option<uqa_sql::ColumnType>, uqa_sql::SQLError> {
            if self.0.fetch_add(1, Ordering::Relaxed) >= 2 {
                return Err(uqa_sql::SQLError::Internal(
                    "join repeated its selected type lookup".into(),
                ));
            }
            crate::scalar_type(expression, schema, &[])
        }
    }
    let evaluator = Arc::new(CountTypes(AtomicUsize::new(0)));
    let ty = uqa_sql::ColumnType::from_sql_name("numrange").unwrap();
    let scan = |column: &str, text: &str| {
        Box::new(TableScan::from_typed_rows(
            vec![column.into()],
            vec![Some(ty.clone())],
            vec![row(&[(column, Value::Str(text.into()))])],
        ))
    };
    let mut join = HashJoin::new_with_work_mem(
        scan("l.k", "[1.0,3.00)"),
        scan("r.k", "[1.00,3.0)"),
        JoinKind::Inner,
        vec![ScalarExpr::Column("l.k".into())],
        vec![ScalarExpr::Column("r.k".into())],
        evaluator.clone(),
        row(&[("l.k", Value::Null)]),
        row(&[("r.k", Value::Null)]),
        65536,
    );
    assert_eq!(run_to_rows(&mut join).unwrap().1.len(), 1);
    assert_eq!(evaluator.0.load(Ordering::Relaxed), 2);
}