Struct FlattenRequest 

#[non_exhaustive]
pub struct FlattenRequest<'a> {
    pub source_relation: &'a str,
    pub source_alias: &'a str,
    pub array_column: &'a str,
    pub array_type: &'a DataType,
    pub element_alias: &'a str,
    pub ordinal_alias: &'a str,
    pub fields: &'a [FlattenField<'a>],
}

What Razeri is asking to have flattened.

Every name here is spelled the way it already appears in the statement being composed — qualified where the statement qualifies it, quoted where the statement quotes it. An implementation interpolates them as they are rather than re-spelling them, because the answer has to name the same relation the rest of the statement names.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

source_relation: &'a str

The relation being read, qualified, as the statement’s FROM spells it.

source_alias: &'a str

The alias the recompute gave that relation.

array_column: &'a str

The array column, qualified by the source alias.

array_type: &'a DataType

What the column was declared to hold. An array of records and an array of scalars are both flattened; on engines that fold either to a document type, this is how an implementation tells a native container from a document holding a list.

element_alias: &'a str

The alias to give one element.

ordinal_alias: &'a str

The alias to give the element’s position.

fields: &'a [FlattenField<'a>]

The element fields the statement reads, in declared order. Empty for an array of scalars, where the element is itself the value.

Implementations

impl<'a> FlattenRequest<'a>

pub fn new( source_relation: &'a str, source_alias: &'a str, array_column: &'a str, array_type: &'a DataType, element_alias: &'a str, ordinal_alias: &'a str, fields: &'a [FlattenField<'a>], ) -> Self

Build a request. Every part is required, because every engine that can answer at all needs all of them.

pub fn element_type(&self) -> Option<&'a DataType>

What one element holds, where the column was declared as an array.

An engine whose elements are untyped reads them through this: an array of plain values is answered with one expression, and the expression has to say what kind of value it is producing. None is a column that was not declared as an array at all, which razeri refuses before it gets here.

pub fn elements_have_fields(&self) -> bool

True when the elements are records with named fields.

An array of scalars asks for no fields, because the element is the value: the answer’s fields is then empty and the element expression reads the whole of it.

Trait Implementations

impl<'a> Clone for FlattenRequest<'a>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for FlattenRequest<'a>

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

Formats the value using the given formatter.