Fixes after sync to 50.0.0

Author: Vedin

Cargo.lock

@@ -173,7 +173,7 @@ recursive = "0.1.1"
 regex = "1.11"
 rstest = "0.25.0"
 serde_json = "1"
-sqlparser = { git = "https://github.com/Embucket/datafusion-sqlparser-rs.git", rev = "8d9cbc2669d7fc3d79d7d1d725ac20f1e9bfe10e", features = [
+sqlparser = { git = "https://github.com/Embucket/datafusion-sqlparser-rs.git", rev = "75ce913994c7bf8e1e9122f836da882302673bde", features = [
     "visitor",
 ] }
 tempfile = "3"

Cargo.toml

@@ -322,9 +322,13 @@ pub struct ParquetMetadataFunc {}
 
 impl TableFunctionImpl for ParquetMetadataFunc {
     fn call(&self, exprs: &[(Expr, Option<String>)]) -> Result<Arc<dyn TableProvider>> {
+        if exprs.is_empty() {
+            return plan_err!("parquet_metadata requires string argument as its input");
+        }
+
         let filename = match exprs.first() {
             Some((Expr::Literal(ScalarValue::Utf8(Some(s)), _), _)) => s, // single quote: parquet_metadata('x.parquet')
-            Some(Expr::Column(Column { name, .. })) => name, // double quote: parquet_metadata("x.parquet")
+            Some((Expr::Column(Column { name, .. }), _)) => name, // double quote: parquet_metadata("x.parquet")
             _ => {
                 return plan_err!(
                     "parquet_metadata requires string argument as its input"
@@ -510,7 +514,7 @@ impl MetadataCacheFunc {
 }
 
 impl TableFunctionImpl for MetadataCacheFunc {
-    fn call(&self, exprs: &[Expr]) -> Result<Arc<dyn TableProvider>> {
+    fn call(&self, exprs: &[(Expr, Option<String>)]) -> Result<Arc<dyn TableProvider>> {
         if !exprs.is_empty() {
             return plan_err!("metadata_cache should have no arguments");
         }

datafusion-cli/src/functions.rs

@@ -133,7 +133,8 @@ struct LocalCsvTableFunc {}
 
 impl TableFunctionImpl for LocalCsvTableFunc {
     fn call(&self, exprs: &[(Expr, Option<String>)]) -> Result<Arc<dyn TableProvider>> {
-        let Some((Expr::Literal(ScalarValue::Utf8(Some(ref path)), _), _)) = exprs.first()
+        let Some((Expr::Literal(ScalarValue::Utf8(Some(ref path)), _), _)) =
+            exprs.first()
         else {
             return plan_err!("read_csv requires at least one string argument");
         };

datafusion-examples/examples/simple_udtf.rs

@@ -274,6 +274,8 @@ impl Session for SessionState {
 }
 
 impl SessionState {
+    /// Resolve a [`TableReference`] into a [`ResolvedTableReference`] using
+    /// the session's configured default catalog and schema.
     pub fn resolve_table_ref(
         &self,
         table_ref: impl Into<TableReference>,

datafusion/core/src/execution/session_state.rs

@@ -97,7 +97,6 @@ use datafusion_sql::TableReference;
 use sqlparser::ast::NullTreatment;
 
 use async_trait::async_trait;
-use datafusion_datasource::file_groups::FileGroup;
 use datafusion_expr_common::operator::Operator;
 use datafusion_physical_plan::async_func::{AsyncFuncExec, AsyncMapper};
 use futures::{StreamExt, TryStreamExt};
@@ -1872,8 +1871,6 @@ pub fn create_aggregate_expr_and_maybe_filter(
     )
 }
 
-
-
 /// Transform a PIVOT operation into a more standard Aggregate + Projection plan
 /// For known pivot values, we create a projection that includes "IS NOT DISTINCT FROM" conditions
 ///
@@ -1930,7 +1927,7 @@ pub fn transform_pivot_to_aggregate(
             Box::new(Expr::Column(pivot_column.clone())),
             Operator::IsNotDistinctFrom,
             Box::new(Expr::Cast(Cast::new(
-                Box::new(Expr::Literal(value.clone())),
+                Box::new(Expr::Literal(value.clone(), None)),
                 pivot_col_type.clone(),
             ))),
         ));
@@ -2394,9 +2391,9 @@ impl DefaultPhysicalPlanner {
         if let LogicalPlan::Pivot(pivot) = input.as_ref() {
             if pivot.value_subquery.is_some()
                 && input_exec
-                .as_any()
-                .downcast_ref::<AggregateExec>()
-                .is_some()
+                    .as_any()
+                    .downcast_ref::<AggregateExec>()
+                    .is_some()
             {
                 let agg_exec =
                     input_exec.as_any().downcast_ref::<AggregateExec>().unwrap();

datafusion/core/src/physical_planner.rs

@@ -759,8 +759,8 @@ impl<'n> TreeNodeVisitor<'n> for PgJsonVisitor<'_, '_> {
 mod tests {
     use crate::EmptyRelation;
     use arrow::datatypes::{DataType, Field, Schema};
-    use insta::assert_snapshot;
     use datafusion_common::{Column, DFSchema, ScalarValue};
+    use insta::assert_snapshot;
     use std::sync::Arc;
 
     use super::*;

datafusion/expr/src/logical_plan/display.rs

@@ -2444,7 +2444,7 @@ fn pivot_schema(
     }
 
     for pivot_value in pivot_values {
-        let field_name = format!("{}", pivot_value);
+        let field_name = format!("{pivot_value}");
         let data_type = aggregate_expr.get_type(input_schema)?;
         fields.push(Arc::new(Field::new(field_name, data_type, true)));
     }

datafusion/expr/src/logical_plan/plan.rs

@@ -521,10 +521,13 @@ impl TableFunctionImpl for GenerateSeriesFuncImpl {
 }
 
 impl GenerateSeriesFuncImpl {
-    fn call_int64(&self, exprs: &[Expr]) -> Result<Arc<dyn TableProvider>> {
+    fn call_int64(
+        &self,
+        exprs: &[(Expr, Option<String>)],
+    ) -> Result<Arc<dyn TableProvider>> {
         let mut normalize_args = Vec::new();
-        for (expr_index, expr, _) in exprs.iter().enumerate() {
-            match expr {
+        for (expr_index, expr) in exprs.iter().enumerate() {
+            match &expr.0 {
                 Expr::Literal(ScalarValue::Null, _) => {}
                 Expr::Literal(ScalarValue::Int64(Some(n)), _) => normalize_args.push(*n),
                 other => {
@@ -584,7 +587,10 @@ impl GenerateSeriesFuncImpl {
         }))
     }
 
-    fn call_timestamp(&self, exprs: &[Expr]) -> Result<Arc<dyn TableProvider>> {
+    fn call_timestamp(
+        &self,
+        exprs: &[(Expr, Option<String>)],
+    ) -> Result<Arc<dyn TableProvider>> {
         if exprs.len() != 3 {
             return plan_err!(
                 "{} function with timestamps requires exactly 3 arguments",
@@ -593,7 +599,7 @@ impl GenerateSeriesFuncImpl {
         }
 
         // Parse start timestamp
-        let (start_ts, tz) = match &exprs[0] {
+        let (start_ts, tz) = match &exprs[0].0 {
             Expr::Literal(ScalarValue::TimestampNanosecond(ts, tz), _) => {
                 (*ts, tz.clone())
             }
@@ -606,7 +612,7 @@ impl GenerateSeriesFuncImpl {
         };
 
         // Parse end timestamp
-        let end_ts = match &exprs[1] {
+        let end_ts = match &exprs[1].0 {
             Expr::Literal(ScalarValue::Null, _) => None,
             Expr::Literal(ScalarValue::TimestampNanosecond(ts, _), _) => *ts,
             other => {
@@ -618,7 +624,7 @@ impl GenerateSeriesFuncImpl {
         };
 
         // Parse step interval
-        let step_interval = match &exprs[2] {
+        let step_interval = match &exprs[2].0 {
             Expr::Literal(ScalarValue::Null, _) => None,
             Expr::Literal(ScalarValue::IntervalMonthDayNano(interval), _) => *interval,
             other => {
@@ -660,7 +666,10 @@ impl GenerateSeriesFuncImpl {
         }))
     }
 
-    fn call_date(&self, exprs: &[Expr]) -> Result<Arc<dyn TableProvider>> {
+    fn call_date(
+        &self,
+        exprs: &[(Expr, Option<String>)],
+    ) -> Result<Arc<dyn TableProvider>> {
         if exprs.len() != 3 {
             return plan_err!(
                 "{} function with dates requires exactly 3 arguments",
@@ -675,7 +684,7 @@ impl GenerateSeriesFuncImpl {
         )]));
 
         // Parse start date
-        let start_date = match &exprs[0] {
+        let start_date = match &exprs[0].0 {
             Expr::Literal(ScalarValue::Date32(Some(date)), _) => *date,
             Expr::Literal(ScalarValue::Date32(None), _)
             | Expr::Literal(ScalarValue::Null, _) => {
@@ -693,7 +702,7 @@ impl GenerateSeriesFuncImpl {
         };
 
         // Parse end date
-        let end_date = match &exprs[1] {
+        let end_date = match &exprs[1].0 {
             Expr::Literal(ScalarValue::Date32(Some(date)), _) => *date,
             Expr::Literal(ScalarValue::Date32(None), _)
             | Expr::Literal(ScalarValue::Null, _) => {
@@ -711,7 +720,7 @@ impl GenerateSeriesFuncImpl {
         };
 
         // Parse step interval
-        let step_interval = match &exprs[2] {
+        let step_interval = match &exprs[2].0 {
             Expr::Literal(ScalarValue::IntervalMonthDayNano(Some(interval)), _) => {
                 *interval
             }

datafusion/functions-table/src/generate_series.rs

@@ -462,18 +462,14 @@ mod tests {
         ];
         for scalar in test_cases {
             let timestamp_to_date_result =
-                ToDateFunc::new().invoke_with_args(datafusion_expr::ScalarFunctionArgs {
-                    args: vec![ColumnarValue::Scalar(scalar.clone())],
-                    number_rows: 1,
-                    return_type: &DataType::Date32,
-                });
+                invoke_to_date_with_args(vec![ColumnarValue::Scalar(scalar.clone())], 1);
 
             match timestamp_to_date_result {
                 Ok(ColumnarValue::Scalar(ScalarValue::Date32(date_val))) => {
                     let expected = Date32Type::parse_formatted("2025-01-13", "%Y-%m-%d");
                     assert_eq!(date_val, expected, "to_date created wrong value");
                 }
-                _ => panic!("Conversion of {}", scalar),
+                _ => panic!("Conversion of {scalar}"),
             }
         }
     }