Struct LogicalIcebergIntermediateScan 

pub struct LogicalIcebergIntermediateScan {
    pub base: PlanBase<Logical>,
    pub core: Source,
    pub iceberg_predicate: Predicate,
    pub time_travel_info: IcebergTimeTravelInfo,
    pub table_column_type_mapping: HashMap<String, DataType>,
    pub hummock_rewrite: HummockRewriteInfo,
}

LogicalIcebergIntermediateScan is an intermediate plan node used during optimization of Iceberg scans. It accumulates predicates and column pruning information before being converted to the final LogicalIcebergScan with delete file anti-joins.

This node is introduced to reduce the number of Iceberg metadata reads. Instead of reading metadata when creating LogicalIcebergScan, we defer the metadata read until all optimizations (predicate pushdown, column pruning) are applied.

The optimization flow is:

1. LogicalSource (iceberg) -> LogicalIcebergIntermediateScan
2. Predicate pushdown and column pruning are applied to LogicalIcebergIntermediateScan
3. LogicalIcebergIntermediateScan -> LogicalIcebergScan (with anti-joins for delete files)

Fields

base: PlanBase<Logical>

core: Source

iceberg_predicate: Predicate

time_travel_info: IcebergTimeTravelInfo

table_column_type_mapping: HashMap<String, DataType>

For Iceberg engine tables: maps source column name → target Hummock DataType. This remapping is applied to the output schema so that the intermediate scan’s output types match the Hummock table types, avoiding unnecessary double casts when the storage selection rule rewrites to a Hummock LogicalScan. Empty for non-engine-table Iceberg sources.

hummock_rewrite: HummockRewriteInfo

Info needed only when rewriting to a Hummock row-store scan.

Implementations

impl LogicalIcebergIntermediateScan

pub fn new( logical_source: &LogicalSource, time_travel_info: IcebergTimeTravelInfo, table_column_type_mapping: HashMap<String, DataType>, source_to_table_mapping: ColIndexMapping, ) -> Self

pub fn source_catalog(&self) -> Option<&SourceCatalog>

pub fn output_columns(&self) -> impl ExactSizeIterator<Item = &str>

pub fn add_predicate( &self, iceberg_predicate: Predicate, extracted_condition: Condition, ) -> Self

pub fn has_type_mapping(&self) -> bool

Returns true if this intermediate scan has type remapping for Iceberg engine tables.

pub fn clone_with_required_cols(&self, required_cols: &[usize]) -> 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 LogicalIcebergIntermediateScan

fn clone(&self) -> LogicalIcebergIntermediateScan

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl ColPrunable for LogicalIcebergIntermediateScan

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 LogicalIcebergIntermediateScan

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

Formats the value using the given formatter.

impl Deref for LogicalIcebergIntermediateScan

type Target = PlanBase<Logical>

The resulting type after dereferencing.

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

Dereferences the value.

impl Distill for LogicalIcebergIntermediateScan

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

fn distill_to_string(&self) -> String

impl ExprRewritable<Logical> for LogicalIcebergIntermediateScan

fn has_rewritable_expr(&self) -> bool

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

impl ExprVisitable for LogicalIcebergIntermediateScan

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

impl Hash for LogicalIcebergIntermediateScan

where PlanBase<Logical>: Hash, Source: Hash, IcebergTimeTravelInfo: Hash,

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 LogicalIcebergIntermediateScan

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

const NODE_TYPE: LogicalPlanNodeType = LogicalPlanNodeType::LogicalIcebergIntermediateScan

type Convention = Logical

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

Get the reference to the PlanBase with corresponding convention.

impl PlanTreeNode<Logical> for LogicalIcebergIntermediateScan

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

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

Push predicate down for every logical plan node.

impl ToBatch for LogicalIcebergIntermediateScan

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 LogicalIcebergIntermediateScan

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 LogicalIcebergIntermediateScan

impl LogicalPlanNode for LogicalIcebergIntermediateScan

impl StructuralPartialEq for LogicalIcebergIntermediateScan