fix(ci): fix native prewhere when there is subquery

Author: sundy-li

Cargo.lock

@@ -19,4 +19,4 @@ fi
 echo "Run suites using argument: $RUN_DIR"
 
 echo "Starting databend-sqllogic tests"
-target/${BUILD_PROFILE}/databend-sqllogictests --handlers ${TEST_HANDLERS} ${RUN_DIR} --skip_dir management,mode,explain --enable_sandbox --parallel 8 --debug
+target/${BUILD_PROFILE}/databend-sqllogictests --handlers ${TEST_HANDLERS} ${RUN_DIR} --skip_dir management,mode,explain,tpch --enable_sandbox --parallel 8 --debug

scripts/ci/ci-run-sqllogic-tests-native.sh

@@ -52,47 +52,51 @@ impl RulePushDownPrewhere {
         }
     }
 
-    fn collect_columns_impl(expr: &ScalarExpr, columns: &mut ColumnSet) {
+    /// will throw error if the bound column ref is not in the table, such as subquery
+    fn collect_columns_impl(expr: &ScalarExpr, columns: &mut ColumnSet) -> Option<()> {
         match expr {
             ScalarExpr::BoundColumnRef(column) => {
+                if column.column.table_name.is_none() {
+                    return None;
+                }
                 columns.insert(column.column.index);
+                Some(())
             }
             ScalarExpr::AndExpr(and) => {
-                Self::collect_columns_impl(and.left.as_ref(), columns);
-                Self::collect_columns_impl(and.right.as_ref(), columns);
+                Self::collect_columns_impl(and.left.as_ref(), columns)?;
+                Self::collect_columns_impl(and.right.as_ref(), columns)
             }
             ScalarExpr::OrExpr(or) => {
-                Self::collect_columns_impl(or.left.as_ref(), columns);
-                Self::collect_columns_impl(or.right.as_ref(), columns);
-            }
-            ScalarExpr::NotExpr(not) => {
-                Self::collect_columns_impl(not.argument.as_ref(), columns);
+                Self::collect_columns_impl(or.left.as_ref(), columns)?;
+                Self::collect_columns_impl(or.right.as_ref(), columns)
             }
+            ScalarExpr::NotExpr(not) => Self::collect_columns_impl(not.argument.as_ref(), columns),
             ScalarExpr::ComparisonExpr(cmp) => {
-                Self::collect_columns_impl(cmp.left.as_ref(), columns);
-                Self::collect_columns_impl(cmp.right.as_ref(), columns);
+                Self::collect_columns_impl(cmp.left.as_ref(), columns)?;
+                Self::collect_columns_impl(cmp.right.as_ref(), columns)
             }
             ScalarExpr::FunctionCall(func) => {
                 for arg in func.arguments.iter() {
-                    Self::collect_columns_impl(arg, columns);
+                    Self::collect_columns_impl(arg, columns)?;
                 }
+                Some(())
             }
             ScalarExpr::CastExpr(cast) => {
-                Self::collect_columns_impl(cast.argument.as_ref(), columns);
+                Self::collect_columns_impl(cast.argument.as_ref(), columns)
             }
             // 1. ConstantExpr is not collected.
             // 2. SubqueryExpr and AggregateFunction will not appear in Filter-LogicalGet
-            _ => {}
+            _ => None,
         }
     }
 
     // analyze if the expression can be moved to prewhere
-    fn collect_columns(expr: &ScalarExpr) -> ColumnSet {
+    fn collect_columns(expr: &ScalarExpr) -> Option<ColumnSet> {
         let mut columns = ColumnSet::new();
         // columns in subqueries are not considered
-        Self::collect_columns_impl(expr, &mut columns);
+        Self::collect_columns_impl(expr, &mut columns)?;
 
-        columns
+        Some(columns)
     }
 
     pub fn prewhere_optimize(&self, s_expr: &SExpr) -> Result<SExpr> {
@@ -111,21 +115,27 @@ impl RulePushDownPrewhere {
 
         // filter.predicates are already splited by AND
         for pred in filter.predicates.iter() {
-            let columns = Self::collect_columns(pred);
-            prewhere_pred.push(pred.clone());
-            prewhere_columns.extend(&columns);
+            match Self::collect_columns(pred) {
+                Some(columns) => {
+                    prewhere_pred.push(pred.clone());
+                    prewhere_columns.extend(&columns);
+                }
+                None => return Ok(s_expr.clone()),
+            }
         }
 
-        get.prewhere = if prewhere_pred.is_empty() {
-            None
-        } else {
-            Some(Prewhere {
+        if !prewhere_pred.is_empty() {
+            if let Some(prewhere) = get.prewhere.as_ref() {
+                prewhere_pred.extend(prewhere.predicates.clone());
+                prewhere_columns.extend(&prewhere.prewhere_columns);
+            }
+
+            get.prewhere = Some(Prewhere {
                 output_columns: get.columns.clone(),
                 prewhere_columns,
                 predicates: prewhere_pred,
-            })
-        };
-
+            });
+        }
         Ok(SExpr::create_leaf(get.into()))
     }
 }

src/query/sql/src/planner/optimizer/rule/rewrite/rule_push_down_prewhere.rs

@@ -5,9 +5,9 @@ statement ok
 insert into temp values(1)
 
 query II
-select data_size, data_compressed_size from system.tables where name = 'temp'
+select data_size, data_compressed_size > 0 from system.tables where name = 'temp'
 ----
-1 207
+1 1
 
 statement ok
 drop table temp