Struct JsonToVariant 

pub struct JsonToVariant;

Parses JSON strings into Variant values, optionally shredding fields.

Accepts Json extension inputs and returns Variant values with the input’s nullability. Null rows stay null, the JSON literal null becomes a variant-null value, and any row that fails to parse as JSON fails the whole expression.

A non-empty ShreddingSpec additionally shreds the selected paths into a typed shredded child, following the Parquet Variant shredding rules: rows whose value does not match the requested type stay readable through the residual variant value.

Execution

Building a Variant requires a concrete Variant encoding, so this function does not perform the conversion itself. The Variant encoding registered with the session supplies it as an execute_parent kernel keyed on the extension encoding for a Json input. The fallback execute here only canonicalizes the input to that encoding and re-dispatches so that kernel runs; it errors if no Variant encoding is registered with the session.

Normalization

json_to_variant is a lossy, normalizing conversion: the parsed Variant does not round-trip back to the exact source JSON text.

• JSON whitespace is not preserved.
• Object keys are stored in Variant metadata in sorted order, not source order.
• Number representations are normalized (e.g. 1.0 and 1 may parse to the same value; exponent forms and very large numbers are re-encoded).
• Duplicate object keys are collapsed to a single entry.
• Unicode escape sequences are normalized (e.g. A becomes A).

Trait Implementations

impl Clone for JsonToVariant

fn clone(&self) -> JsonToVariant

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl ScalarFnVTable for JsonToVariant

type Options = JsonToVariantOptions

Options for this expression.

fn id(&self) -> ScalarFnId

Returns the ID of the scalar function vtable.

fn serialize(&self, options: &Self::Options) -> VortexResult<Option<Vec<u8>>>

Serialize the options for this expression.

fn deserialize( &self, metadata: &[u8], session: &VortexSession, ) -> VortexResult<Self::Options>

Deserialize the options of this expression.

fn arity(&self, _options: &Self::Options) -> Arity

Returns the arity of this expression.

fn child_name(&self, _options: &Self::Options, child_idx: usize) -> ChildName

Returns the name of the nth child of the expr.

fn return_dtype( &self, _options: &Self::Options, arg_dtypes: &[DType], ) -> VortexResult<DType>

Compute the return DType of the expression if evaluated over the given input types.

fn execute( &self, options: &Self::Options, args: &dyn ExecutionArgs, ctx: &mut ExecutionCtx, ) -> VortexResult<ArrayRef>

Execute the expression over the input arguments.

fn is_null_sensitive(&self, _options: &Self::Options) -> bool

Returns whether this expression itself is null-sensitive. Conservatively default to true.

fn fmt_sql( &self, options: &Self::Options, expr: &Expression, f: &mut Formatter<'_>, ) -> Result<(), Error>

Format this expression in a nice human-readable SQL-style format

fn coerce_args( &self, options: &Self::Options, args: &[DType], ) -> Result<Vec<DType>, VortexError>

Coerce the arguments of this function.

fn reduce( &self, options: &Self::Options, node: &dyn ReduceNode, ctx: &dyn ReduceCtx, ) -> Result<Option<Arc<dyn ReduceNode>>, VortexError>

Implement an abstract reduction rule over a tree of scalar functions.

fn simplify( &self, options: &Self::Options, expr: &Expression, ctx: &dyn SimplifyCtx, ) -> Result<Option<Expression>, VortexError>

Simplify the expression if possible.

fn simplify_untyped( &self, options: &Self::Options, expr: &Expression, ) -> Result<Option<Expression>, VortexError>

Simplify the expression if possible, without type information.

fn validity( &self, options: &Self::Options, expression: &Expression, ) -> Result<Option<Expression>, VortexError>

Returns an expression that evaluates to the validity of the result of this expression.

fn is_fallible(&self, options: &Self::Options) -> bool

Returns whether this expression is semantically fallible. Conservatively defaults to true.