Enum mz_sql::func::ParamType

pub enum ParamType {
    Any,
    AnyCompatible,
    AnyElement,
    ArrayAny,
    ArrayAnyCompatible,
    ListAny,
    ListAnyCompatible,
    ListElementAnyCompatible,
    MapAny,
    MapAnyCompatible,
    NonVecAny,
    NonVecAnyCompatible,
    Plain(ScalarType),
    RecordAny,
    RangeAny,
    RangeAnyCompatible,
    Internal,
}

Describes parameter types.

Parameters with “Compatible” in their name are used in conjunction with other “Compatible”-type parameters to determine the best common type to cast arguments to.

“Compatible” parameters contrast with parameters that contain “Any” in their name, but not “Compatible.” These parameters require all other “Any”-type parameters be of the same type from the perspective of ScalarType::base_eq.

For more details on polymorphic parameter resolution, see PolymorphicSolution.

Variants

Any

A pseudotype permitting any type. Note that this parameter does not enforce the same “Any” constraint as the other “Any”-type parameters.

AnyCompatible

A pseudotype permitting any type, permitting other “Compatibility”-type parameters to find the best common type.

AnyElement

An pseudotype permitting any type, requiring other “Any”-type parameters to be of the same type.

ArrayAny

An pseudotype permitting any array type, requiring other “Any”-type parameters to be of the same type.

ArrayAnyCompatible

A pseudotype permitting any array type, permitting other “Compatibility”-type parameters to find the best common type.

ListAny

An pseudotype permitting any list type, requiring other “Any”-type parameters to be of the same type.

ListAnyCompatible

A pseudotype permitting any list type, permitting other “Compatibility”-type parameters to find the best common type.

ListElementAnyCompatible

A pseudotype permitting any type, permitting other “Compatibility”-type parameters to find the best common type. Additionally, enforces a constraint that when used with ListAnyCompatible, resolves to that argument’s element type.

MapAny

An pseudotype permitting any map type, requiring other “Any”-type parameters to be of the same type.

MapAnyCompatible

A pseudotype permitting any map type, permitting other “Compatibility”-type parameters to find the best common type.

NonVecAny

A pseudotype permitting any type except ScalarType::List and ScalarType::Array, requiring other “Any”-type parameters to be of the same type.

NonVecAnyCompatible

A pseudotype permitting any type except ScalarType::List and ScalarType::Array, requiring other “Compatibility”-type parameters to be of the same type.

Plain(ScalarType)

A standard parameter that accepts arguments that match its embedded ScalarType.

RecordAny

A polymorphic pseudotype permitting a ScalarType::Record of any type, but all records must be structurally equal.

RangeAny

An pseudotype permitting any range type, requiring other “Any”-type parameters to be of the same type.

RangeAnyCompatible

A pseudotype permitting any range type, permitting other “Compatibility”-type parameters to find the best common type.

Prefer using ParamType::RangeAny over this type; it is easy to fool this type into generating non-existent range types (e.g. ranges of floats) that will panic.

Internal

A psuedotype indicating that the function is only meant to be called internally by the database system.

Implementations

impl ParamType

fn accepts_type(&self, ecx: &ExprContext<'_>, t: &ScalarType) -> bool

Does self accept arguments of type t?

fn is_preferred_by(&self, t: &ScalarType) -> bool

Does t’s TypeCategory prefer self? This question can make more sense with the understanding that pseudotypes are never preferred.

fn is_near_match(&self, t: &ScalarType) -> bool

Is self the ParamType corresponding to t’s near match value?

fn prefers_self(&self) -> bool

Is self the preferred parameter type for its TypeCategory?

fn is_polymorphic(&self) -> bool

fn name(&self) -> &'static str

Trait Implementations

impl Clone for ParamType

fn clone(&self) -> ParamType

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ParamType

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<ParamType> for ReturnType

fn from(typ: ParamType) -> ReturnType

Converts to this type from the input type.

impl From<ScalarBaseType> for ParamType

fn from(s: ScalarBaseType) -> ParamType

Converts to this type from the input type.

impl From<ScalarType> for ParamType

fn from(s: ScalarType) -> ParamType

Converts to this type from the input type.

impl Hash for ParamType

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq<ParamType> for ScalarType

fn eq(&self, other: &ParamType) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<ScalarType> for ParamType

fn eq(&self, other: &ScalarType) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq for ParamType

fn eq(&self, other: &ParamType) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl TryFrom<&ParamType> for PolymorphicCompatClass

type Error = ()

The type returned in the event of a conversion error.

fn try_from(param: &ParamType) -> Result<PolymorphicCompatClass, Self::Error>

Performs the conversion.

impl Eq for ParamType

impl StructuralPartialEq for ParamType