Struct substrait_validator::input::proto::substrait::validator::Node

pub struct Node {
    pub class: i32,
    pub brief: Option<Comment>,
    pub summary: Option<Comment>,
    pub data_type: Option<DataType>,
    pub data: Vec<Data>,
    pub node_type: Option<NodeType>,
}

Nodes of the validator parse result tree.

Note that, unlike substrait.Plan and its children, the nodes in this tree are intentionally devoid of typing information: all nodes are of type Node. The purpose of this is to allow a consumer of these trees to walk over the entire tree without needing in-depth knowledge of how Substrait works (and, with that, to decouple them from changes to the Substrait specification): they are intended as an intermediate format for converting Substrait plans into more human-friendly representations after all, not for programmatically dealing with the semantics of Substrait itself. That’s what the validator is for, in this case.

In particular, gathering all diagnostics emitted by the validator only requires the consumer to use the Node, Node.Data, Node.Child, and of course the Diagnostic message types.

In case the consumer does need additional information from the original substrait.Plan, every node can be related back to its corresponding message via the path information associated with the nodes.

Fields

class: i32

Semantic classification of this node.

brief: Option<Comment>

Optional brief description of the node. Should not contain newlines or other non-span formatting information.

summary: Option<Comment>

Optional summary of the node. Unlike brief, this may contain paragraph-level formatting information.

data_type: Option<DataType>

For the following types of nodes, the validator will try to do type resolution:

• type-like nodes resolve to said type;
• expression-like nodes resolve to the type returned by the expression;
• relation-like nodes resolve to the schema (as a named struct) returned by the relation. This field will be populated for such nodes even if resolution fails, to indicate that there is supposed to be a type. In that case, the type kind will be set to “unresolved.” The field will not be populated for nodes that don’t have a logical Substrait type.

data: Vec<Data>

Data associated with this node.

node_type: Option<NodeType>

The type of node.

Implementations

impl Node

pub fn class(&self) -> Class

Returns the enum value of class, or the default if the field is set to an invalid enum value.

pub fn set_class(&mut self, value: Class)

Sets class to the provided enum value.

Trait Implementations

impl Clone for Node

fn clone(&self) -> Node

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Node

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

Formats the value using the given formatter.

impl Default for Node

fn default() -> Self

Returns the “default value” for a type.

impl From<&'_ Node> for Node

fn from(node: &Node) -> Self

Converts to this type from the input type.

impl InputNode for Node

fn type_to_node() -> Node

Creates an empty output node for a protobuf datum of this type.

fn data_to_node(&self) -> Node

Creates an empty output node for a protobuf datum with this value.

fn oneof_variant(&self) -> Option<&'static str>

Returns the name of the selected variant of a oneof field, if this is a rust enum used to represent a oneof field.

fn parse_unknown(&self, y: &mut Context<'_>) -> bool

Complete the subtrees of this datum in output that have not already been parsed using UnknownField nodes. Returns whether any such nodes were added.

impl Message for Node

fn encoded_len(&self) -> usize

Returns the encoded length of the message without a length delimiter.

fn clear(&mut self)

Clears the message, resetting all fields to their default.

fn encode<B>(&self, buf: &mut B) -> Result<(), EncodeError> where
    B: BufMut, 

Encodes the message to a buffer.

fn encode_to_vec(&self) -> Vec<u8, Global>

Encodes the message to a newly allocated buffer.

fn encode_length_delimited<B>(&self, buf: &mut B) -> Result<(), EncodeError> where
    B: BufMut, 

Encodes the message with a length-delimiter to a buffer.

fn encode_length_delimited_to_vec(&self) -> Vec<u8, Global>

Encodes the message with a length-delimiter to a newly allocated buffer.

fn decode<B>(buf: B) -> Result<Self, DecodeError> where
    B: Buf,
    Self: Default, 

Decodes an instance of the message from a buffer.

fn decode_length_delimited<B>(buf: B) -> Result<Self, DecodeError> where
    B: Buf,
    Self: Default, 

Decodes a length-delimited instance of the message from the buffer.

fn merge<B>(&mut self, buf: B) -> Result<(), DecodeError> where
    B: Buf, 

Decodes an instance of the message from a buffer, and merges it into self.

fn merge_length_delimited<B>(&mut self, buf: B) -> Result<(), DecodeError> where
    B: Buf, 

Decodes a length-delimited instance of the message from buffer, and merges it into self.

impl PartialEq<Node> for Node

fn eq(&self, other: &Node) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Node) -> bool

This method tests for !=.

impl ProtoMessage for Node

fn proto_message_type() -> &'static str

Returns the protobuf type name for messages of this type.

impl StructuralPartialEq for Node