fix(query): fix index out of bounds with constant expr (#16206)

* fix(query): fix index out of bounds with constant expr

* fix(query): fix index out of bounds with constant expr

* Revert "fix(query): fix index out of bounds with constant expr"

This reverts commit 1486da6.

* fix(query): fix index out of bounds with constant expr

* fix(query): add short circuit test case

* fix(query): fix index out of bounds with constant expr

* fix(query): fix index out of bounds with constant expr

Author: zhang2014

src/query/expression/src/evaluator.rs

@@ -222,6 +222,7 @@ impl<'a> Evaluator<'a> {
 
                 let (_, eval) = function.eval.as_scalar().unwrap();
                 let result = (eval)(cols_ref.as_slice(), &mut ctx);
+
                 ctx.render_error(
                     *span,
                     id.params(),
@@ -852,6 +853,7 @@ impl<'a> Evaluator<'a> {
                 Value::Scalar(_) => 1,
                 Value::Column(col) => col.len(),
             });
+
         let block = DataBlock::new(vec![BlockEntry::new(src_type.clone(), value)], num_rows);
         let evaluator = Evaluator::new(&block, self.func_ctx, self.fn_registry);
         Ok(Some(evaluator.partial_run(&cast_expr, validity, options)?))

src/query/expression/src/function.rs

@@ -48,6 +48,7 @@ use crate::FunctionDomain;
 use crate::Scalar;
 
 pub type AutoCastRules<'a> = &'a [(DataType, DataType)];
+
 /// A function to build function depending on the const parameters and the type of arguments (before coercion).
 ///
 /// The first argument is the const parameters and the second argument is the types of arguments.
@@ -604,24 +605,26 @@ impl<'a> EvalContext<'a> {
         }
         match &self.errors {
             Some((valids, error)) => {
-                let first_error_row = if let Some(selection) = selection {
-                    if let Some(first_invalid) =
-                        selection.iter().find(|idx| !valids.get(**idx as usize))
-                    {
+                let first_error_row = match selection {
+                    None => valids.iter().enumerate().find(|(_, v)| !v).unwrap().0,
+                    Some(selection) if valids.len() == 1 => {
+                        if valids.get(0) || selection.is_empty() {
+                            return Ok(());
+                        }
+
+                        selection.first().map(|x| *x as usize).unwrap()
+                    }
+                    Some(selection) => {
+                        let Some(first_invalid) =
+                            selection.iter().find(|idx| !valids.get(**idx as usize))
+                        else {
+                            return Ok(());
+                        };
+
                         *first_invalid as usize
-                    } else {
-                        return Ok(());
                     }
-                } else {
-                    valids
-                        .iter()
-                        .enumerate()
-                        .filter(|(_, valid)| !valid)
-                        .take(1)
-                        .next()
-                        .unwrap()
-                        .0
                 };
+
                 let args = args
                     .iter()
                     .map(|arg| {

tests/sqllogictests/suites/query/eval_constant_expr.test

@@ -0,0 +1,20 @@
+statement ok
+DROP TABLE IF EXISTS test
+
+statement ok
+CREATE TABLE test(test DATE NULL)
+
+statement ok
+INSERT INTO test SELECT IF(number % 999=0 and number != 0,'2024-01-01', NULL) FROM numbers(10000)
+
+statement error 1006
+SELECT count(1) FROM test WHERE test IS NOT NULL AND NOT test = ''
+
+query ITIT
+SELECT count(1) FROM test WHERE test IS NOT NULL AND test != '2024-01-01' AND NOT test = ''
+----
+0
+
+statement ok
+drop table test;
+