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    validate_select_expression_envelope(select, text)?;
164    if select.target_list.len() != 1 {
165        return Err(SQLError::Parse(format!("not a single expression: {text}")));
166    }
167    let Some(pg_query::NodeEnum::ResTarget(target)) = select.target_list[0].node.as_ref() else {
168        return Err(SQLError::Internal(
169            "PL/pgSQL expression target is not a ResTarget".into(),
170        ));
171    };
172    let value = target
173        .val
174        .as_deref()
175        .ok_or_else(|| SQLError::Internal("PL/pgSQL expression target has no value".into()))?;
176    crate::compiler::compile_pg_expression(value)
177}
178
179fn validate_select_expression_envelope(
180    select: &pg_query::protobuf::SelectStmt,
181    text: &str,
182) -> Result<()> {
183    if !select.distinct_clause.is_empty()
184        || select.into_clause.is_some()
185        || !select.from_clause.is_empty()
186        || select.where_clause.is_some()
187        || !select.group_clause.is_empty()
188        || select.group_distinct
189        || select.having_clause.is_some()
190        || !select.window_clause.is_empty()
191        || !select.values_lists.is_empty()
192        || !select.sort_clause.is_empty()
193        || select.limit_offset.is_some()
194        || select.limit_count.is_some()
195        || select.limit_option != pg_query::protobuf::LimitOption::Default as i32
196        || !select.locking_clause.is_empty()
197        || select.with_clause.is_some()
198        || select.op != pg_query::protobuf::SetOperation::SetopNone as i32
199        || select.all
200        || select.larg.is_some()
201        || select.rarg.is_some()
202    {
203        return Err(SQLError::Parse(format!(
204            "PL/pgSQL fragment contains non-expression SELECT state: {text}"
205        )));
206    }
207    Ok(())
208}
209
210#[cfg(test)]
211mod tests {
212    use super::*;
213
214    fn parsed_expression_select() -> pg_query::protobuf::SelectStmt {
215        let node = parse_one_raw_node("value + 1", pg_query::ParseMode::PlPgSqlExpr).unwrap();
216        let Some(pg_query::NodeEnum::SelectStmt(select)) = node.node else {
217            panic!("expression mode did not return SelectStmt");
218        };
219        *select
220    }
221
222    #[test]
223    fn expression_envelope_rejects_every_non_expression_select_field() {
224        let base = parsed_expression_select();
225        validate_select_expression_envelope(&base, "value + 1").unwrap();
226
227        let mut malformed = Vec::new();
228        let mut select = base.clone();
229        select
230            .distinct_clause
231            .push(pg_query::protobuf::Node::default());
232        malformed.push(select);
233        let mut select = base.clone();
234        select.into_clause = Some(Box::default());
235        malformed.push(select);
236        let mut select = base.clone();
237        select.group_distinct = true;
238        malformed.push(select);
239        let mut select = base.clone();
240        select.limit_option = pg_query::protobuf::LimitOption::WithTies as i32;
241        malformed.push(select);
242        let mut select = base.clone();
243        select.op = pg_query::protobuf::SetOperation::SetopUnion as i32;
244        malformed.push(select);
245        let mut select = base;
246        select.all = true;
247        malformed.push(select);
248
249        for select in malformed {
250            assert!(matches!(
251                validate_select_expression_envelope(&select, "malformed"),
252                Err(SQLError::Parse(message))
253                    if message.contains("non-expression SELECT state")
254            ));
255        }
256    }
257}
uqa_sql/plpgsql/lowering_expression.rs

uqa_sql/plpgsql/
lowering_expression.rs
