un-deprecate to minimize diff

Author: adriangb

datafusion/catalog/src/memory/table.rs

@@ -138,7 +138,6 @@ impl MemTable {
     ) -> Result<Self> {
         let schema = t.schema();
         let constraints = t.constraints();
-        #[expect(deprecated)]
         let exec = t.scan(state, None, &[], None).await?;
         let partition_count = exec.output_partitioning().partition_count();
 

datafusion/catalog/src/table.rs

@@ -164,7 +164,6 @@ pub trait TableProvider: Debug + Sync + Send {
     /// because inexact filters do not guarantee that every filtered row is
     /// removed, so applying the limit could lead to too few rows being available
     /// to return as a final result.
-    #[deprecated(since = "50.0.0", note = "Use `scan_with_args` instead")]
     async fn scan(
         &self,
         state: &dyn Session,
@@ -195,7 +194,6 @@ pub trait TableProvider: Debug + Sync + Send {
                 TableProviderFilterPushDown::Exact => None,
             })
             .collect_vec();
-        #[expect(deprecated)]
         let plan = self
             .scan(state, projection.as_ref(), &filters, limit)
             .await?;
@@ -381,6 +379,7 @@ pub struct ScanResult {
     /// The ExecutionPlan to run.
     plan: Arc<dyn ExecutionPlan>,
     // Remaining filters that were not completely evaluated during `scan_with_args()`.
+    // These were previously referred to as "unsupported filters" or "inexact filters".
     filters: Vec<Expr>,
 }
 

datafusion/core/src/datasource/listing/table.rs

@@ -1696,7 +1696,6 @@ mod tests {
 
         let table = load_table(&ctx, "alltypes_plain.parquet").await?;
         let projection = None;
-        #[expect(deprecated)]
         let exec = table
             .scan(&ctx.state(), projection, &[], None)
             .await
@@ -1834,7 +1833,6 @@ mod tests {
         // this will filter out the only file in the store
         let filter = Expr::not_eq(col("p1"), lit("v1"));
 
-        #[expect(deprecated)]
         let scan = table
             .scan(&ctx.state(), None, &[filter], None)
             .await
@@ -2735,7 +2733,6 @@ mod tests {
             .with_schema(schema_default);
         let table_default = ListingTable::try_new(config_default)?;
 
-        #[expect(deprecated)]
         let exec_default = table_default.scan(&state, None, &[], None).await?;
         assert_eq!(
             exec_default.partition_statistics(None)?.num_rows,
@@ -2757,7 +2754,6 @@ mod tests {
             .with_schema(schema_disabled);
         let table_disabled = ListingTable::try_new(config_disabled)?;
 
-        #[expect(deprecated)]
         let exec_disabled = table_disabled.scan(&state, None, &[], None).await?;
         assert_eq!(
             exec_disabled.partition_statistics(None)?.num_rows,
@@ -2777,7 +2773,6 @@ mod tests {
             .with_schema(schema_enabled);
         let table_enabled = ListingTable::try_new(config_enabled)?;
 
-        #[expect(deprecated)]
         let exec_enabled = table_enabled.scan(&state, None, &[], None).await?;
         assert_eq!(
             exec_enabled.partition_statistics(None)?.num_rows,
@@ -2884,7 +2879,6 @@ mod tests {
         assert!(table.schema_adapter_factory().is_none());
 
         // The scan should work correctly with the default schema adapter
-        #[expect(deprecated)]
         let scan_result = table.scan(&ctx.state(), None, &[], None).await;
         assert!(
             scan_result.is_ok(),
@@ -2921,7 +2915,6 @@ mod tests {
         )?;
 
         // The error should bubble up from the scan operation when schema mapping fails
-        #[expect(deprecated)]
         let scan_result = table.scan(&ctx.state(), None, &[], None).await;
 
         assert!(scan_result.is_err());

datafusion/core/src/datasource/memory_test.rs

@@ -59,7 +59,6 @@ mod tests {
         let provider = MemTable::try_new(schema, vec![vec![batch]])?;
 
         // scan with projection
-        #[expect(deprecated)]
         let exec = provider
             .scan(&session_ctx.state(), Some(&vec![2, 1]), &[], None)
             .await?;
@@ -95,7 +94,6 @@ mod tests {
 
         let provider = MemTable::try_new(schema, vec![vec![batch]])?;
 
-        #[expect(deprecated)]
         let exec = provider.scan(&session_ctx.state(), None, &[], None).await?;
         let mut it = exec.execute(0, task_ctx)?;
         let batch1 = it.next().await.unwrap()?;
@@ -128,7 +126,6 @@ mod tests {
 
         let projection: Vec<usize> = vec![0, 4];
 
-        #[expect(deprecated)]
         match provider
             .scan(&session_ctx.state(), Some(&projection), &[], None)
             .await
@@ -257,7 +254,6 @@ mod tests {
         let provider =
             MemTable::try_new(Arc::new(merged_schema), vec![vec![batch1, batch2]])?;
 
-        #[expect(deprecated)]
         let exec = provider.scan(&session_ctx.state(), None, &[], None).await?;
         let mut it = exec.execute(0, task_ctx)?;
         let batch1 = it.next().await.unwrap()?;

datafusion/core/tests/parquet/file_statistics.rs

@@ -60,7 +60,6 @@ async fn check_stats_precision_with_filter_pushdown() {
     options.execution.parquet.pushdown_filters = true;
 
     // Scan without filter, stats are exact
-    #[expect(deprecated)]
     let exec = table.scan(&state, None, &[], None).await.unwrap();
     assert_eq!(
         exec.partition_statistics(None).unwrap().num_rows,
@@ -72,7 +71,6 @@ async fn check_stats_precision_with_filter_pushdown() {
     // (it is not a partition filter). Therefore; it will be pushed down to the
     // source operator after the appropriate optimizer pass.
     let filter_expr = Expr::gt(col("id"), lit(1));
-    #[expect(deprecated)]
     let exec_with_filter = table
         .scan(&state, None, std::slice::from_ref(&filter_expr), None)
         .await
@@ -121,7 +119,6 @@ async fn load_table_stats_with_session_level_cache() {
 
     //Session 1 first time list files
     assert_eq!(get_static_cache_size(&state1), 0);
-    #[expect(deprecated)]
     let exec1 = table1.scan(&state1, None, &[], None).await.unwrap();
 
     assert_eq!(
@@ -138,7 +135,6 @@ async fn load_table_stats_with_session_level_cache() {
     //Session 2 first time list files
     //check session 1 cache result not show in session 2
     assert_eq!(get_static_cache_size(&state2), 0);
-    #[expect(deprecated)]
     let exec2 = table2.scan(&state2, None, &[], None).await.unwrap();
     assert_eq!(
         exec2.partition_statistics(None).unwrap().num_rows,
@@ -154,7 +150,6 @@ async fn load_table_stats_with_session_level_cache() {
     //Session 1 second time list files
     //check session 1 cache result not show in session 2
     assert_eq!(get_static_cache_size(&state1), 1);
-    #[expect(deprecated)]
     let exec3 = table1.scan(&state1, None, &[], None).await.unwrap();
     assert_eq!(
         exec3.partition_statistics(None).unwrap().num_rows,
@@ -200,7 +195,6 @@ async fn list_files_with_session_level_cache() {
 
     //Session 1 first time list files
     assert_eq!(get_list_file_cache_size(&state1), 0);
-    #[expect(deprecated)]
     let exec1 = table1.scan(&state1, None, &[], None).await.unwrap();
     let data_source_exec = exec1.as_any().downcast_ref::<DataSourceExec>().unwrap();
     let data_source = data_source_exec.data_source();
@@ -217,7 +211,6 @@ async fn list_files_with_session_level_cache() {
     //Session 2 first time list files
     //check session 1 cache result not show in session 2
     assert_eq!(get_list_file_cache_size(&state2), 0);
-    #[expect(deprecated)]
     let exec2 = table2.scan(&state2, None, &[], None).await.unwrap();
     let data_source_exec = exec2.as_any().downcast_ref::<DataSourceExec>().unwrap();
     let data_source = data_source_exec.data_source();
@@ -234,7 +227,6 @@ async fn list_files_with_session_level_cache() {
     //Session 1 second time list files
     //check session 1 cache result not show in session 2
     assert_eq!(get_list_file_cache_size(&state1), 1);
-    #[expect(deprecated)]
     let exec3 = table1.scan(&state1, None, &[], None).await.unwrap();
     let data_source_exec = exec3.as_any().downcast_ref::<DataSourceExec>().unwrap();
     let data_source = data_source_exec.data_source();

datafusion/core/tests/physical_optimizer/partition_statistics.rs

@@ -102,7 +102,6 @@ mod test {
             .downcast_ref::<ListingTable>()
             .unwrap()
             .clone();
-        #[expect(deprecated)]
         listing_table
             .scan(&ctx.state(), None, &[], None)
             .await

datafusion/ffi/src/table_provider.rs

@@ -260,7 +260,6 @@ unsafe extern "C" fn scan_fn_wrapper(
 
         let projections: Vec<_> = projections.into_iter().collect();
 
-        #[expect(deprecated)]
         let plan = rresult_return!(
             internal_provider
                 .scan(&ctx.state(), Some(&projections), &filters, limit.into())