Struct Relation 

pub struct Relation<'a> {
    pub name: Cow<'a, str>,
    pub arguments: Option<RelationArgs<'a>>,
    pub columns: Vec<Value<'a>>,
    pub emit: Option<&'a EmitKind>,
    output_syntax: OutputSyntax,
    addenda: AddendumLines,
    pub children: Vec<Option<Relation<'a>>>,
}

Fields

name: Cow<'a, str>

arguments: Option<RelationArgs<'a>>

Arguments to the relation, if any.

• None means this relation does not take arguments, and the argument section is omitted entirely.
• Some(RelationArgs::Inline(args)) with both vectors empty means the relation takes arguments, but none are provided; this will print as _ => ....
• Some(RelationArgs::Inline(args)) with non-empty vectors will print with positional arguments first, then named arguments, separated by commas.
• Some(RelationArgs::Rows { .. }) prints one row per line, followed by any named arguments, one per line.

columns: Vec<Value<'a>>

The columns emitted by this relation, pre-emit - the ‘direct’ column output.

emit: Option<&'a EmitKind>

The emit kind, if any. If none, use the columns directly.

output_syntax: OutputSyntax

Whether output columns are rendered as visible output or as a direct output domain plus optional explicit emit mapping.

addenda: AddendumLines

+-prefixed addendum lines to emit between this relation’s header and children. This owns the canonical ordering for + Ext, + Enh, and + Opt lines rather than making the generic relation shape grow one field per addendum kind.

children: Vec<Option<Relation<'a>>>

The input relations.

Implementations

impl Relation<'_>

pub fn write_header<S: Scope, W: Write>(&self, ctx: &S, w: &mut W) -> Result

Write the header for this relation, e.g. Filter[$0 => $0].

Usually a single line, but an argument list of RelationArgs::Rows (used by Read:Virtual with many rows) spans several lines:

Read:Virtual[
  - (1, 'alice'),
  - (2, 'bob')
  - => id:i64, name:string]

Does not write a trailing newline; callers are responsible for any newline that follows (either from an addendum or from the next child).

pub fn write_children<S: Scope, W: Write>(&self, ctx: &S, w: &mut W) -> Result

Write each child relation at one indent level deeper than ctx. Each child is preceded by a newline.

impl<'a> Relation<'a>

pub fn emitted(&self) -> usize

impl<'a> Relation<'a>

fn from_read<S: Scope>(rel: &'a ReadRel, ctx: &S) -> Self

impl<'a> Relation<'a>

pub fn convert_children<S: Scope>( refs: Vec<Option<&'a Rel>>, ctx: &S, ) -> (Vec<Option<Relation<'a>>>, usize)

Convert a vector of relation references into their structured form.

Returns a list of children (with None for ones missing), and a count of input columns.

impl<'a> Relation<'a>

fn from_filter<S: Scope>(rel: &'a FilterRel, ctx: &S) -> Self

fn from_project<S: Scope>(rel: &'a ProjectRel, ctx: &S) -> Self

pub fn from_rel<S: Scope>(rel: &'a Rel, ctx: &S) -> Self

fn from_extension_leaf<S: Scope>(rel: &'a ExtensionLeafRel, ctx: &S) -> Self

fn from_extension_single<S: Scope>(rel: &'a ExtensionSingleRel, ctx: &S) -> Self

fn from_extension_multi<S: Scope>(rel: &'a ExtensionMultiRel, ctx: &S) -> Self

fn from_extension<S: Scope>( ext_type: &'static str, decoded: Result<(String, ExtensionArgs), ExtensionError>, child_refs: Vec<Option<&'a Rel>>, ctx: &S, ) -> Self

fn from_aggregate<S: Scope>(rel: &'a AggregateRel, ctx: &S) -> Self

Convert an AggregateRel to a Relation for textification.

The conversion follows this logic:

1. Arguments: Group-by expressions (as Value::Expression)
2. Columns: All possible outputs in order:
   • First: Group-by field references (Value::Reference)
   • Then: Aggregate function measures (Value::AggregateFunction)
3. Emit: Uses the relation’s emit mapping to select which outputs to display
4. Children: The input relation

fn get_grouping_sets( rel: &'a AggregateRel, ) -> (Vec<Value<'a>>, Vec<Vec<Value<'a>>>)

impl<'a> Relation<'a>

fn from_sort<S: Scope>(rel: &'a SortRel, ctx: &S) -> Self

fn from_fetch<S: Scope>(rel: &'a FetchRel, ctx: &S) -> Self

impl<'a> Relation<'a>

fn from_join<S: Scope>(rel: &'a JoinRel, ctx: &S) -> Self

fn from_set<S: Scope>(rel: &'a SetRel, ctx: &S) -> Self

fn from_cross<S: Scope>(rel: &'a CrossRel, ctx: &S) -> Self

Trait Implementations

impl Textify for Relation<'_>

fn name() -> &'static str

fn textify<S: Scope, W: Write>(&self, ctx: &S, w: &mut W) -> Result