uqa_sql/plpgsql/
lowering_expression.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Embedded SQL expression and assignment-target lowering.
8
9use super::{
10    expect_tag, json_i64_or_zero, require_nonempty_str, Expr, JSONValue, PLpgSQLCursorArgument,
11    Result, SQLError, Statement,
12};
13
14pub(super) fn lower_expr_list(raw: Option<&JSONValue>) -> Result<Vec<Expr>> {
15    let Some(raw) = raw else {
16        return Ok(Vec::new());
17    };
18    let list = raw
19        .as_array()
20        .ok_or_else(|| SQLError::Internal("PL/pgSQL expression list is not an array".into()))?;
21    let mut out = Vec::with_capacity(list.len());
22    for item in list {
23        out.push(lower_expr(item)?);
24    }
25    Ok(out)
26}
27
28/// Lower a `PLpgSQL_expr` node whose text is a scalar expression
29/// (parse modes 2 = expression, 3/4/5 = assignment source).
30pub(super) fn lower_expr(raw: &JSONValue) -> Result<Expr> {
31    let (query, mode) = expr_text(raw)?;
32    let parse_mode = match mode {
33        2 => pg_query::ParseMode::PlPgSqlExpr,
34        3 => pg_query::ParseMode::PlPgSqlAssign1,
35        4 => pg_query::ParseMode::PlPgSqlAssign2,
36        5 => pg_query::ParseMode::PlPgSqlAssign3,
37        other => {
38            return Err(SQLError::Internal(format!(
39                "PL/pgSQL scalar expression has invalid parse mode {other}"
40            )));
41        }
42    };
43    let node = parse_one_raw_node(&query, parse_mode)?;
44    match (mode, node.node.as_ref()) {
45        (2, Some(pg_query::NodeEnum::SelectStmt(select))) => {
46            compile_single_select_expression(select, &query)
47        }
48        (3..=5, Some(pg_query::NodeEnum::PlassignStmt(assign))) => {
49            let expected_names = i32::try_from(mode - 2).map_err(|_| {
50                SQLError::Internal(format!("invalid PL/pgSQL assignment parse mode {mode}"))
51            })?;
52            if assign.nnames != expected_names {
53                return Err(SQLError::Internal(format!(
54                    "PL/pgSQL assignment parser returned {} target names for parse mode {mode}",
55                    assign.nnames
56                )));
57            }
58            let value = assign
59                .val
60                .as_deref()
61                .ok_or_else(|| SQLError::Internal("PL/pgSQL assignment has no value".into()))?;
62            compile_single_select_expression(value, &query)
63        }
64        (_, Some(other)) => Err(SQLError::Internal(format!(
65            "PL/pgSQL parse mode {mode} returned unexpected node {other:?}"
66        ))),
67        (_, None) => Err(SQLError::Internal(
68            "PL/pgSQL expression parser returned an empty node".into(),
69        )),
70    }
71}
72
73/// Lower a `PLpgSQL_expr` node holding a complete SQL statement
74/// (parse mode 0: queries, PERFORM bodies, CALL statements).
75pub(super) fn lower_full_statement(raw: &JSONValue) -> Result<Statement> {
76    let (query, mode) = expr_text(raw)?;
77    if mode != 0 {
78        return Err(SQLError::Internal(format!(
79            "embedded PL/pgSQL statement has invalid parse mode {mode}"
80        )));
81    }
82    let mut stmts = crate::compile(&query)?;
83    match stmts.len() {
84        1 => Ok(stmts.remove(0)),
85        n => Err(SQLError::Internal(format!(
86            "embedded PL/pgSQL query compiled to {n} statements"
87        ))),
88    }
89}
90
91pub(super) fn lower_cursor_arguments(
92    raw: Option<&JSONValue>,
93) -> Result<Vec<PLpgSQLCursorArgument>> {
94    let Some(raw) = raw else {
95        return Ok(Vec::new());
96    };
97    let (query, mode) = expr_text(raw)?;
98    if mode != 2 {
99        return Err(SQLError::Internal(format!(
100            "PL/pgSQL cursor arguments have invalid parse mode {mode}"
101        )));
102    }
103    let node = parse_one_raw_node(&query, pg_query::ParseMode::PlPgSqlExpr)?;
104    let Some(pg_query::NodeEnum::SelectStmt(select)) = node.node.as_ref() else {
105        return Err(SQLError::Internal(format!(
106            "PL/pgSQL cursor arguments did not parse as a SELECT target list: {query}"
107        )));
108    };
109    validate_select_expression_envelope(select, &query)?;
110    if select.target_list.is_empty() {
111        return Err(SQLError::Parse(format!(
112            "PL/pgSQL cursor argument list is empty: {query}"
113        )));
114    }
115    let projections = crate::compiler::compile_pg_projections(&select.target_list)?;
116    Ok(projections
117        .into_iter()
118        .map(|projection| PLpgSQLCursorArgument {
119            name: projection.alias.map(|name| name.to_ascii_lowercase()),
120            expr: projection.expr,
121        })
122        .collect())
123}
124
125pub(super) fn expr_text(raw: &JSONValue) -> Result<(String, i64)> {
126    let expr = expect_tag(raw, "PLpgSQL_expr", "expression")?;
127    let query = require_nonempty_str(expr, "query", "PLpgSQL expression")?;
128    // RAW_PARSE_DEFAULT is encoded as zero and therefore omitted by
129    // libpg_query's JSON serializer.
130    let mode = json_i64_or_zero(expr, "parseMode")?;
131    Ok((query, mode))
132}
133
134/// Compile a bare expression through `PostgreSQL`'s PL/pgSQL expression parser.
135pub fn compile_expression_text(text: &str) -> Result<Expr> {
136    let node = parse_one_raw_node(text, pg_query::ParseMode::PlPgSqlExpr)?;
137    let Some(pg_query::NodeEnum::SelectStmt(select)) = node.node.as_ref() else {
138        return Err(SQLError::Parse(format!("not an expression: {text}")));
139    };
140    compile_single_select_expression(select, text)
141}
142
143fn parse_one_raw_node(text: &str, mode: pg_query::ParseMode) -> Result<pg_query::protobuf::Node> {
144    let parsed = pg_query::parse_with_mode(text, mode)?;
145    let mut statements = parsed.protobuf.stmts;
146    if statements.len() != 1 {
147        return Err(SQLError::Parse(format!(
148            "PL/pgSQL fragment parsed to {} statements: {text}",
149            statements.len()
150        )));
151    }
152    statements
153        .remove(0)
154        .stmt
155        .map(|node| *node)
156        .ok_or_else(|| SQLError::Internal("PL/pgSQL parser returned an empty statement".into()))
157}
158
159fn compile_single_select_expression(
160    select: &pg_query::protobuf::SelectStmt,
161    text: &str,
162) -> Result<Expr> {
163    if select.target_list.len() != 1 {
164        return Err(SQLError::Parse(format!("not a single expression: {text}")));
165    }
166    if validate_select_expression_envelope(select, text).is_err() {
167        return crate::compiler::compile_pg_select(select)
168            .map(Box::new)
169            .map(Expr::ScalarSubquery);
170    }
171    let Some(pg_query::NodeEnum::ResTarget(target)) = select.target_list[0].node.as_ref() else {
172        return Err(SQLError::Internal(
173            "PL/pgSQL expression target is not a ResTarget".into(),
174        ));
175    };
176    let value = target
177        .val
178        .as_deref()
179        .ok_or_else(|| SQLError::Internal("PL/pgSQL expression target has no value".into()))?;
180    crate::compiler::compile_pg_expression(value)
181}
182
183fn validate_select_expression_envelope(
184    select: &pg_query::protobuf::SelectStmt,
185    text: &str,
186) -> Result<()> {
187    if !select.distinct_clause.is_empty()
188        || select.into_clause.is_some()
189        || !select.from_clause.is_empty()
190        || select.where_clause.is_some()
191        || !select.group_clause.is_empty()
192        || select.group_distinct
193        || select.having_clause.is_some()
194        || !select.window_clause.is_empty()
195        || !select.values_lists.is_empty()
196        || !select.sort_clause.is_empty()
197        || select.limit_offset.is_some()
198        || select.limit_count.is_some()
199        || select.limit_option != pg_query::protobuf::LimitOption::Default as i32
200        || !select.locking_clause.is_empty()
201        || select.with_clause.is_some()
202        || select.op != pg_query::protobuf::SetOperation::SetopNone as i32
203        || select.all
204        || select.larg.is_some()
205        || select.rarg.is_some()
206    {
207        return Err(SQLError::Parse(format!(
208            "PL/pgSQL fragment contains non-expression SELECT state: {text}"
209        )));
210    }
211    Ok(())
212}
213
214#[cfg(test)]
215mod tests {
216    use super::*;
217
218    fn parsed_expression_select() -> pg_query::protobuf::SelectStmt {
219        let node = parse_one_raw_node("value + 1", pg_query::ParseMode::PlPgSqlExpr).unwrap();
220        let Some(pg_query::NodeEnum::SelectStmt(select)) = node.node else {
221            panic!("expression mode did not return SelectStmt");
222        };
223        *select
224    }
225
226    #[test]
227    fn expression_envelope_rejects_every_non_expression_select_field() {
228        let base = parsed_expression_select();
229        validate_select_expression_envelope(&base, "value + 1").unwrap();
230
231        let mut malformed = Vec::new();
232        let mut select = base.clone();
233        select
234            .distinct_clause
235            .push(pg_query::protobuf::Node::default());
236        malformed.push(select);
237        let mut select = base.clone();
238        select.into_clause = Some(Box::default());
239        malformed.push(select);
240        let mut select = base.clone();
241        select.group_distinct = true;
242        malformed.push(select);
243        let mut select = base.clone();
244        select.limit_option = pg_query::protobuf::LimitOption::WithTies as i32;
245        malformed.push(select);
246        let mut select = base.clone();
247        select.op = pg_query::protobuf::SetOperation::SetopUnion as i32;
248        malformed.push(select);
249        let mut select = base;
250        select.all = true;
251        malformed.push(select);
252
253        for select in malformed {
254            assert!(matches!(
255                validate_select_expression_envelope(&select, "malformed"),
256                Err(SQLError::Parse(message))
257                    if message.contains("non-expression SELECT state")
258            ));
259        }
260    }
261
262    #[test]
263    fn expression_with_from_lowers_to_a_scalar_subquery() {
264        let expression = compile_expression_text("max(a) FROM xacttest").unwrap();
265        let Expr::ScalarSubquery(query) = expression else {
266            panic!("PL/pgSQL query-shaped expression was not preserved as a scalar subquery");
267        };
268        assert_eq!(query.projections.len(), 1);
269        assert!(query.from.is_some());
270    }
271}
uqa_sql/plpgsql/lowering_expression.rs

uqa_sql/plpgsql/
lowering_expression.rs
