Struct LogicalTopN 

pub struct LogicalTopN {
    pub base: PlanBase<Logical>,
    core: TopN<LogicalPlanRef>,
}

LogicalTopN sorts the input data and fetches up to limit rows from offset

Fields

base: PlanBase<Logical>

core: TopN<LogicalPlanRef>

Implementations

impl LogicalTopN

pub fn new( input: PlanRef, limit: u64, offset: u64, with_ties: bool, order: Order, group_key: Vec<usize>, ) -> Self

pub fn create( input: PlanRef, limit: u64, offset: u64, order: Order, with_ties: bool, group_key: Vec<usize>, ) -> Result<PlanRef>

pub fn limit_attr(&self) -> TopNLimit

pub fn offset(&self) -> u64

pub fn topn_order(&self) -> &Order

topn_order returns the order of the Top-N operator. This naming is because order() already exists and it was designed to return the operator’s physical property order.

Note that for streaming query, order() and topn_order() may differ. order() which implies the output ordering of an operator, is never guaranteed; while topn_order() must be non-null because it’s a critical information for Top-N operators to work

pub fn group_key(&self) -> &[usize]

pub fn decompose(self) -> (PlanRef, u64, u64, bool, Order, Vec<usize>)

decompose -> (input, limit, offset, with_ties, order, group_key)

fn gen_dist_stream_top_n_plan( &self, stream_input: StreamPlanRef, ) -> Result<StreamPlanRef>

fn gen_single_stream_top_n_plan( &self, stream_input: StreamPlanRef, ) -> Result<StreamPlanRef>

fn gen_vnode_two_phase_stream_top_n_plan( &self, stream_input: StreamPlanRef, dist_key: &[usize], ) -> Result<StreamPlanRef>

pub fn clone_with_input_and_prefix(&self, input: PlanRef, prefix: Order) -> Self

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 LogicalTopN

fn clone(&self) -> LogicalTopN

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl ColPrunable for LogicalTopN

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 LogicalTopN

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

Formats the value using the given formatter.

impl Deref for LogicalTopN

type Target = PlanBase<Logical>

The resulting type after dereferencing.

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

Dereferences the value.

impl Distill for LogicalTopN

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

fn distill_to_string(&self) -> String

impl ExprRewritable<Logical> for LogicalTopN

fn has_rewritable_expr(&self) -> bool

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

impl ExprVisitable for LogicalTopN

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

impl From<TopN<PlanRef<Logical>>> for LogicalTopN

fn from(core: TopN<PlanRef>) -> Self

Converts to this type from the input type.

impl Hash for LogicalTopN

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 LogicalTopN

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

const NODE_TYPE: LogicalPlanNodeType = LogicalPlanNodeType::LogicalTopN

type Convention = Logical

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

Get the reference to the PlanBase with corresponding convention.

impl PlanTreeNode<Logical> for LogicalTopN

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

Clone the node with a list of new inputs.

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

Get input nodes of the plan.

impl PlanTreeNodeUnary<Logical> for LogicalTopN

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)

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

impl PredicatePushdown for LogicalTopN

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

Push predicate down for every logical plan node.

impl ToBatch for LogicalTopN

fn to_batch(&self) -> Result<BatchPlanRef>

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

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

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

impl ToStream for LogicalTopN

fn to_stream(&self, ctx: &mut ToStreamContext) -> Result<StreamPlanRef>

to_stream is equivalent to to_stream_with_dist_required(RequiredDist::Any)

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

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<StreamPlanRef>

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

fn try_better_locality(&self, _columns: &[usize]) -> Option<LogicalPlanRef>

impl Eq for LogicalTopN

impl LogicalPlanNode for LogicalTopN

impl StructuralPartialEq for LogicalTopN