Enum TableFunc

pub enum TableFunc {
    AclExplode,
    MzAclExplode,
    JsonbEach {
        stringify: bool,
    },
    JsonbObjectKeys,
    JsonbArrayElements {
        stringify: bool,
    },
    RegexpExtract(AnalyzedRegex),
    CsvExtract(usize),
    GenerateSeriesInt32,
    GenerateSeriesInt64,
    GenerateSeriesTimestamp,
    GenerateSeriesTimestampTz,
    GuardSubquerySize {
        column_type: ScalarType,
    },
    Repeat,
    UnnestArray {
        el_typ: ScalarType,
    },
    UnnestList {
        el_typ: ScalarType,
    },
    UnnestMap {
        value_type: ScalarType,
    },
    Wrap {
        types: Vec<ColumnType>,
        width: usize,
    },
    GenerateSubscriptsArray,
    TabletizedScalar {
        name: String,
        relation: RelationType,
    },
    RegexpMatches,
    WithOrdinality(WithOrdinality),
}

When adding a new TableFunc variant, please consider adding it to TableFunc::with_ordinality!

Variants

AclExplode

MzAclExplode

JsonbEach

Fields

stringify: bool

JsonbObjectKeys

JsonbArrayElements

Fields

stringify: bool

RegexpExtract(AnalyzedRegex)

CsvExtract(usize)

GenerateSeriesInt32

GenerateSeriesInt64

GenerateSeriesTimestamp

GenerateSeriesTimestampTz

GuardSubquerySize

Supplied with an input count,

1. Adds a column as if a typed subquery result,
2. Filters the row away if the count is only one,
3. Errors if the count is not exactly one. The intent is that this presents as if a subquery result with too many records contributing. The error column has the same type as the result should have, but we only produce it if the count exceeds one.

This logic could nearly be achieved with map, filter, project logic, but has been challenging to do in a way that respects the vagaries of SQL and our semantics. If we reveal a constant value in the column we risk the optimizer pruning the branch; if we reveal that this will not produce rows we risk the optimizer pruning the branch; if we reveal that the only possible value is an error we risk the optimizer propagating that error without guards.

Before replacing this by an MirScalarExpr, quadruple check that it would not result in misoptimizations due to expression evaluation order being utterly undefined, and predicate pushdown trimming any fragments that might produce columns that will not be needed.

Fields

column_type: ScalarType

Repeat

UnnestArray

Fields

el_typ: ScalarType

UnnestList

Fields

el_typ: ScalarType

UnnestMap

Fields

value_type: ScalarType

Wrap

Given n input expressions, wraps them into n / width rows, each of width columns.

This function is not intended to be called directly by end users, but is useful in the planning of e.g. VALUES clauses.

Fields

types: Vec<ColumnType>

width: usize

GenerateSubscriptsArray

TabletizedScalar

Execute some arbitrary scalar function as a table function.

Fields

name: String

relation: RelationType

RegexpMatches

WithOrdinality(WithOrdinality)

Implements the WITH ORDINALITY clause.

Don’t construct TableFunc::WithOrdinality manually! Use the with_ordinality constructor function instead, which checks whether the given table function supports WithOrdinality.

Implementations

impl TableFunc

pub fn with_ordinality(inner: TableFunc) -> Option<TableFunc>

Adds WITH ORDINALITY to a table function if it’s allowed on the given table function.

impl TableFunc

pub fn eval<'a>( &'a self, datums: &'a [Datum<'a>], temp_storage: &'a RowArena, ) -> Result<Box<dyn Iterator<Item = (Row, Diff)> + 'a>, EvalError>

Executes self on the given input row (datums).

pub fn output_type(&self) -> RelationType

pub fn output_arity(&self) -> usize

pub fn empty_on_null_input(&self) -> bool

pub fn preserves_monotonicity(&self) -> bool

True iff the table function preserves the append-only property of its input.

Trait Implementations

impl Arbitrary for TableFunc

Manual Arbitrary, because proptest-derive is choking on the recursive WithOrdinality variant.

type Parameters = ()

The type of parameters that arbitrary_with accepts for configuration of the generated Strategy. Parameters must implement Default.

type Strategy = BoxedStrategy<TableFunc>

The type of Strategy used to generate values of type Self.

fn arbitrary_with(_: Self::Parameters) -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self). The strategy is passed the arguments given in args.

fn arbitrary() -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self).

impl Clone for TableFunc

fn clone(&self) -> TableFunc

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TableFunc

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TableFunc

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for TableFunc

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

Formats the value using the given formatter.

impl Hash for TableFunc

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 MzReflect for TableFunc

fn add_to_reflected_type_info(rti: &mut ReflectedTypeInfo)

Adds names and types of the fields of the struct or enum to rti.

impl Ord for TableFunc

fn cmp(&self, other: &TableFunc) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for TableFunc

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

fn partial_cmp(&self, other: &TableFunc) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl RustType<ProtoTableFunc> for TableFunc

fn into_proto(&self) -> ProtoTableFunc

Convert a Self into a Proto value.

fn from_proto(proto: ProtoTableFunc) -> Result<Self, TryFromProtoError>

Consume and convert a Proto back into a Self value.

fn into_proto_owned(self) -> Proto

A zero clone version of Self::into_proto that types can optionally implement, otherwise, the default implementation delegates to Self::into_proto.

impl Serialize for TableFunc

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for TableFunc

impl StructuralPartialEq for TableFunc