Enum SqlExpr 

pub enum SqlExpr {
    Lit(LitValue),
    JsonPath {
        root: String,
        path: JsonPath,
    },
    Param(usize),
    ColRef(String),
    Cast {
        inner: Box<SqlExpr>,
        ty: SqlType,
    },
    BinOp {
        op: BinOp,
        lhs: Box<SqlExpr>,
        rhs: Box<SqlExpr>,
    },
    UnaryOp {
        op: UnaryOp,
        inner: Box<SqlExpr>,
    },
    Case {
        arms: Vec<(SqlExpr, SqlExpr)>,
        else_: Option<Box<SqlExpr>>,
    },
    Coalesce(Vec<SqlExpr>),
    NullIf(Box<SqlExpr>, Box<SqlExpr>),
    AsJson(Box<SqlExpr>),
    JsonAgg(Box<SubQuery>),
    Scalar(Box<SubQuery>),
    Exists(Box<SubQuery>),
    CountSub(Box<SubQuery>),
    Alias {
        name: String,
        inner: Box<SqlExpr>,
    },
    ReferenceKey {
        reference: Box<SqlExpr>,
        expected_type: Option<String>,
    },
    Boundary {
        side: BoundarySide,
        kind: BoundaryKind,
        source: Box<SqlExpr>,
    },
    WhereExists {
        focus: Box<SqlExpr>,
        iter_alias: String,
        predicate: Box<SqlExpr>,
        negate: bool,
    },
    WhereScalar {
        focus: Box<SqlExpr>,
        iter_alias: String,
        predicate: Box<SqlExpr>,
        projection: Box<SqlExpr>,
    },
    JoinAggregate {
        outer_focus: Box<SqlExpr>,
        outer_alias: String,
        inner_field: String,
        inner_alias: String,
        separator: String,
    },
    CollectionAgg {
        root: String,
        path: JsonPath,
    },
    ScalarFromChain {
        chain_sql: String,
        projection: Box<SqlExpr>,
        offset: i64,
    },
}

A dialect-independent value-level SQL expression.

Each variant lowers to a SQL fragment via the Dialect trait. Subqueries hold a PlanNode together with the scalar projection extracted from each row.

Variants

Lit(LitValue)

Literal scalar.

JsonPath

Navigation through a JSON document.

root is the alias provided by the surrounding plan node — typically r.data (resource scan), fe.value (lateral unnest), or rec.node (recursive CTE). path is the chain of steps applied to it.

Fields

root: String

JSON root alias (e.g., r.data).

path: JsonPath

Ordered navigation steps applied to root.

Param(usize)

Bound query parameter, 1-based.

Indices 1 and 2 are reserved for tenant_id and resource_type. Constants from ViewDefinition.constant[] and string literals lifted out of extension(url) etc. allocate from index 3 upward.

ColRef(String)

Reference to a column projected by a CTE or subquery.

Cast

Type coercion. The dialect lowerer chooses the appropriate cast syntax.

Fields

inner: Box<SqlExpr>

Expression being coerced.

ty: SqlType

Target SQL type.

BinOp

Binary operator.

Fields

op: BinOp

Operator kind.

lhs: Box<SqlExpr>

Left-hand operand.

rhs: Box<SqlExpr>

Right-hand operand.

UnaryOp

Unary operator.

Fields

op: UnaryOp

Operator kind.

inner: Box<SqlExpr>

Operand the operator is applied to.

Case

CASE WHEN .. THEN .. ... ELSE .. END.

Fields

arms: Vec<(SqlExpr, SqlExpr)>

(condition, value) pairs evaluated in order.

else_: Option<Box<SqlExpr>>

Optional default branch.

Coalesce(Vec<SqlExpr>)

COALESCE(a, b, ...).

NullIf(Box<SqlExpr>, Box<SqlExpr>)

NULLIF(a, b).

AsJson(Box<SqlExpr>)

Wrap a scalar as a JSON value (to_jsonb / json).

JsonAgg(Box<SubQuery>)

Aggregate the rows produced by a subquery into a JSON array (jsonb_agg / json_group_array). Used for column.collection: true.

