Struct InvertedIndexApplierBuilder

pub(crate) struct InvertedIndexApplierBuilder<'a> {
    region_dir: String,
    object_store: ObjectStore,
    file_cache: Option<Arc<FileCache>>,
    metadata: &'a RegionMetadata,
    indexed_column_ids: HashSet<ColumnId>,
    output: HashMap<ColumnId, Vec<Predicate>>,
    puffin_manager_factory: PuffinManagerFactory,
    inverted_index_cache: Option<Arc<IndexCache<FileId, InvertedIndexMetas>>>,
    puffin_metadata_cache: Option<PuffinMetadataCacheRef>,
}

Constructs an InvertedIndexApplier which applies predicates to SST files during scan.

Fields

region_dir: String

Directory of the region, required argument for constructing InvertedIndexApplier.

object_store: ObjectStore

Object store, required argument for constructing InvertedIndexApplier.

file_cache: Option<Arc<FileCache>>

File cache, required argument for constructing InvertedIndexApplier.

metadata: &'a RegionMetadata

Metadata of the region, used to get metadata like column type.

indexed_column_ids: HashSet<ColumnId>

Column ids of the columns that are indexed.

output: HashMap<ColumnId, Vec<Predicate>>

Stores predicates during traversal on the Expr tree.

puffin_manager_factory: PuffinManagerFactory

The puffin manager factory.

inverted_index_cache: Option<Arc<IndexCache<FileId, InvertedIndexMetas>>>

Cache for inverted index.

puffin_metadata_cache: Option<PuffinMetadataCacheRef>

Cache for puffin metadata.

Implementations

impl InvertedIndexApplierBuilder<'_>

pub(crate) fn collect_between(&mut self, between: &Between) -> Result<()>

Collects a BETWEEN expression in the form of column BETWEEN lit AND lit.

impl InvertedIndexApplierBuilder<'_>

pub(crate) fn collect_comparison_expr( &mut self, left: &DfExpr, op: &Operator, right: &DfExpr, ) -> Result<()>

Collects a comparison expression in the form of column < lit, column > lit, column <= lit, column >= lit, lit < column, lit > column, lit <= column, lit >= column.

fn collect_column_lt_lit(&mut self, left: &DfExpr, right: &DfExpr) -> Result<()>

fn collect_column_gt_lit(&mut self, left: &DfExpr, right: &DfExpr) -> Result<()>

fn collect_column_le_lit(&mut self, left: &DfExpr, right: &DfExpr) -> Result<()>

fn collect_column_ge_lit(&mut self, left: &DfExpr, right: &DfExpr) -> Result<()>

fn collect_column_cmp_lit( &mut self, column: &DfExpr, literal: &DfExpr, range_builder: impl FnOnce(Bytes) -> Range, ) -> Result<()>

impl InvertedIndexApplierBuilder<'_>

pub(crate) fn collect_eq(&mut self, left: &DfExpr, right: &DfExpr) -> Result<()>

Collects an eq expression in the form of column = lit.

pub(crate) fn collect_or_eq_list( &mut self, eq_expr: &DfExpr, or_list: &DfExpr, ) -> Result<()>

Collects eq list in the form of column = lit OR column = lit OR ....

fn collect_eq_list_inner( column_name: &str, data_type: &ConcreteDataType, expr: &DfExpr, inlist: &mut HashSet<Bytes>, ) -> Result<bool>

Recursively collects eq list.

Returns false if the expression doesn’t match the form then caller can safely ignore the expression.

impl InvertedIndexApplierBuilder<'_>

pub(crate) fn collect_inlist(&mut self, inlist: &InList) -> Result<()>

Collects an in list expression in the form of column IN (lit, lit, ...).

impl InvertedIndexApplierBuilder<'_>

pub(crate) fn collect_regex_match( &mut self, column: &DfExpr, pattern: &DfExpr, ) -> Result<()>

Collects a regex match expression in the form of column ~ pattern.

impl<'a> InvertedIndexApplierBuilder<'a>

pub fn new( region_dir: String, object_store: ObjectStore, metadata: &'a RegionMetadata, indexed_column_ids: HashSet<ColumnId>, puffin_manager_factory: PuffinManagerFactory, ) -> Self

Creates a new InvertedIndexApplierBuilder.

pub fn with_file_cache(self, file_cache: Option<Arc<FileCache>>) -> Self

Sets the file cache.

pub fn with_puffin_metadata_cache( self, puffin_metadata_cache: Option<PuffinMetadataCacheRef>, ) -> Self

Sets the puffin metadata cache.

pub fn with_inverted_index_cache( self, inverted_index_cache: Option<Arc<IndexCache<FileId, InvertedIndexMetas>>>, ) -> Self

Sets the inverted index cache.

pub fn build(self, exprs: &[Expr]) -> Result<Option<InvertedIndexApplier>>

Consumes the builder to construct an InvertedIndexApplier, optionally returned based on the expressions provided. If no predicates match, returns None.

fn traverse_and_collect(&mut self, expr: &Expr)

Recursively traverses expressions to collect predicates. Results are stored in self.output.

fn add_predicate(&mut self, column_id: ColumnId, predicate: Predicate)

Helper function to add a predicate to the output.

fn column_id_and_type( &self, column_name: &str, ) -> Result<Option<(ColumnId, ConcreteDataType)>>

Helper function to get the column id and the column type of a column. Returns None if the column is not a tag column or if the column is ignored.

fn nonnull_lit(expr: &Expr) -> Option<&ScalarValue>

Helper function to get a non-null literal.

fn column_name(expr: &Expr) -> Option<&str>

Helper function to get the column name of a column expression.

fn encode_lit(lit: &ScalarValue, data_type: ConcreteDataType) -> Result<Vec<u8>>

Helper function to encode a literal into bytes.