wip

Author: jayshrivastava

datafusion/ffi/src/physical_expr/mod.rs

@@ -698,9 +698,9 @@ impl PhysicalExpr for ForeignPhysicalExpr {
         }
     }
 
-    #[allow(deprecated)]
     fn snapshot(&self) -> Result<Option<Arc<dyn PhysicalExpr>>> {
         unsafe {
+            #[allow(deprecated)]
             let result = df_result!((self.expr.snapshot)(&self.expr))?;
             Ok(result
                 .map(|expr| <Arc<dyn PhysicalExpr>>::from(&expr))
@@ -947,6 +947,23 @@ mod tests {
         assert_eq!(left, right);
     }
 
+    #[allow(deprecated)]
+    #[test]
+    fn ffi_physical_expr_snapshots() -> Result<(), DataFusionError> {
+        let (original, foreign_expr) = create_test_expr();
+
+        let left = original.snapshot()?;
+        let right = foreign_expr.snapshot()?;
+        assert_eq!(left, right);
+
+        assert_eq!(
+            original.snapshot_generation(),
+            foreign_expr.snapshot_generation()
+        );
+
+        Ok(())
+    }
+
     #[test]
     fn ffi_physical_expr_volatility() {
         let (original, foreign_expr) = create_test_expr();

datafusion/physical-expr/src/expressions/dynamic_filters.rs

@@ -525,11 +525,6 @@ impl PhysicalExpr for DynamicFilterPhysicalExpr {
         self.render(f, |expr, f| expr.fmt_sql(f))
     }
 
-    #[allow(useless_deprecated, unused_attributes)]
-    #[deprecated(
-        since = "54.0.0",
-        note = "downcast to `DynamicFilterPhysicalExpr` and call `current()` instead"
-    )]
     fn snapshot(&self) -> Result<Option<Arc<dyn PhysicalExpr>>> {
         // Return the current expression as a snapshot.
         Ok(Some(self.current()?))
@@ -708,6 +703,24 @@ mod test {
         assert_eq!(&dynamic_filter.current().unwrap(), &new_expr);
     }
 
+    #[allow(deprecated)]
+    #[test]
+    fn test_snapshot() {
+        let expr = lit(42) as Arc<dyn PhysicalExpr>;
+        let dynamic_filter = DynamicFilterPhysicalExpr::new(vec![], Arc::clone(&expr));
+
+        // Take a snapshot of the current expression
+        let snapshot = dynamic_filter.snapshot().unwrap();
+        assert_eq!(snapshot, Some(expr));
+
+        // Update the current expression
+        let new_expr = lit(100) as Arc<dyn PhysicalExpr>;
+        dynamic_filter.update(Arc::clone(&new_expr)).unwrap();
+        // Take another snapshot
+        let snapshot = dynamic_filter.snapshot().unwrap();
+        assert_eq!(snapshot, Some(new_expr));
+    }
+
     #[test]
     fn test_dynamic_filter_physical_expr_misbehaves_data_type_nullable() {
         let dynamic_filter =