Merge branch 'main' into feat/1757-aggregate-column-names

Author: richacode007-byte

.ai/skills/check-upstream/SKILL.md

@@ -146,6 +146,7 @@ The user may specify an area via `$ARGUMENTS`. If no area is specified or "all"
 - `show_limit` — already covered by `DataFrame.show()`, which provides the same functionality with a simpler API
 - `with_param_values` — already covered by the `param_values` argument on `SessionContext.sql()`, which accomplishes the same thing more robustly
 - `union_by_name_distinct` — already covered by `DataFrame.union_by_name(distinct=True)`, which provides a more Pythonic API
+- `to_string` — `str(df)` is the Pythonic way to get a string and already goes through `__repr__` and the configurable formatter. A separate `to_string()` would either duplicate `str(df)` or render every row through a different path (session `datafusion.format.*` options, no formatter), giving a third text rendering alongside `repr` and `show()`
 
 **How to check:**
 1. Fetch the upstream DataFrame documentation page listing all methods

crates/core/src/dataframe.rs

@@ -844,13 +844,24 @@ impl PyDataFrame {
     }
 
     /// Print the query plan
-    #[pyo3(signature = (verbose=false, analyze=false, format=None))]
+    #[pyo3(signature = (
+        verbose=false,
+        analyze=false,
+        format=None,
+        show_statistics=None,
+        analyze_level=None,
+        analyze_categories=None
+    ))]
+    #[allow(clippy::too_many_arguments)]
     fn explain(
         &self,
         py: Python,
         verbose: bool,
         analyze: bool,
         format: Option<&str>,
+        show_statistics: Option<bool>,
+        analyze_level: Option<&str>,
+        analyze_categories: Option<Vec<String>>,
     ) -> PyDataFusionResult<()> {
         let explain_format = match format {
             Some(f) => f
@@ -860,10 +871,24 @@ impl PyDataFrame {
                 })?,
             None => datafusion::common::format::ExplainFormat::Indent,
         };
+        let analyze_level = analyze_level
+            .map(|l| l.parse::<datafusion::common::format::MetricType>())
+            .transpose()?;
+        let analyze_categories = analyze_categories
+            .map(|cats| {
+                cats.iter()
+                    .map(|c| c.parse::<datafusion::common::format::MetricCategory>())
+                    .collect::<datafusion::common::Result<Vec<_>>>()
+                    .map(datafusion::common::format::ExplainAnalyzeCategories::Only)
+            })
+            .transpose()?;
         let opts = datafusion::logical_expr::ExplainOption::default()
             .with_verbose(verbose)
             .with_analyze(analyze)
-            .with_format(explain_format);
+            .with_format(explain_format)
+            .with_show_statistics(show_statistics)
+            .with_analyze_level(analyze_level)
+            .with_analyze_categories(analyze_categories);
         let df = self.df.as_ref().clone().explain_with_options(opts)?;
         print_dataframe(py, df)
     }
@@ -1320,6 +1345,26 @@ impl PyDataFrame {
         let df = self.df.as_ref().fill_null(&scalar_value.0, &cols)?;
         Ok(Self::new(df))
     }
+
+    /// Fill NaN values with a specified value for specific floating-point columns
+    #[pyo3(signature = (value, columns=None))]
+    fn fill_nan(
+        &self,
+        value: Py<PyAny>,
+        columns: Option<Vec<PyBackedStr>>,
+        py: Python,
+    ) -> PyDataFusionResult<Self> {
+        let scalar_value: PyScalarValue = value.extract(py)?;
+
+        let cols = match columns {
+            Some(col_names) => col_names.iter().map(|c| c.to_string()).collect(),
+            None => Vec::new(), // Empty vector means fill NaN for all columns
+        };
+
+        let cols = cols.iter().map(String::as_str).collect::<Vec<_>>();
+        let df = self.df.as_ref().fill_nan(&scalar_value.0, &cols)?;
+        Ok(Self::new(df))
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]