Method invoke_with_args

datafusion/functions/src/datetime/to_date.rs:132–185

(&self, args: ScalarFunctionArgs)

    }

    fn invoke_with_args(&self, args: ScalarFunctionArgs) -> Result<ColumnarValue> {
        let args = args.args;
        if args.is_empty() {
            return exec_err!("to_date function requires 1 or more arguments, got 0");
        }

        // validate that any args after the first one are Utf8
        if args.len() > 1 {
            validate_data_types(&args, "to_date")?;
        }

        match args[0].data_type() {
            Null | Int32 | Int64 | Date32 | Date64 | Timestamp(_, _) => {
                args[0].cast_to(&Date32, None)
            }
            UInt8 | UInt16 | UInt32 | UInt64 | Int8 | Int16 => {
                // Arrow cast doesn't support direct casting of these types to date32
                // as it only supports Int32 and Int64. To work around that limitation,
                // use cast_with_options to cast to Int32 and then cast the result of
                // that to Date32.
                match &args[0] {
                    ColumnarValue::Array(array) => {
                        Ok(ColumnarValue::Array(cast_with_options(
                            &cast_with_options(&array, &Int32, &DEFAULT_CAST_OPTIONS)?,
                            &Date32,
                            &DEFAULT_CAST_OPTIONS,
                        )?))
                    }
                    ColumnarValue::Scalar(scalar) => {
                        let sv =
                            scalar.cast_to_with_options(&Int32, &DEFAULT_CAST_OPTIONS)?;
                        Ok(ColumnarValue::Scalar(
                            sv.cast_to_with_options(&Date32, &DEFAULT_CAST_OPTIONS)?,
                        ))
                    }
                }
            }
            Float16
            | Float32
            | Float64
            | Decimal32(_, _)
            | Decimal64(_, _)
            | Decimal128(_, _)
            | Decimal256(_, _) => {
                // The only way this makes sense is to get the Int64 value of the float
                // or decimal and then cast that to Date32.
                args[0].cast_to(&Int64, None)?.cast_to(&Date32, None)
            }
            Utf8View | LargeUtf8 | Utf8 => self.to_date(&args),
            other => {
                exec_err!("Unsupported data type {} for function to_date", other)
            }
        }
    }

    fn documentation(&self) -> Option<&Documentation> {
        self.doc()