Function plan_all_op

datafusion/sql/src/expr/mod.rs:1315–1362

Plans `needle ALL(haystack)` with proper SQL NULL semantics. CASE/WHEN structure: WHEN arr IS NULL → NULL WHEN empty → TRUE WHEN lhs IS NULL → NULL WHEN decisive_condition → FALSE WHEN has_nulls → NULL ELSE → TRUE

(
    needle: &Expr,
    haystack: &Expr,
    compare_op: &BinaryOperator,
)

///   WHEN has_nulls          → NULL
///   ELSE                    → TRUE
fn plan_all_op(
    needle: &Expr,
    haystack: &Expr,
    compare_op: &BinaryOperator,
) -> Result<Expr> {
    let null_arr_check = haystack.clone().is_null();
    let empty_check = cardinality(haystack.clone()).eq(lit(0u64));
    let null_lhs_check = needle.clone().is_null();
    // DataFusion's array_position uses is_null() checks internally (not equality),
    // so it can locate NULL elements even though NULL = NULL is NULL in standard SQL.
    let has_nulls =
        array_position(haystack.clone(), lit(ScalarValue::Null), lit(1i64)).is_not_null();

    let decisive_condition = match compare_op {
        BinaryOperator::NotEq => array_has(haystack.clone(), needle.clone()),
        BinaryOperator::Eq => {
            let all_equal = array_min(haystack.clone())
                .eq(needle.clone())
                .and(array_max(haystack.clone()).eq(needle.clone()));
            Expr::Not(Box::new(all_equal))
        }
        BinaryOperator::Gt => {
            Expr::Not(Box::new(needle.clone().gt(array_max(haystack.clone()))))
        }
        BinaryOperator::Lt => {
            Expr::Not(Box::new(needle.clone().lt(array_min(haystack.clone()))))
        }
        BinaryOperator::GtEq => {
            Expr::Not(Box::new(needle.clone().gt_eq(array_max(haystack.clone()))))
        }
        BinaryOperator::LtEq => {
            Expr::Not(Box::new(needle.clone().lt_eq(array_min(haystack.clone()))))
        }
        _ => {
            return plan_err!(
                "Unsupported AllOp: '{compare_op}', only '=', '<>', '>', '<', '>=', '<=' are supported"
            );
        }
    };

    let null_bool = lit(ScalarValue::Boolean(None));
    when(null_arr_check, null_bool.clone())
        .when(empty_check, lit(true))
        .when(null_lhs_check, null_bool.clone())
        .when(decisive_condition, lit(false))
        .when(has_nulls, null_bool)
        .otherwise(lit(true))
}

#[cfg(test)]
mod tests {