grammar+db: 3g — RETURNING on INSERT/UPDATE/DELETE (ADR-0033 §5)

Shared RETURNING_CLAUSE (reuses Phase-2 PROJECTION_LIST, now
pub(crate)) as an optional tail on all three SQL DML shapes.
`returning: bool` on the Command variants, set by the ast-builders
and threaded to the worker. run_returning collects the returned rows
as a DataResult (RETURNING mutates + yields in one pass), reusing
resolve_select_column_types for bare-column type recovery; computed
projections stay typeless. DeleteResult gains a `data` field rendered
alongside the cascade summary.

Follow-set fix: `returning` is added to the table-source and
projection bare-alias follow-sets so an INSERT … SELECT row source
stops before RETURNING instead of reading it as a table alias.

Auto-fill × RETURNING: build_sql_insert stops row_source before the
RETURNING token (keeping it preparable for shortid materialisation),
and plan_shortid_autofill re-appends the RETURNING tail so generated
shortids surface in RETURNING *.

Tests (+17): grammar accept on all three; INSERT/UPDATE/DELETE
RETURNING incl. *, aliases, multi-row, type recovery + computed-
typeless; auto-fill × RETURNING (single + multi-row distinct ids);
INSERT…SELECT…RETURNING execution; UPDATE…RETURNING zero-match;
DELETE…RETURNING cascade+rows; app-level render of both. Dev
sql_insert/sql_update/sql_delete entry words still removed in 3j.
1562 pass / 0 fail / 1 ignored. Clippy clean.

tests/sql_update.rs

@@ -58,6 +58,7 @@ fn seed(db: &Database, rt: &tokio::runtime::Runtime, sql: &str, target: &str) {
         target.to_string(),
         Vec::new(),
         String::new(),
+        false,
     ))
     .unwrap_or_else(|e| panic!("seed {sql:?}: {e:?}"));
 }
@@ -69,8 +70,8 @@ fn run_update(
     input: &str,
 ) -> Result<UpdateResult, DbError> {
     match parse_command(input).expect("parse sql_update") {
-        Command::SqlUpdate { sql, target_table } => {
-            rt.block_on(db.run_sql_update(sql, Some(input.to_string()), target_table))
+        Command::SqlUpdate { sql, target_table, returning } => {
+            rt.block_on(db.run_sql_update(sql, Some(input.to_string()), target_table, returning))
         }
         other => panic!("expected Command::SqlUpdate, got {other:?}"),
     }
@@ -81,7 +82,7 @@ fn parse_path_lowers_sql_update_to_command() {
     let command = parse_command("sql_update Orders set total = 0 where id = 1")
         .expect("sql_update parses in advanced mode");
     match command {
-        Command::SqlUpdate { sql, target_table } => {
+        Command::SqlUpdate { sql, target_table, .. } => {
             assert_eq!(sql, "update Orders set total = 0 where id = 1");
             assert_eq!(target_table, "Orders");
         }
@@ -203,3 +204,51 @@ fn update_appends_literal_line_to_history() {
         .expect("history.log present");
     assert!(body.contains(input), "history records the literal line: {body:?}");
 }
+
+// =================================================================
+// Sub-phase 3g — RETURNING (ADR-0033 §5)
+// =================================================================
+
+#[test]
+fn update_returning_yields_modified_columns() {
+    let (_project, db, _dir) = open_project_db();
+    let rt = rt();
+    create_cols(&db, &rt, "t", &[("id", Type::Int), ("v", Type::Text)], &["id"]);
+    seed(&db, &rt, "insert into t (id, v) values (1, 'old'), (2, 'keep')", "t");
+    let result = run_update(&db, &rt, "sql_update t set v = 'new' where id = 1 returning id, v")
+        .expect("UPDATE … RETURNING runs");
+    assert_eq!(result.rows_affected, 1, "one row updated");
+    assert_eq!(result.data.columns, vec!["id".to_string(), "v".to_string()]);
+    assert_eq!(result.data.rows.len(), 1);
+    // RETURNING reflects the POST-update value.
+    assert_eq!(result.data.rows[0][1], Some("new".to_string()), "modified value returned");
+}
+
+#[test]
+fn update_returning_recovers_bare_column_type() {
+    let (_project, db, _dir) = open_project_db();
+    let rt = rt();
+    create_cols(&db, &rt, "t", &[("id", Type::Int), ("active", Type::Bool)], &["id"]);
+    seed(&db, &rt, "insert into t (id, active) values (1, false)", "t");
+    let result = run_update(&db, &rt, "sql_update t set active = true where id = 1 returning active")
+        .expect("UPDATE … RETURNING active runs");
+    assert_eq!(result.data.column_types, vec![Some(Type::Bool)], "bool type recovered");
+    assert_eq!(result.data.rows[0][0], Some("true".to_string()));
+}
+
+#[test]
+fn update_returning_matching_no_rows_is_ok_and_empty() {
+    // DA gate: RETURNING makes data.columns non-empty even when no
+    // rows match (unlike the 3e column-less case). The operation
+    // succeeds with zero rows and an empty result set — no panic, no
+    // phantom row.
+    let (_project, db, _dir) = open_project_db();
+    let rt = rt();
+    create_cols(&db, &rt, "t", &[("id", Type::Int), ("v", Type::Text)], &["id"]);
+    seed(&db, &rt, "insert into t (id, v) values (1, 'keep')", "t");
+    let result = run_update(&db, &rt, "sql_update t set v = 'x' where id = 999 returning id, v")
+        .expect("no-match UPDATE … RETURNING is a success");
+    assert_eq!(result.rows_affected, 0, "no rows matched");
+    assert!(result.data.rows.is_empty(), "no rows returned");
+    assert_eq!(result.data.columns, vec!["id".to_string(), "v".to_string()], "columns still present");
+}