Struct LogQueryPlanner

pub struct LogQueryPlanner {
    table_provider: DfTableSourceProvider,
    session_state: SessionState,
}

Fields

table_provider: DfTableSourceProvider

session_state: SessionState

Implementations

impl LogQueryPlanner

pub fn new( table_provider: DfTableSourceProvider, session_state: SessionState, ) -> Self

pub async fn query_to_plan(&mut self, query: LogQuery) -> Result<LogicalPlan>

fn build_time_filter( &self, time_filter: &TimeFilter, schema: &Schema, ) -> Result<Expr>

fn build_filters( &self, filters: &Filters, schema: &ArrowSchema, ) -> Result<Option<Expr>>

fn build_column_filter( &self, column_filter: &ColumnFilters, schema: &ArrowSchema, ) -> Result<Option<Expr>>

Builds filter expression from ColumnFilters (new structure with expr + filters)

fn build_content_filter_with_expr( &self, col_expr: Expr, filter: &ContentFilter, schema: &DFSchema, ) -> Result<Option<Expr>>

Builds filter expression from a single ContentFilter using a provided column expression

fn build_aggr_func( &self, schema: &DFSchema, fn_name: &str, args: &[LogExpr], by: &[LogExpr], ) -> Result<(Expr, Vec<Expr>)>

fn log_expr_to_df_expr(&self, expr: &LogExpr, schema: &DFSchema) -> Result<Expr>

Converts a LogExpr to a DataFusion Expr, handling all expression types.

fn build_scalar_func( &self, schema: &DFSchema, name: &str, args: &[LogExpr], alias: &Option<String>, ) -> Result<Expr>

fn binary_operator_to_df_operator(op: &BinaryOperator) -> Operator

Convert BinaryOperator to DataFusion’s Operator.

fn infer_literal_scalar_value( &self, literal: &str, target_type: &DataType, ) -> ScalarValue

Parse a string literal to the appropriate ScalarValue based on target DataType. Falls back to UTF8 if parsing fails or type is not supported.

fn build_binary_expr( &self, left: &LogExpr, op: &BinaryOperator, right: &LogExpr, schema: &DFSchema, ) -> Result<Expr>

Build binary expression with type inference for literals. Attempts to infer literal types from the non-literal operand’s type.

fn create_inferred_literal( &self, value: &str, expr: &Expr, schema: &DFSchema, ) -> Expr

Create a type-inferred literal based on the provided expression’s type. Falls back to UTF8 if type inference fails.

fn create_eq_literal(value: EqualValue) -> Expr

fn process_log_expr( &self, plan_builder: LogicalPlanBuilder, expr: &LogExpr, ) -> Result<LogicalPlanBuilder>

Process LogExpr recursively.

Return the [LogicalPlanBuilder] after modification and the resulting expression’s names.