refactor: modify py_obj_to_scalar_value to return ScalarValue directly and streamline error handling

Author: kosiew

src/dataframe.rs

@@ -720,7 +720,7 @@ impl PyDataFrame {
         columns: Option<Vec<PyBackedStr>>,
         py: Python,
     ) -> PyDataFusionResult<Self> {
-        let scalar_value = py_obj_to_scalar_value(py, value)?;
+        let scalar_value = py_obj_to_scalar_value(py, value);
 
         let cols = match columns {
             Some(col_names) => col_names.iter().map(|c| c.to_string()).collect(),

src/utils.rs

@@ -101,30 +101,30 @@ pub(crate) fn validate_pycapsule(capsule: &Bound<PyCapsule>, name: &str) -> PyRe
 ///
 /// This function handles basic Python types directly and uses PyArrow
 /// for complex types like datetime.
-pub(crate) fn py_obj_to_scalar_value(py: Python, obj: PyObject) -> PyResult<ScalarValue> {
-    // Try basic types first for efficiency
+pub(crate) fn py_obj_to_scalar_value(py: Python, obj: PyObject) -> ScalarValue {
     if let Ok(value) = obj.extract::<bool>(py) {
-        return Ok(ScalarValue::Boolean(Some(value)));
+        ScalarValue::Boolean(Some(value))
     } else if let Ok(value) = obj.extract::<i64>(py) {
-        return Ok(ScalarValue::Int64(Some(value)));
+        ScalarValue::Int64(Some(value))
     } else if let Ok(value) = obj.extract::<u64>(py) {
-        return Ok(ScalarValue::UInt64(Some(value)));
+        ScalarValue::UInt64(Some(value))
     } else if let Ok(value) = obj.extract::<f64>(py) {
-        return Ok(ScalarValue::Float64(Some(value)));
+        ScalarValue::Float64(Some(value))
     } else if let Ok(value) = obj.extract::<String>(py) {
-        return Ok(ScalarValue::Utf8(Some(value)));
+        ScalarValue::Utf8(Some(value))
+    } else {
+        // For datetime and other complex types, convert via PyArrow
+        let pa = py.import("pyarrow");
+        let pa = pa.expect("Failed to import PyArrow");
+        // Convert Python object to PyArrow scalar
+        // This handles datetime objects by converting to PyArrow timestamp type
+        let scalar = pa.call_method1("scalar", (obj,));
+        let scalar = scalar.expect("Failed to convert Python object to PyArrow scalar");
+        // Convert PyArrow scalar to PyScalarValue
+        let py_scalar = PyScalarValue::extract_bound(scalar.as_ref());
+        // Unwrap the result - this will panic if extraction failed
+        let py_scalar = py_scalar.expect("Failed to extract PyScalarValue from PyArrow scalar");
+        // Convert PyScalarValue to ScalarValue
+        py_scalar.into()
     }
-
-    // For datetime and other complex types, convert via PyArrow
-    let pa = py.import("pyarrow")?;
-
-    // Convert Python object to PyArrow scalar
-    // This handles datetime objects by converting to PyArrow timestamp type
-    let scalar = pa.call_method1("scalar", (obj,))?;
-
-    // Convert PyArrow scalar to PyScalarValue
-    let py_scalar = PyScalarValue::extract_bound(scalar.as_ref())?;
-
-    // Convert PyScalarValue to ScalarValue
-    Ok(py_scalar.into())
 }