Struct FunctionCall 

pub struct FunctionCall {
    pub(super) func_type: ExprType,
    pub(super) return_type: DataType,
    pub(super) inputs: Vec<ExprImpl>,
}

Fields

func_type: ExprType

return_type: DataType

inputs: Vec<ExprImpl>

Implementations

impl FunctionCall

pub fn new(func_type: ExprType, inputs: Vec<ExprImpl>) -> RwResult<Self>

Create a FunctionCall expr with the return type inferred from func_type and types of inputs.

pub fn cast_mut( child: &mut ExprImpl, target: &DataType, allows: CastContext, ) -> Result<(), CastError>

Create a cast expr over child to target type in allows context. The input child remains unchanged when this returns an error.

fn cast_row_expr( func: &mut FunctionCall, target_type: &DataType, allows: CastContext, ) -> Result<(), CastError>

Cast a ROW expression to the target type. We intentionally disallow casting arbitrary expressions, like ROW(1)::STRUCT<i INTEGER> to STRUCT<VARCHAR>, although an integer is castable to VARCHAR. It’s to simply the casting rules.

pub fn new_unchecked( func_type: ExprType, inputs: Vec<ExprImpl>, return_type: DataType, ) -> Self

Construct a FunctionCall expr directly with the provided return_type, bypassing type inference. Use with caution.

pub fn new_binary_op_func( func_types: Vec<ExprType>, inputs: Vec<ExprImpl>, ) -> RwResult<ExprImpl>

pub fn decompose(self) -> (ExprType, Vec<ExprImpl>, DataType)

pub fn decompose_as_binary(self) -> (ExprType, ExprImpl, ExprImpl)

pub fn decompose_as_unary(self) -> (ExprType, ExprImpl)

pub fn func_type(&self) -> ExprType

pub fn inputs(&self) -> &[ExprImpl]

Get a reference to the function call’s inputs.

pub fn inputs_mut(&mut self) -> &mut [ExprImpl]

pub(super) fn from_expr_proto( function_call: &FunctionCall, func_type: ExprType, return_type: DataType, ) -> RwResult<Self>

pub fn is_pure(&self) -> bool

Trait Implementations

impl Clone for FunctionCall

fn clone(&self) -> FunctionCall

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FunctionCall

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

Formats the value using the given formatter.

impl Expr for FunctionCall

fn return_type(&self) -> DataType

Get the return type of the expr

fn try_to_expr_proto(&self) -> Result<ExprNode, String>

Try to serialize the expression, returning an error if it’s impossible.

fn to_expr_proto(&self) -> ExprNode

Serialize the expression. Panic if it’s impossible.

impl From<FunctionCall> for ExprImpl

fn from(o: FunctionCall) -> ExprImpl

Converts to this type from the input type.

impl Hash for FunctionCall

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 for FunctionCall

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

impl StructuralPartialEq for FunctionCall