Enum OperatorOption 

pub enum OperatorOption<'a> {
    Function {
        function_span: Span,
        eq_span: Span,
        function_name: QualifiedName<'a>,
    },
    Procedure {
        procedure_span: Span,
        eq_span: Span,
        procedure_name: QualifiedName<'a>,
    },
    LeftArg {
        leftarg_span: Span,
        eq_span: Span,
        arg_type: DataType<'a>,
    },
    RightArg {
        rightarg_span: Span,
        eq_span: Span,
        arg_type: DataType<'a>,
    },
    Commutator {
        commutator_span: Span,
        eq_span: Span,
        operator: OperatorRef<'a>,
    },
    Negator {
        negator_span: Span,
        eq_span: Span,
        operator: OperatorRef<'a>,
    },
    Restrict {
        restrict_span: Span,
        eq_span: Span,
        function_name: QualifiedName<'a>,
    },
    RestrictNone {
        restrict_span: Span,
        eq_span: Span,
        none_span: Span,
    },
    Join {
        join_span: Span,
        eq_span: Span,
        function_name: QualifiedName<'a>,
    },
    JoinNone {
        join_span: Span,
        eq_span: Span,
        none_span: Span,
    },
    Hashes(Span),
    Merges(Span),
}

Options for CREATE OPERATOR

Variants

Function

FUNCTION = function_name

Fields

function_span: Span

Span of FUNCTION keyword

eq_span: Span

Span of equal sign

function_name: QualifiedName<'a>

The function name that implements the operator

Procedure

PROCEDURE = procedure_name (synonym for FUNCTION)

Fields

procedure_span: Span

Span of PROCEDURE keyword

eq_span: Span

Span of equal sign

procedure_name: QualifiedName<'a>

The procedure name that implements the operator

LeftArg

LEFTARG = type

Fields

leftarg_span: Span

Span of LEFTARG keyword

eq_span: Span

Span of equal sign

arg_type: DataType<'a>

The data type of the left argument (or NONE)

RightArg

RIGHTARG = type

Fields

rightarg_span: Span

Span of RIGHTARG keyword

eq_span: Span

Span of equal sign

arg_type: DataType<'a>

The data type of the right argument (or NONE)

Commutator

COMMUTATOR = operator or COMMUTATOR = OPERATOR(operator)

Fields

commutator_span: Span

Span of COMMUTATOR keyword

eq_span: Span

Span of equal sign

operator: OperatorRef<'a>

The commutator operator (the operator that gives the same result when left and right arguments are swapped)

Negator

NEGATOR = operator or NEGATOR = OPERATOR(operator)

Fields

negator_span: Span

Span of NEGATOR keyword

eq_span: Span

Span of equal sign

operator: OperatorRef<'a>

The negator operator (the operator that gives the negated result of the original operator)

Restrict

RESTRICT = function

Fields

restrict_span: Span

Span of RESTRICT keyword

eq_span: Span

Span of equal sign

function_name: QualifiedName<'a>

The function name that implements the selectivity estimator for the operator

RestrictNone

RESTRICT = NONE

Fields

restrict_span: Span

Span of RESTRICT keyword

eq_span: Span

Span of equal sign

none_span: Span

Span of NONE keyword

Join

JOIN = function

Fields

join_span: Span

Span of JOIN keyword

eq_span: Span

Span of equal sign

function_name: QualifiedName<'a>

The function name that implements the join selectivity estimator for the operator

JoinNone

JOIN = NONE

Fields

join_span: Span

Span of JOIN keyword

eq_span: Span

Span of equal sign

none_span: Span

Span of NONE keyword

Hashes(Span)

HASHES

Merges(Span)

MERGES

Trait Implementations

impl<'a> Clone for OperatorOption<'a>

fn clone(&self) -> OperatorOption<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for OperatorOption<'a>

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

Formats the value using the given formatter.

impl<'a> Spanned for OperatorOption<'a>

fn span(&self) -> Span

Compute byte span of an ast fragment

fn join_span(&self, other: &impl OptSpanned) -> Span

Compute the minimal span containing both self and other