Datafusion expand scalarvalue catchall

dask_planner/src/expression.rs

@@ -403,6 +403,7 @@ impl PyExpr {
                 ScalarValue::Float32(_value) => Ok(String::from("Float32")),
                 ScalarValue::Float64(_value) => Ok(String::from("Float64")),
                 ScalarValue::Decimal128(_value, ..) => Ok(String::from("Decimal128")),
+                ScalarValue::Dictionary(..) => Ok(String::from("Dictionary")),
                 ScalarValue::Int8(_value) => Ok(String::from("Int8")),
                 ScalarValue::Int16(_value) => Ok(String::from("Int16")),
                 ScalarValue::Int32(_value) => Ok(String::from("Int32")),
@@ -418,9 +419,15 @@ impl PyExpr {
                 ScalarValue::Date32(_value) => Ok(String::from("Date32")),
                 ScalarValue::Date64(_value) => Ok(String::from("Date64")),
                 ScalarValue::Null => Ok(String::from("Null")),
-                _ => {
-                    panic!("CatchAll")
-                }
+                ScalarValue::TimestampSecond(..) => Ok(String::from("TimestampSecond")),
+                ScalarValue::TimestampMillisecond(..) => Ok(String::from("TimestampMillisecond")),
+                ScalarValue::TimestampMicrosecond(..) => Ok(String::from("TimestampMicrosecond")),
+                ScalarValue::TimestampNanosecond(..) => Ok(String::from("TimestampNanosecond")),
+                ScalarValue::IntervalYearMonth(..) => Ok(String::from("IntervalYearMonth")),
+                ScalarValue::IntervalDayTime(..) => Ok(String::from("IntervalDayTime")),
+                ScalarValue::IntervalMonthDayNano(..) => Ok(String::from("IntervalMonthDayNano")),
+                ScalarValue::List(..) => Ok(String::from("List")),
+                ScalarValue::Struct(..) => Ok(String::from("Struct")),
             },
             Expr::ScalarFunction { fun, args: _ } => match fun {
                 BuiltinScalarFunction::Abs => Ok(String::from("Abs")),
@@ -628,6 +635,19 @@ impl PyExpr {
         }
     }
 
+    #[pyo3(name = "getIntervalDayTimeValue")]
+    pub fn interval_day_time_value(&mut self) -> i64 {
+        match &self.expr {
+            Expr::Literal(scalar_value) => match scalar_value {
+                ScalarValue::IntervalDayTime(iv) => iv.clone().unwrap(),
+                _ => {
+                    panic!("getValue<T>() - Unexpected value")
+                }
+            },
+            _ => panic!("getValue<T>() - Non literal value encountered"),
+        }
+    }
+
     #[pyo3(name = "isNegated")]
     pub fn is_negated(&self) -> PyResult<bool> {
         match &self.expr {

dask_sql/physical/rex/core/literal.py

@@ -145,8 +145,13 @@ def convert(
         elif literal_type == "Null":
             literal_type = SqlTypeName.NULL
             literal_value = None
+        elif literal_type == "IntervalDayTime":
+            literal_type = SqlTypeName.INTERVAL
+            literal_value = rex.getIntervalDayTimeValue()
         else:
-            raise RuntimeError("Failed to determine DataFusion Type in literal.py")
+            raise RuntimeError(
+                f"Failed to map literal type {literal_type} to python type in literal.py"
+            )
 
         # if isinstance(literal_value, org.apache.calcite.util.Sarg):
         #     return SargPythonImplementation(literal_value, literal_type)