Struct PreCompiledMatchesTermExpr

pub struct PreCompiledMatchesTermExpr {
    text: Arc<dyn PhysicalExpr>,
    term: String,
    finder: MatchesTermFinder,
}

A physical expression that uses a pre-compiled term finder for the matches_term function.

This expression optimizes the matches_term function by pre-compiling the term when the term is a constant value. This avoids recompiling the term for each row during execution.

Fields

text: Arc<dyn PhysicalExpr>

The text column expression to search in

term: String

The constant term to search for

finder: MatchesTermFinder

The pre-compiled term finder

Trait Implementations

impl Debug for PreCompiledMatchesTermExpr

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

Formats the value using the given formatter.

impl Display for PreCompiledMatchesTermExpr

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

Formats the value using the given formatter.

impl Hash for PreCompiledMatchesTermExpr

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 PreCompiledMatchesTermExpr

fn eq(&self, other: &Self) -> 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 PhysicalExpr for PreCompiledMatchesTermExpr

fn as_any(&self) -> &dyn Any

Returns the physical expression as Any so that it can be downcast to a specific implementation.

fn data_type(&self, _input_schema: &Schema) -> Result<DataType>

Get the data type of this expression, given the schema of the input

fn nullable(&self, input_schema: &Schema) -> Result<bool>

Determine whether this expression is nullable, given the schema of the input

fn evaluate(&self, batch: &DfRecordBatch) -> Result<ColumnarValue>

Evaluate an expression against a RecordBatch

fn children(&self) -> Vec<&Arc<dyn PhysicalExpr>>

Get a list of child PhysicalExpr that provide the input for this expr.

fn with_new_children( self: Arc<Self>, children: Vec<Arc<dyn PhysicalExpr>>, ) -> Result<Arc<dyn PhysicalExpr>>

Returns a new PhysicalExpr where all children were replaced by new exprs.

fn evaluate_selection( &self, batch: &RecordBatch, selection: &BooleanArray, ) -> Result<ColumnarValue, DataFusionError>

Evaluate an expression against a RecordBatch after first applying a validity array

fn evaluate_bounds( &self, _children: &[&Interval], ) -> Result<Interval, DataFusionError>

Computes the output interval for the expression, given the input intervals.

fn propagate_constraints( &self, _interval: &Interval, _children: &[&Interval], ) -> Result<Option<Vec<Interval>>, DataFusionError>

Updates bounds for child expressions, given a known interval for this expression.

fn get_properties( &self, _children: &[ExprProperties], ) -> Result<ExprProperties, DataFusionError>

Calculates the properties of this [PhysicalExpr] based on its children’s properties (i.e. order and range), recursively aggregating the information from its children. In cases where the [PhysicalExpr] has no children (e.g., Literal or Column), these properties should be specified externally, as the function defaults to unknown properties.

impl Eq for PreCompiledMatchesTermExpr