Stash some changes

Signed-off-by: Adam Gutglick <[email protected]>

Author: AdamGS

vortex-datafusion/src/convert/exprs.rs

@@ -100,7 +100,7 @@ impl DefaultExpressionConvertor {
 
 impl ExpressionConvertor for DefaultExpressionConvertor {
     fn can_be_pushed_down(&self, expr: &Arc<dyn PhysicalExpr>, schema: &Schema) -> bool {
-        can_be_pushed_down(expr, schema)
+        can_be_pushed_down_impl(expr, schema)
     }
 
     fn convert(&self, df: &dyn PhysicalExpr) -> VortexResult<Expression> {
@@ -241,7 +241,7 @@ fn try_operator_from_df(value: &DFOperator) -> VortexResult<Operator> {
     }
 }
 
-pub(crate) fn can_be_pushed_down(df_expr: &Arc<dyn PhysicalExpr>, schema: &Schema) -> bool {
+fn can_be_pushed_down_impl(df_expr: &Arc<dyn PhysicalExpr>, schema: &Schema) -> bool {
     // We currently do not support pushdown of dynamic expressions in DF.
     // See issue: https://github.com/vortex-data/vortex/issues/4034
     if is_dynamic_physical_expr(df_expr) {
@@ -257,20 +257,24 @@ pub(crate) fn can_be_pushed_down(df_expr: &Arc<dyn PhysicalExpr>, schema: &Schem
             .ok()
             .is_some_and(|field| supported_data_types(field.data_type()))
     } else if let Some(like) = expr.downcast_ref::<df_expr::LikeExpr>() {
-        can_be_pushed_down(like.expr(), schema) && can_be_pushed_down(like.pattern(), schema)
+        can_be_pushed_down_impl(like.expr(), schema)
+            && can_be_pushed_down_impl(like.pattern(), schema)
     } else if let Some(lit) = expr.downcast_ref::<df_expr::Literal>() {
         supported_data_types(&lit.value().data_type())
     } else if expr.downcast_ref::<df_expr::CastExpr>().is_some()
         || expr.downcast_ref::<df_expr::CastColumnExpr>().is_some()
     {
         true
     } else if let Some(is_null) = expr.downcast_ref::<df_expr::IsNullExpr>() {
-        can_be_pushed_down(is_null.arg(), schema)
+        can_be_pushed_down_impl(is_null.arg(), schema)
     } else if let Some(is_not_null) = expr.downcast_ref::<df_expr::IsNotNullExpr>() {
-        can_be_pushed_down(is_not_null.arg(), schema)
+        can_be_pushed_down_impl(is_not_null.arg(), schema)
     } else if let Some(in_list) = expr.downcast_ref::<df_expr::InListExpr>() {
-        can_be_pushed_down(in_list.expr(), schema)
-            && in_list.list().iter().all(|e| can_be_pushed_down(e, schema))
+        can_be_pushed_down_impl(in_list.expr(), schema)
+            && in_list
+                .list()
+                .iter()
+                .all(|e| can_be_pushed_down_impl(e, schema))
     } else if let Some(scalar_fn) = expr.downcast_ref::<ScalarFunctionExpr>() {
         can_scalar_fn_be_pushed_down(scalar_fn)
     } else {
@@ -282,8 +286,8 @@ pub(crate) fn can_be_pushed_down(df_expr: &Arc<dyn PhysicalExpr>, schema: &Schem
 fn can_binary_be_pushed_down(binary: &df_expr::BinaryExpr, schema: &Schema) -> bool {
     let is_op_supported = try_operator_from_df(binary.op()).is_ok();
     is_op_supported
-        && can_be_pushed_down(binary.left(), schema)
-        && can_be_pushed_down(binary.right(), schema)
+        && can_be_pushed_down_impl(binary.left(), schema)
+        && can_be_pushed_down_impl(binary.right(), schema)
 }
 
 fn supported_data_types(dt: &DataType) -> bool {
@@ -548,30 +552,30 @@ mod tests {
     fn test_can_be_pushed_down_column_supported(test_schema: Schema) {
         let col_expr = Arc::new(df_expr::Column::new("id", 0)) as Arc<dyn PhysicalExpr>;
 
-        assert!(can_be_pushed_down(&col_expr, &test_schema));
+        assert!(can_be_pushed_down_impl(&col_expr, &test_schema));
     }
 
     #[rstest]
     fn test_can_be_pushed_down_column_unsupported_type(test_schema: Schema) {
         let col_expr =
             Arc::new(df_expr::Column::new("unsupported_list", 5)) as Arc<dyn PhysicalExpr>;
 
-        assert!(!can_be_pushed_down(&col_expr, &test_schema));
+        assert!(!can_be_pushed_down_impl(&col_expr, &test_schema));
     }
 
     #[rstest]
     fn test_can_be_pushed_down_column_not_found(test_schema: Schema) {
         let col_expr = Arc::new(df_expr::Column::new("nonexistent", 99)) as Arc<dyn PhysicalExpr>;
 
-        assert!(!can_be_pushed_down(&col_expr, &test_schema));
+        assert!(!can_be_pushed_down_impl(&col_expr, &test_schema));
     }
 
     #[rstest]
     fn test_can_be_pushed_down_literal_supported(test_schema: Schema) {
         let lit_expr =
             Arc::new(df_expr::Literal::new(ScalarValue::Int32(Some(42)))) as Arc<dyn PhysicalExpr>;
 
-        assert!(can_be_pushed_down(&lit_expr, &test_schema));
+        assert!(can_be_pushed_down_impl(&lit_expr, &test_schema));
     }
 
     #[rstest]
@@ -581,7 +585,7 @@ mod tests {
         let lit_expr =
             Arc::new(df_expr::Literal::new(unsupported_literal)) as Arc<dyn PhysicalExpr>;
 
-        assert!(!can_be_pushed_down(&lit_expr, &test_schema));
+        assert!(!can_be_pushed_down_impl(&lit_expr, &test_schema));
     }
 
     #[rstest]
@@ -592,7 +596,7 @@ mod tests {
         let binary_expr = Arc::new(df_expr::BinaryExpr::new(left, DFOperator::Eq, right))
             as Arc<dyn PhysicalExpr>;
 
-        assert!(can_be_pushed_down(&binary_expr, &test_schema));
+        assert!(can_be_pushed_down_impl(&binary_expr, &test_schema));
     }
 
     #[rstest]
@@ -606,7 +610,7 @@ mod tests {
             right,
         )) as Arc<dyn PhysicalExpr>;
 
-        assert!(!can_be_pushed_down(&binary_expr, &test_schema));
+        assert!(!can_be_pushed_down_impl(&binary_expr, &test_schema));
     }
 
     #[rstest]
@@ -617,7 +621,7 @@ mod tests {
         let binary_expr = Arc::new(df_expr::BinaryExpr::new(left, DFOperator::Eq, right))
             as Arc<dyn PhysicalExpr>;
 
-        assert!(!can_be_pushed_down(&binary_expr, &test_schema));
+        assert!(!can_be_pushed_down_impl(&binary_expr, &test_schema));
     }
 
     #[rstest]
@@ -629,7 +633,7 @@ mod tests {
         let like_expr =
             Arc::new(df_expr::LikeExpr::new(false, false, expr, pattern)) as Arc<dyn PhysicalExpr>;
 
-        assert!(can_be_pushed_down(&like_expr, &test_schema));
+        assert!(can_be_pushed_down_impl(&like_expr, &test_schema));
     }
 
     #[rstest]
@@ -641,6 +645,6 @@ mod tests {
         let like_expr =
             Arc::new(df_expr::LikeExpr::new(false, false, expr, pattern)) as Arc<dyn PhysicalExpr>;
 
-        assert!(!can_be_pushed_down(&like_expr, &test_schema));
+        assert!(!can_be_pushed_down_impl(&like_expr, &test_schema));
     }
 }

vortex-datafusion/src/persistent/mod.rs

@@ -7,6 +7,7 @@ mod cache;
 mod format;
 pub mod metrics;
 mod opener;
+mod projection;
 mod sink;
 mod source;