Struct StreamMaterialize

pub struct StreamMaterialize {
    pub base: PlanBase<Stream>,
    input: PlanRef,
    table: TableCatalog,
}

Materializes a stream.

Fields

base: PlanBase<Stream>

input: PlanRef

Child of Materialize plan

table: TableCatalog

Implementations

impl StreamMaterialize

pub fn new(input: PlanRef, table: TableCatalog) -> Self

pub fn create( input: PlanRef, name: String, user_distributed_by: RequiredDist, user_order_by: Order, user_cols: FixedBitSet, out_names: Vec<String>, definition: String, table_type: TableType, cardinality: Cardinality, retention_seconds: Option<NonZeroU32>, ) -> Result<Self, RwError>

Create a materialize node, for MATERIALIZED VIEW and INDEX.

When creating index, TableType should be Index. Then, materialize will distribute keys using user_distributed_by.

pub fn create_for_table( input: PlanRef, name: String, user_distributed_by: RequiredDist, user_order_by: Order, columns: Vec<ColumnCatalog>, definition: String, conflict_behavior: ConflictBehavior, version_column_index: Option<usize>, pk_column_indices: Vec<usize>, row_id_index: Option<usize>, version: Option<TableVersion>, retention_seconds: Option<NonZeroU32>, cdc_table_id: Option<String>, ) -> Result<Self, RwError>

Create a materialize node, for TABLE.

Different from create, the columns are passed in directly, instead of being derived from the input. So the column IDs are preserved from the SQL columns binding step and will be consistent with the source node and DML node.

fn rewrite_input( input: PlanRef, user_distributed_by: RequiredDist, table_type: TableType, ) -> Result<PlanRef, RwError>

Rewrite the input to satisfy the required distribution if necessary, according to the type.

fn derive_table_catalog( rewritten_input: PlanRef, name: String, user_order_by: Order, columns: Vec<ColumnCatalog>, definition: String, conflict_behavior: ConflictBehavior, version_column_index: Option<usize>, pk_column_indices: Option<Vec<usize>>, row_id_index: Option<usize>, table_type: TableType, version: Option<TableVersion>, cardinality: Cardinality, retention_seconds: Option<NonZeroU32>, create_type: CreateType, ) -> Result<TableCatalog, RwError>

Derive the table catalog with the given arguments.

• The caller must ensure the validity of the given columns.
• The rewritten_input should be generated by rewrite_input.

pub fn table(&self) -> &TableCatalog

Get a reference to the stream materialize’s table.

pub fn name(&self) -> &str

Methods from Deref<Target = PlanBase<Stream>>

pub fn clone_with_new_plan_id(&self) -> Self

pub fn clone_with_new_distribution(&self, dist: Distribution) -> Self

Clone the plan node with a new distribution.

Panics if the plan node is not physical.

Trait Implementations

impl Clone for StreamMaterialize

fn clone(&self) -> StreamMaterialize

Returns a copy of the value.

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

Performs copy-assignment from source.

impl ColPrunable for StreamMaterialize

fn prune_col( &self, _required_cols: &[usize], _ctx: &mut ColumnPruningContext, ) -> PlanRef

Transform the plan node to only output the required columns ordered by index number.

impl Debug for StreamMaterialize

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

Formats the value using the given formatter.

impl Deref for StreamMaterialize

type Target = PlanBase<Stream>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl Distill for StreamMaterialize

fn distill<'a>(&self) -> XmlNode<'a>

fn distill_to_string(&self) -> String

impl ExprRewritable for StreamMaterialize

fn has_rewritable_expr(&self) -> bool

fn rewrite_exprs(&self, _r: &mut dyn ExprRewriter) -> PlanRef

impl ExprVisitable for StreamMaterialize

fn visit_exprs(&self, _v: &mut dyn ExprVisitor)

impl Hash for StreamMaterialize

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 PartialEq for StreamMaterialize

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

const NODE_TYPE: PlanNodeType = PlanNodeType::StreamMaterialize

type Convention = Stream

fn plan_base(&self) -> &PlanBase<Stream>

Get the reference to the PlanBase with corresponding convention.

fn plan_base_ref(&self) -> PlanBaseRef<'_>

Get the reference to the PlanBase with erased convention.

impl PlanTreeNode for StreamMaterialize

fn clone_with_inputs(&self, inputs: &[PlanRef]) -> PlanRef

Clone the node with a list of new inputs.

fn inputs(&self) -> SmallVec<[PlanRef; 2]>

Get input nodes of the plan.

impl PlanTreeNodeUnary for StreamMaterialize

fn input(&self) -> PlanRef

fn clone_with_input(&self, input: PlanRef) -> Self

fn rewrite_with_input( &self, _input: PlanRef, _input_col_change: ColIndexMapping, ) -> (Self, ColIndexMapping)

where Self: Sized,

Rewrites the plan node according to the schema change of its input node during rewriting.

impl PredicatePushdown for StreamMaterialize

fn predicate_pushdown( &self, _predicate: Condition, _ctx: &mut PredicatePushdownContext, ) -> PlanRef

Push predicate down for every logical plan node.

impl StreamNode for StreamMaterialize

fn to_stream_prost_body( &self, _state: &mut BuildFragmentGraphState, ) -> PbNodeBody

impl ToBatch for StreamMaterialize

fn to_batch(&self) -> Result<PlanRef, RwError>

to_batch is equivalent to to_batch_with_order_required(&Order::any())

fn to_batch_with_order_required( &self, required_order: &Order, ) -> Result<PlanRef, RwError>

convert the plan to batch physical plan and satisfy the required Order

impl ToDistributedBatch for StreamMaterialize

fn to_distributed(&self) -> Result<PlanRef, RwError>

to_distributed is equivalent to to_distributed_with_required(&Order::any(), &RequiredDist::Any)

fn to_distributed_with_required( &self, required_order: &Order, required_dist: &RequiredDist, ) -> Result<PlanRef, RwError>

insert the exchange in batch physical plan to satisfy the required Distribution and Order.

impl ToLocalBatch for StreamMaterialize

fn to_local(&self) -> Result<PlanRef, RwError>

fn to_local_with_order_required( &self, required_order: &Order, ) -> Result<PlanRef, RwError>

Convert the plan to batch local physical plan and satisfy the required Order

impl ToStream for StreamMaterialize

fn to_stream(&self, _ctx: &mut ToStreamContext) -> Result<PlanRef, RwError>

to_stream is equivalent to to_stream_with_dist_required(RequiredDist::Any)

fn logical_rewrite_for_stream( &self, _ctx: &mut RewriteStreamContext, ) -> Result<(PlanRef, ColIndexMapping), RwError>

logical_rewrite_for_stream will rewrite the logical node, and return (new_plan_node, col_mapping), the col_mapping is for original columns have been changed into some other position.

fn to_stream_with_dist_required( &self, required_dist: &RequiredDist, ctx: &mut ToStreamContext, ) -> Result<PlanRef, RwError>

convert the plan to streaming physical plan and satisfy the required distribution

impl TryToBatchPb for StreamMaterialize

fn try_to_batch_prost_body(&self) -> Result<NodeBody, SchedulerError>

impl Eq for StreamMaterialize

impl PlanNode for StreamMaterialize

impl StructuralPartialEq for StreamMaterialize

impl ToPb for StreamMaterialize