Refactor Spark bitshift signature

[Jefffrey]

Which issue does this PR close?

Part of #12725

Rationale for this change

Prefer to avoid user_defined for consistency in function definitions.

What changes are included in this PR?

Refactor signature of Spark bit shift functions (left, right, right unsigned) to use coercion API instead of being user defined.

Also refactor the bit shift code to have a common base struct.

Move the Rust unit tests to SLTs.

Are these changes tested?

Existing tests.

Are there any user-facing changes?

No.

[Jefffrey]

Rewrote some comments to be more succinct, and also cleanup some function signatures (remove some unused bounds, use type aliases, etc.)

[Jefffrey]

Folded these structs into a single common SparkBitShift struct

[Jefffrey]

Signature here

[Jefffrey]

Moved these all to SLTs

[Jefffrey]

This is to accommodate being able to use a single struct (e.g. SparkBitShift) for multiple different functions; similar to how allow for window functions:

datafusion/datafusion/functions-window/src/macros.rs

Lines 96 to 116 in e661b33

	macro_rules! get_or_init_udwf {
	($UDWF:ident, $OUT_FN_NAME:ident, $DOC:expr) => {
	get_or_init_udwf!($UDWF, $OUT_FN_NAME, $DOC, $UDWF::default);
	};
	($UDWF:ident, $OUT_FN_NAME:ident, $DOC:expr, $CTOR:path) => {
	paste::paste! {
	#[doc = concat!(" Returns a [`WindowUDF`](datafusion_expr::WindowUDF) for [`", stringify!($OUT_FN_NAME), "`].")]
	#[doc = ""]
	#[doc = concat!(" ", $DOC)]
	pub fn [<$OUT_FN_NAME _udwf>]() -> std::sync::Arc<datafusion_expr::WindowUDF> {
	// Singleton instance of UDWF, ensures it is only created once.
	static INSTANCE: std::sync::LazyLock<std::sync::Arc<datafusion_expr::WindowUDF>> =
	std::sync::LazyLock::new(|| {
	std::sync::Arc::new(datafusion_expr::WindowUDF::from($CTOR()))
	});
	std::sync::Arc::clone(&INSTANCE)
	}
	}
	};
	}

I had a bit of difficulty trying to reduce it to something simpler like:

macro_rules! make_udf_function {
    ($UDF:ty, $NAME:ident) => {
        make_udf_function!($UDF, $NAME, $UDF::new); // Error on :: token
    };
    ($UDF:ty, $NAME:ident, $CTOR:path) => {
        #[allow(rustdoc::redundant_explicit_links)]
        #[doc = concat!("Return a [`ScalarUDF`](datafusion_expr::ScalarUDF) implementation of ", stringify!($NAME))]
        pub fn $NAME() -> std::sync::Arc<datafusion_expr::ScalarUDF> {
            // Singleton instance of the function
            static INSTANCE: std::sync::LazyLock<
                std::sync::Arc<datafusion_expr::ScalarUDF>,
            > = std::sync::LazyLock::new(|| {
                std::sync::Arc::new(datafusion_expr::ScalarUDF::new_from_impl(
                    $CTOR(),
                ))
            });
            std::sync::Arc::clone(&INSTANCE)
        }
    };
}

To reduce duplication. For now just kept this minor duplication of the arms.

[comphead]

Thanks @Jefffrey

[martin-g]

Suggested change

	ArrowNativeType, DataType, Int32Type, Int64Type, UInt32Type, UInt64Type,
	DataType, Int32Type, Int64Type, UInt32Type, UInt64Type,

[Jefffrey]

The trait is still needed for calling get_byte_width in the shift functions

    let bit_num = (T::Native::get_byte_width() * 8) as i32;

[martin-g]

Why always Int32Array ?
If shift_array.data_type().is_null() then I think you need to use the type returned by value_array.data_type(), which could be Int64 for example.
If value_array.data_type().is_null() then fallback to Int32Array

[Jefffrey]

That's a good point, I'll fix it

[Jefffrey]

I removed the explicit null handling as it seems coercion will coerce to int types for us; added tests to confirm this

768a657