functions: filter index lambda, reverse of arrays, sequence over dates and timestamps, to_char of binary, schema_of_xml options (SQL-4, SQL-5, SQL-6)

changelog.d/767.compat.md

@@ -0,0 +1 @@
+`filter` takes the element index (`(x, i) -> ...`), `reverse` works on arrays, `sequence` works over dates and timestamps with year-month, day-time and calendar steps, `to_char` and `to_varchar` accept binary values (`hex`, `base64`, `utf-8`), and `schema_of_xml` honours `excludeAttribute`, `ignoreNamespace` and `prefersDecimal` and merges repeated elements the way Spark does (SQL-4, SQL-5, SQL-6).

crates/krishiv-exec/src/planner/eval/hof.rs

@@ -14,7 +14,7 @@
 //!
 //! For a batch of `rows` rows whose lists hold `total` elements, the
 //! flattened batch has `total` rows: the lambda's element columns are the
-//! lists' child values, its index column (two-variable `transform`) counts
+//! lists' child values, its index column (two-variable `transform` or `filter`) counts
 //! positions within each list, and every captured outer column repeats its
 //! row's value per element (through the lists' offsets). A vectorized body
 //! runs once over that batch — never one evaluation per element — and the
@@ -454,7 +454,7 @@ fn compile_unary(name: &str, f: &ResolvedFunction, input: Input<'_>) -> Result<A
     let ArrowType::List(field) = array.data_type().clone() else {
         return Err(internal("a higher-order call over a non-list"));
     };
-    let index = name == "transform" && params.len() == 2;
+    let index = matches!(name, "transform" | "filter") && params.len() == 2;
     let mut refs = Refs::default();
     collect(
         body,

crates/krishiv-functions/src/registry/array_shape.rs

@@ -12,7 +12,7 @@
 
 use krishiv_common::error::{
     DatatypeMismatchSequenceWrongInputTypes, DatatypeMismatchUnexpectedInputType, KrishivError,
-    KrishivUnsupportedFeature, WrongNumArgsWithoutSuggestion,
+    WrongNumArgsWithoutSuggestion,
 };
 use krishiv_types::{ArrayType, DataType};
 
@@ -128,8 +128,49 @@ fn sequence_type(c: &CallTypes<'_>) -> Option<DataType> {
     })
 }
 
+/// The result element type of `sequence(start, stop[, step])` over temporal bounds (Spark 4.2.0): `DATE` for two dates, else a timestamp
+/// (`TIMESTAMP_NTZ` only when no bound is a plain `TIMESTAMP`; a `DATE` beside either takes its type). `None` unless some bound is
+/// temporal and none is anything else.
+fn temporal_sequence_type(c: &CallTypes<'_>) -> Option<DataType> {
+    if c.args().len() < 2 {
+        return None;
+    }
+    let is_time = |t: &DataType| {
+        matches!(
+            t,
+            DataType::Date | DataType::Timestamp | DataType::TimestampNtz
+        )
+    };
+    let bounds: Vec<Option<&DataType>> = (0..2).map(|i| c.data_type(i)).collect();
+    // An untyped NULL bound, or (under ANSI) a string, is cast to the other bound's type; at least one bound is a date or timestamp.
+    let castable = |t: &Option<&DataType>| match t {
+        None => true,
+        Some(DataType::String) => c.ansi(),
+        Some(t) => is_time(t),
+    };
+    if !bounds.iter().any(|t| t.is_some_and(is_time)) || !bounds.iter().all(castable) {
+        return None;
+    }
+    let has = |want: &DataType| bounds.contains(&Some(want));
+    Some(if has(&DataType::Timestamp) {
+        DataType::Timestamp
+    } else if has(&DataType::TimestampNtz) {
+        DataType::TimestampNtz
+    } else {
+        DataType::Date
+    })
+}
+
 /// `sequence`'s inputs: every argument is cast to the widest integral type.
 fn sequence_inputs(c: &CallTypes<'_>) -> Vec<InputType> {
+    if let Some(t) = temporal_sequence_type(c) {
+        // The bounds are cast to the common temporal type; the step keeps its own (checked in the result rule).
+        let mut v = vec![InputType::Exact(t.clone()), InputType::Exact(t)];
+        if c.args().len() > 2 {
+            v.push(InputType::Any);
+        }
+        return v;
+    }
     match sequence_type(c) {
         Some(t) => vec![InputType::Exact(t); c.args().len()],
         None => vec![InputType::Any; c.args().len()],
@@ -155,17 +196,34 @@ fn sequence(c: &CallTypes<'_>) -> Result<ArgType, KrishivError> {
             c.any_nullable(),
         ));
     }
