Refactor range/gen_series signature away from user defined

datafusion/common/src/types/builtin.rs

@@ -15,9 +15,17 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use arrow::datatypes::IntervalUnit::*;
+
 use crate::types::{LogicalTypeRef, NativeType};
 use std::sync::{Arc, LazyLock};
 
+/// Create a singleton and accompanying static variable for a [`LogicalTypeRef`]
+/// of a [`NativeType`].
+/// * `name`: name of the static variable, must be unique.
+/// * `getter`: name of the public function that will return the singleton instance
+///   of the static variable.
+/// * `ty`: the [`NativeType`].
 macro_rules! singleton {
     ($name:ident, $getter:ident, $ty:ident) => {
         static $name: LazyLock<LogicalTypeRef> =
@@ -31,6 +39,26 @@ macro_rules! singleton {
     };
 }
 
+/// Similar to [`singleton`], but for native types that have variants, such as
+/// `NativeType::Interval(MonthDayNano)`.
+/// * `name`: name of the static variable, must be unique.
+/// * `getter`: name of the public function that will return the singleton instance
+///   of the static variable.
+/// * `ty`: the [`NativeType`].
+/// * `variant`: specific variant of the `ty`.
+macro_rules! singleton_variant {
+    ($name:ident, $getter:ident, $ty:ident, $variant:ident) => {
+        static $name: LazyLock<LogicalTypeRef> =
+            LazyLock::new(|| Arc::new(NativeType::$ty($variant)));
+
+        #[doc = "Getter for singleton instance of a logical type representing"]
+        #[doc = concat!("[`NativeType::", stringify!($ty), "`] of unit [`", stringify!($variant),"`].`")]
+        pub fn $getter() -> LogicalTypeRef {
+            Arc::clone(&$name)
+        }
+    };
+}
+
 singleton!(LOGICAL_NULL, logical_null, Null);
 singleton!(LOGICAL_BOOLEAN, logical_boolean, Boolean);
 singleton!(LOGICAL_INT8, logical_int8, Int8);
@@ -47,3 +75,10 @@ singleton!(LOGICAL_FLOAT64, logical_float64, Float64);
 singleton!(LOGICAL_DATE, logical_date, Date);
 singleton!(LOGICAL_BINARY, logical_binary, Binary);
 singleton!(LOGICAL_STRING, logical_string, String);
+
+singleton_variant!(
+    LOGICAL_INTERVAL_MDN,
+    logical_interval_mdn,
+    Interval,
+    MonthDayNano
+);

datafusion/common/src/types/native.rs

@@ -486,4 +486,9 @@ impl NativeType {
     pub fn is_binary(&self) -> bool {
         matches!(self, NativeType::Binary | NativeType::FixedSizeBinary(_))
     }
+
+    #[inline]
+    pub fn is_null(&self) -> bool {
+        matches!(self, NativeType::Null)
+    }
 }

datafusion/expr-common/src/signature.rs

@@ -382,10 +382,7 @@ impl TypeSignatureClass {
     }
 
     /// Does the specified `NativeType` match this type signature class?
-    pub fn matches_native_type(
-        self: &TypeSignatureClass,
-        logical_type: &NativeType,
-    ) -> bool {
+    pub fn matches_native_type(&self, logical_type: &NativeType) -> bool {
         if logical_type == &NativeType::Null {
             return true;
         }
@@ -431,6 +428,7 @@ impl TypeSignatureClass {
             TypeSignatureClass::Binary if native_type.is_binary() => {
                 Ok(origin_type.to_owned())
             }
+            _ if native_type.is_null() => Ok(origin_type.to_owned()),
             _ => internal_err!("May miss the matching logic in `matches_native_type`"),
         }
     }