Struct DfLogicalPlanner 

pub struct DfLogicalPlanner {
    engine_state: Arc<QueryEngineState>,
    session_state: SessionState,
}

Fields

engine_state: Arc<QueryEngineState>

session_state: SessionState

Implementations

impl DfLogicalPlanner

pub fn new(engine_state: Arc<QueryEngineState>) -> Self

async fn explain_to_plan( &self, explain: &ExplainStatement, query_ctx: QueryContextRef, ) -> Result<LogicalPlan>

Basically the same with explain_to_plan in DataFusion, but adapted to Greptime’s plan_sql to support Greptime Statements.

fn plan_sql<'life0, 'life_self, 'async_recursion>( &'life_self self, stmt: &'life0 Statement, query_ctx: QueryContextRef, ) -> Pin<Box<dyn Future<Output = Result<LogicalPlan>> + Send + 'async_recursion>>

where 'life0: 'async_recursion, 'life_self: 'async_recursion,

pub(crate) async fn sql_to_expr( &self, sql: SqlExpr, schema: &DFSchema, normalize_ident: bool, query_ctx: QueryContextRef, ) -> Result<DfExpr>

Generate a relational expression from a SQL expression

async fn plan_pql( &self, stmt: &EvalStmt, query_ctx: QueryContextRef, ) -> Result<LogicalPlan>

fn optimize_logical_plan(&self, plan: LogicalPlan) -> Result<LogicalPlan>

fn has_hybrid_ctes(&self, stmt: &Statement) -> bool

Check if a statement contains hybrid CTEs (mix of SQL and TQL)

async fn plan_query_with_hybrid_ctes( &self, query: &Query, query_ctx: QueryContextRef, planner_context: &mut PlannerContext, ) -> Result<()>

Plan a query with hybrid CTEs using DataFusion’s native PlannerContext

async fn tql_to_logical_plan( &self, tql: &Tql, query_ctx: QueryContextRef, ) -> Result<LogicalPlan>

Convert TQL to LogicalPlan directly

fn extract_placeholder_cast_types( plan: &LogicalPlan, ) -> Result<HashMap<String, Option<DataType>>>

Extracts cast types for all placeholders in a logical plan. Returns a map where each placeholder ID is mapped to:

• Some(DataType) if the placeholder is cast to a specific type
• None if the placeholder exists but has no cast

Example: $1::TEXT returns {"$1": Some(DataType::Utf8)}

This function walks through all expressions in the logical plan, including subqueries, to identify placeholders and their cast types.

pub fn get_inferred_parameter_types( plan: &LogicalPlan, ) -> Result<HashMap<String, Option<DataType>>>

Gets inferred parameter types from a logical plan. Returns a map where each parameter ID is mapped to:

• Some(DataType) if the parameter type could be inferred
• None if the parameter type could not be inferred

This function first uses DataFusion’s get_parameter_types() to infer types. If any parameters have None values (i.e., DataFusion couldn’t infer their types), it falls back to using extract_placeholder_cast_types() to detect explicit casts.

This is because datafusion can only infer types for a limited cases.

Example: For query WHERE $1::TEXT AND $2, DataFusion may not infer $2’s type, but this function will return {"$1": Some(DataType::Utf8), "$2": None}.

Trait Implementations

impl LogicalPlanner for DfLogicalPlanner

fn plan<'life0, 'life1, 'async_trait>( &'life0 self, stmt: &'life1 QueryStatement, query_ctx: QueryContextRef, ) -> Pin<Box<dyn Future<Output = Result<LogicalPlan>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn plan_logs_query<'life0, 'async_trait>( &'life0 self, query: LogQuery, query_ctx: QueryContextRef, ) -> Pin<Box<dyn Future<Output = Result<LogicalPlan>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn optimize(&self, plan: LogicalPlan) -> Result<LogicalPlan>

fn as_any(&self) -> &dyn Any