-    let temporal = |t: Option<&DataType>| {
-        matches!(
-            t,
-            Some(DataType::Date | DataType::Timestamp | DataType::TimestampNtz)
-        )
-    };
-    if temporal(c.data_type(0)) || temporal(c.data_type(1)) {
-        return Err(KrishivUnsupportedFeature {
-            feature: "sequence over dates or timestamps".to_owned(),
+    if let Some(t) = temporal_sequence_type(c) {
+        // The step is a calendar, year-month or day-time interval; anything else (an integral, a string, an untyped NULL) is a type error.
+        let interval = |i: usize| {
+            matches!(
+                c.data_type(i),
+                Some(
+                    DataType::CalendarInterval
+                        | DataType::YearMonthInterval { .. }
+                        | DataType::DayTimeInterval { .. }
+                )
+            )
+        };
+        if n == 3 && !interval(2) {
+            return Err(DatatypeMismatchSequenceWrongInputTypes {
+                sql_expr: call_sql("sequence", c),
+                function_name: "`sequence`".to_owned(),
+                start_type: "(\"TIMESTAMP\" or \"TIMESTAMP_NTZ\" or \"DATE\")".to_owned(),
+                step_type:
+                    "(\"INTERVAL\" or \"INTERVAL YEAR TO MONTH\" or \"INTERVAL DAY TO SECOND\")"
+                        .to_owned(),
+                other_start_type: "\"INTEGRAL\"".to_owned(),
+            }
+            .into());
         }
-        .into());
+        return Ok(ArgType::new(
+            DataType::Array(ArrayType::new(t, false).into()),
+            c.any_nullable(),
+        ));
     }
     Err(DatatypeMismatchSequenceWrongInputTypes {
         sql_expr: call_sql("sequence", c),

crates/krishiv-functions/src/registry/number.rs

@@ -20,7 +20,7 @@ use std::sync::Arc;
 
 use krishiv_common::error::{
     DatatypeMismatchNonFoldableInput, DatatypeMismatchUnexpectedInputType,
-    InvalidParameterValueBinaryFormat, KrishivError,
+    InvalidParameterValueBinaryFormat, InvalidParameterValueNull, KrishivError,
 };
 use krishiv_kernels::cast::{CastMode, CastOptions, TimeZoneRules, cast};
 use krishiv_kernels::number_format::parse_format;
@@ -508,6 +508,14 @@ fn to_char_result(c: &CallTypes<'_>) -> Result<ArgType, KrishivError> {
     // Binaries take `base64`/`hex`/`utf-8` (matched lower-cased, like
     // Spark's `toLowerCase.trim`).
     if matches!(c.data_type(0), Some(DataType::Binary)) {
+        // Spark's `ToCharacterBuilder` refuses a NULL format for a binary.
+        if matches!(c.constant(1), Some(Constant::Null)) {
+            return Err(InvalidParameterValueNull {
+                parameter: "`format`".to_owned(),
+                function_name: "`to_char`".to_owned(),
+            }
+            .into());
+        }
         if let Some(pattern) = format.as_deref()
             && !matches!(
                 pattern.to_lowercase().trim_matches(|c: char| c <= ' '),

crates/krishiv-functions/src/registry/tests/text.rs

@@ -268,3 +268,16 @@ fn argument_casts_follow_spark() {
         InputType::Any
     );
 }
+
+#[test]
+fn to_char_of_a_binary_refuses_a_null_format() {
+    let args = [ty(DataType::Binary), ty(DataType::String)];
+    for name in ["to_char", "to_varchar"] {
+        let err = result(name, &args, &[None, Some(Constant::Null)]).unwrap_err();
+        assert_eq!(
+            err.error_class(),
+            ErrorClass::InvalidParameterValueNull,
+            "{name}"
+        );
+    }
+}

crates/krishiv-functions/src/registry/text.rs

@@ -226,9 +226,16 @@ pub(super) fn specs() -> Vec<Spec> {
         &Inputs::Expects(vec![InputType::Strict(DataType::String)]),
         string,
     ));
+    // `reverse` takes a string, a binary or an array (Spark's `TypeCollection(StringType, ArrayType)`): an array keeps its type.
     out.extend(scalar(
         &["reverse"],
-        &Inputs::Expects(vec![text_or_bytes.clone()]),
+        &Inputs::Built(InputBuilder(|c: &CallTypes<'_>| {
+            if matches!(c.data_type(0), Some(DataType::Array(_))) {
+                vec![InputType::Array]
+            } else {
+                vec![InputType::OneOf(vec![DataType::String, DataType::Binary])]
+            }
+        })),
         first_type,
     ));
     out.extend(scalar(&["quote"], &one_text, nullable_string));