Struct ScalarFunctionImpl 

pub struct ScalarFunctionImpl {
    pub args: Vec<ArgumentsItem>,
    pub options: Options,
    pub variadic: Option<VariadicBehavior>,
    pub session_dependent: bool,
    pub deterministic: bool,
    pub nullability: NullabilityHandling,
    pub return_type: ConcreteType,
    pub implementation: HashMap<String, String>,
}

Available on crate feature parse only.

A single function implementation (overload) with signature and resolved types

Fields

args: Vec<ArgumentsItem>

Function arguments with types and optional names/descriptions

options: Options

Configurable function options (e.g., overflow behavior, rounding modes)

variadic: Option<VariadicBehavior>

Variadic argument behavior.

None indicates the function is not variadic.

session_dependent: bool

Whether the function output depends on session state (e.g., timezone, locale).

Defaults to false per the Substrait spec.

deterministic: bool

Whether the function is deterministic (same inputs always produce same output).

Defaults to true per the Substrait spec.

nullability: NullabilityHandling

How the function handles null inputs and produces nullable outputs.

Defaults to NullabilityHandling::Mirror per the Substrait spec.

return_type: ConcreteType

Return type resolved to a concrete type

The raw YAML type string is parsed and validated. Only concrete types (without type variables) are supported; functions with type variables are skipped in this basic implementation.

implementation: HashMap<String, String>

Language-specific implementation code (e.g., SQL, C++, Python)

Maps language identifiers to implementation source code snippets.

Trait Implementations

impl Clone for Impl

fn clone(&self) -> Impl

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Impl

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

Formats the value using the given formatter.

impl PartialEq for Impl

fn eq(&self, other: &Impl) -> 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 StructuralPartialEq for Impl