Struct JsonExprPlanner 

pub(crate) struct JsonExprPlanner;

Rewrites JSON-aware SQL expressions into DataFusion expressions.

This planner handles three cases:

• Rewrites compound identifiers on JSON extension columns into json_get function. For example, select a.b.c => select json_get(a, "b.c").
• Extends a JSON path with list indexes and fields following an index. For example, select a.b[0].c => select json_get(a, "b[0][\"c\"]").
• Pushes an “expected type” argument into the json_get function when it participates in a binary operator. So that json_get knows the wanted data type when dealing with variant JSON values. For example, select json_get(a, "b.c") + 1 => select json_get(a, "b.c", NULL::Int64) + 1.
• Infers the expected type from scalar, aggregate, and window function signatures. For example, select abs(a.b.c) => select abs(json_get(a, "b.c", NULL::Float64)).

Trait Implementations

impl Debug for JsonExprPlanner

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

Formats the value using the given formatter.

impl ExprPlanner for JsonExprPlanner

fn plan_field_access( &self, expr: RawFieldAccessExpr, _schema: &DFSchema, ) -> Result<PlannerResult<RawFieldAccessExpr>>

Extends the path of an untyped json_get with one field access.

For j.o.l[1].inner.l[2], plan_compound_identifier first produces json_get(j, "o.l"). DataFusion then calls this method successively with a list index, two named fields, and another list index, producing the final path o.l[1]["inner"]["l"][2].

fn plan_scalar( &self, expr: RawScalarExpr, ) -> Result<PlannerResult<RawScalarExpr>>

Rewrites JSON2 arguments without taking over the final function planning.

Original carries the possibly modified raw expression to subsequent planners and then DataFusion’s default function construction. Returning Planned would short-circuit both.

fn plan_aggregate( &self, expr: RawAggregateExpr, ) -> Result<PlannerResult<RawAggregateExpr>>

Rewrites JSON2 arguments while preserving subsequent aggregate planning.

fn plan_window( &self, expr: RawWindowExpr, ) -> Result<PlannerResult<RawWindowExpr>>

Rewrites JSON2 arguments while preserving subsequent window planning.

fn plan_binary_op( &self, expr: RawBinaryExpr, schema: &DFSchema, ) -> Result<PlannerResult<RawBinaryExpr>>

Plan the binary operation between two expressions, returns original BinaryExpr if not possible

fn plan_compound_identifier( &self, field: &Field, qualifier: Option<&TableReference>, nested_names: &[String], ) -> Result<PlannerResult<Vec<Expr>>>

Plans compound identifier such as db.schema.table for non-empty nested names

fn plan_array_literal( &self, exprs: Vec<Expr>, _schema: &DFSchema, ) -> Result<PlannerResult<Vec<Expr>>, DataFusionError>

Plan an array literal, such as [1, 2, 3]

fn plan_position( &self, args: Vec<Expr>, ) -> Result<PlannerResult<Vec<Expr>>, DataFusionError>

Plan a POSITION expression, such as POSITION(<expr> in <expr>)

fn plan_dictionary_literal( &self, expr: RawDictionaryExpr, _schema: &DFSchema, ) -> Result<PlannerResult<RawDictionaryExpr>, DataFusionError>

Plan a dictionary literal, such as { key: value, ...}

fn plan_extract( &self, args: Vec<Expr>, ) -> Result<PlannerResult<Vec<Expr>>, DataFusionError>

Plan an extract expression, such asEXTRACT(month FROM foo)

fn plan_substring( &self, args: Vec<Expr>, ) -> Result<PlannerResult<Vec<Expr>>, DataFusionError>

Plan an substring expression, such as SUBSTRING(<expr> [FROM <expr>] [FOR <expr>])

fn plan_struct_literal( &self, args: Vec<Expr>, _is_named_struct: bool, ) -> Result<PlannerResult<Vec<Expr>>, DataFusionError>

Plans a struct literal, such as {'field1' : expr1, 'field2' : expr2, ...}

fn plan_overlay( &self, args: Vec<Expr>, ) -> Result<PlannerResult<Vec<Expr>>, DataFusionError>

Plans an overlay expression, such as overlay(str PLACING substr FROM pos [FOR count])

fn plan_make_map( &self, args: Vec<Expr>, ) -> Result<PlannerResult<Vec<Expr>>, DataFusionError>

Plans a make_map expression, such as make_map(key1, value1, key2, value2, ...)