Struct LogicalScan

pub struct LogicalScan {
    pub base: PlanBase<Logical>,
    core: TableScan,
}

LogicalScan returns contents of a table or other equivalent object

Fields

base: PlanBase<Logical>

core: TableScan

Implementations

impl LogicalScan

pub fn create( table_name: String, table_catalog: Arc<TableCatalog>, indexes: Vec<Rc<IndexCatalog>>, ctx: OptimizerContextRef, as_of: Option<AsOf>, table_cardinality: Cardinality, ) -> Self

Create a LogicalScan node. Used by planner.

pub fn table_name(&self) -> &str

pub fn as_of(&self) -> Option<AsOf>

pub fn table_cardinality(&self) -> Cardinality

The cardinality of the table without applying the predicate.

pub fn table_desc(&self) -> &TableDesc

Get a reference to the logical scan’s table desc.

pub fn table_catalog(&self) -> Arc<TableCatalog>

pub fn column_descs(&self) -> Vec<ColumnDesc>

Get the descs of the output columns.

pub fn output_column_ids(&self) -> Vec<ColumnId>

Get the ids of the output columns.

pub fn indexes(&self) -> &[Rc<IndexCatalog>]

Get all indexes on this table

pub fn predicate(&self) -> &Condition

Get the logical scan’s filter predicate

pub fn get_out_column_index_order(&self) -> Order

Return indices of fields the output is ordered by and corresponding direction

pub fn distribution_key(&self) -> Option<Vec<usize>>

pub fn watermark_columns(&self) -> FixedBitSet

pub fn indexes_satisfy_order( &self, required_order: &Order, ) -> Vec<&Rc<IndexCatalog>>

Return indexes can satisfy the required order.

pub fn to_index_scan_if_index_covered( &self, index: &Rc<IndexCatalog>, ) -> Option<LogicalScan>

If the index can cover the scan, transform it to the index scan.

pub fn primary_key(&self) -> &[ColumnOrder]

fn output_idx_to_input_ref(&self) -> Vec<ExprImpl>

a vec of InputRef corresponding to output_col_idx, which can represent a pulled project.

pub fn predicate_pull_up(&self) -> (TableScan, Condition, Option<Vec<ExprImpl>>)

Undo predicate push down when predicate in scan is not supported.

fn clone_with_predicate(&self, predicate: Condition) -> Self

pub fn clone_with_output_indices(&self, output_col_idx: Vec<usize>) -> Self

pub fn output_col_idx(&self) -> &Vec<usize>

pub fn required_col_idx(&self) -> &Vec<usize>

impl LogicalScan

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

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

Methods from Deref<Target = PlanBase<Logical>>

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 LogicalScan

fn clone(&self) -> LogicalScan

Returns a copy of the value.

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

Performs copy-assignment from source.

impl ColPrunable for LogicalScan

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 LogicalScan

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

Formats the value using the given formatter.

impl Deref for LogicalScan

type Target = PlanBase<Logical>

The resulting type after dereferencing.

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

Dereferences the value.

impl Distill for LogicalScan

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

fn distill_to_string(&self) -> String

impl ExprRewritable for LogicalScan

fn has_rewritable_expr(&self) -> bool

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

impl ExprVisitable for LogicalScan

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

impl From<TableScan> for LogicalScan

fn from(core: TableScan) -> Self

Converts to this type from the input type.

impl Hash for LogicalScan

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 LogicalScan

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

const NODE_TYPE: PlanNodeType = PlanNodeType::LogicalScan

type Convention = Logical

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

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 LogicalScan

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 PredicatePushdown for LogicalScan

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

Push predicate down for every logical plan node.

impl ToBatch for LogicalScan

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 LogicalScan

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 LogicalScan

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 LogicalScan

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 LogicalScan

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

impl TryToStreamPb for LogicalScan

fn try_to_stream_prost_body( &self, _state: &mut BuildFragmentGraphState, ) -> Result<NodeBody, SchedulerError>

impl Eq for LogicalScan

impl PlanNode for LogicalScan

impl StructuralPartialEq for LogicalScan

impl ToPb for LogicalScan