Function expr_to_sql_value

nodedb-sql/src/planner/dml_helpers.rs:28–54

(expr: &ast::Expr)

}

pub(super) fn expr_to_sql_value(expr: &ast::Expr) -> Result<SqlValue> {
    match expr {
        ast::Expr::Value(v) => convert_value(&v.value),
        // Array literals lower element-wise into `SqlValue::Array`; there is
        // no array-literal `SqlValue` the constant folder could produce.
        ast::Expr::Array(ast::Array { elem, .. }) => {
            let vals = elem.iter().map(expr_to_sql_value).collect::<Result<_>>()?;
            Ok(SqlValue::Array(vals))
        }
        // `ST_Point(...)` / `ST_GeomFromGeoJSON(...)` synthesise a GeoJSON
        // string in place rather than resolving as registered scalar
        // functions, so they keep their bespoke handling.
        ast::Expr::Function(func) => match SpatialConstructor::from_function(func) {
            Some(ctor) => spatial_constructor_to_value(ctor, func),
            // Non-spatial functions (`now()`, `date_add(...)`, registered
            // scalars) fold through the shared pipeline below.
            None => fold_constant_value(expr),
        },
        // Everything else — `::TYPE` / `CAST(... AS TYPE)` casts, arithmetic,
        // string concatenation, parenthesised literals — goes through the
        // same resolver and constant folder the `SELECT` projection path
        // uses, so the two surfaces never drift. Only genuinely row- or
        // runtime-dependent expressions (column refs, subqueries, unknown
        // functions) fail here.
        _ => fold_constant_value(expr),
    }
}

fn fold_constant_value(expr: &ast::Expr) -> Result<SqlValue> {
    let sql_expr = crate::resolver::expr::convert_expr(expr)?;