Scalar(Box<SubQuery>)

Scalar subquery — the inner plan must project exactly one value per row and return at most one row.

Exists(Box<SubQuery>)

EXISTS(subquery) — collapses to a boolean.

CountSub(Box<SubQuery>)

(SELECT count(*) FROM subquery).

Alias

Names an inner expression for reuse (lowered as a CTE column reference when the same scalar appears in multiple projections).

Fields

name: String

Alias to assign to inner.

inner: Box<SqlExpr>

Expression being aliased.

ReferenceKey

Extracts the id portion of a Reference.reference string. When expected_type is supplied, returns NULL unless the reference’s type segment matches (e.g. getReferenceKey(Patient) over Observation/123 returns NULL).

Fields

reference: Box<SqlExpr>

Reference string to inspect.

expected_type: Option<String>

FHIR resource type the reference must match, when set.

Boundary

FHIRPath lowBoundary() / highBoundary() — emits a precision-driven CASE expression over the source’s text form (decimal expands by a half-step in the last digit; date/dateTime/time pad with the first or last instant of the largest unspecified unit). The expected column.type is supplied so the dialect can pick decimal vs. date/dateTime/time logic.

Fields

side: BoundarySide

Whether to take the low or high boundary.

kind: BoundaryKind

Source value kind (decimal vs. date/dateTime/time).

source: Box<SqlExpr>

Expression whose boundary is being computed.

WhereExists

FHIRPath <focus>.where(<crit>).exists() — lowers to an EXISTS subquery that iterates the focus collection (a lateral unnest of a JSON path) and tests crit against each element. The criterion is pre-lowered with iter_alias.value set as its path root.

Fields

focus: Box<SqlExpr>

Collection expression to iterate.

iter_alias: String

Iteration alias used by predicate.

predicate: Box<SqlExpr>

Criterion evaluated against each element.

negate: bool

Mirrors where(crit).empty() — negate the EXISTS.

WhereScalar

FHIRPath <focus>.where(<crit>).<navigation> collapsed to a scalar subquery: iterate the focus collection, filter by the criterion, project the navigation off the iteration alias, return at most one row. Used when a column’s path threads a where() call somewhere in the middle (e.g. name.where(use='official').family).

Fields

focus: Box<SqlExpr>

Collection expression to iterate.

iter_alias: String

Iteration alias used by predicate and projection.

predicate: Box<SqlExpr>

Filter applied to each iteration row.

projection: Box<SqlExpr>

Scalar projection extracted from the surviving row.

JoinAggregate

FHIRPath <base>.<field>.join(<sep>) — aggregates the values of <field> across each element of <base> (flattened) into a single separator-joined string. Lowers to string_agg (PG) / group_concat (SQLite) over a chained lateral unnest.

Fields

outer_focus: Box<SqlExpr>

Outer collection expression to iterate.

outer_alias: String

Outer iteration alias.

inner_field: String

Field name to flatten on each outer row.

inner_alias: String

Inner iteration alias.

separator: String

Separator inserted between joined elements.

CollectionAgg

column.collection: true projection — aggregates the flattened values of a JSON path into a JSON array. Each Field step in path becomes a lateral unnest; the final element values feed into a json_agg / json_group_array.

Fields

root: String

JSON root alias for the aggregation source.

path: JsonPath

Path navigation aggregated into an array.

ScalarFromChain

Correlated scalar subquery used for forEach: "<chain>[N]" paths — FHIRPath indexes the FLATTENED iteration result, but SQLite forbids correlated subqueries in FROM. Lowering each column to a scalar-subquery in the SELECT side bypasses that limitation:

(SELECT <projection> FROM <chain_sql> LIMIT 1 OFFSET <offset>).

Fields

chain_sql: String

Pre-built FROM-clause SQL for the flattened chain.

projection: Box<SqlExpr>

Scalar projection extracted from the row at offset.

offset: i64

Zero-based index into the flattened chain.

Trait Implementations

impl Clone for SqlExpr

fn clone(&self) -> SqlExpr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SqlExpr

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

Formats the value using the given formatter.