diff --git a/crates/cli/src/bin/corpus_report.rs b/crates/cli/src/bin/corpus_report.rs
index 8e63a52..f488b75 100644
--- a/crates/cli/src/bin/corpus_report.rs
+++ b/crates/cli/src/bin/corpus_report.rs
@@ -28,6 +28,9 @@ struct StmtStats {
     ok: usize,
     select_total: usize,
     select_ok: usize,
+    /// PL/pgSQL (dollar-quoted) bodies, parsed with the body grammar.
+    bodies_total: usize,
+    bodies_ok: usize,
 }
 
 struct FileResult {
@@ -142,6 +145,28 @@ fn run_file(source: &str, show_diagnostics: bool) -> FileResult {
         };
     }
 
+    // PL/pgSQL body coverage: parse every plpgsql dollar-quoted body.
+    if source.to_ascii_lowercase().contains("plpgsql") {
+        for token in tokens.iter().filter(|t| t.kind == SyntaxKind::DollarString) {
+            let Some(open) = token.text[1..].find('$').map(|i| i + 2) else {
+                continue;
+            };
+            let tag = &token.text[..open];
+            let Some(body) = token.text[tag.len()..].strip_suffix(tag) else {
+                continue;
+            };
+            if body.trim().is_empty() {
+                continue;
+            }
+            stmts.bodies_total += 1;
+            let body_tokens = parser::lexer::lex_with(body, Dialect::Postgres, LEX_OPTIONS);
+            let body_parse = parser::parser::parse_plpgsql_body(&body_tokens, Dialect::Postgres);
+            if body_parse.diagnostics.is_empty() {
+                stmts.bodies_ok += 1;
+            }
+        }
+    }
+
     let format_options = formatter::Options {
         at_params: true,
         ..formatter::Options::default()
@@ -226,6 +251,8 @@ fn main() -> ExitCode {
         totals.ok += result.stmts.ok;
         totals.select_total += result.stmts.select_total;
         totals.select_ok += result.stmts.select_ok;
+        totals.bodies_total += result.stmts.bodies_total;
+        totals.bodies_ok += result.stmts.bodies_ok;
         if !summary_only {
             match result.error {
                 None => println!("ok          {}", path.display()),
@@ -249,6 +276,10 @@ fn main() -> ExitCode {
         "select-ish  {:>5}/{} parsed",
         totals.select_ok, totals.select_total
     );
+    println!(
+        "pl bodies   {:>5}/{} parsed",
+        totals.bodies_ok, totals.bodies_total
+    );
     if unreadable > 0 {
         println!("unreadable: {unreadable}");
     }
diff --git a/crates/parser/src/parser.rs b/crates/parser/src/parser.rs
index c6cc5ce..34c1e51 100644
--- a/crates/parser/src/parser.rs
+++ b/crates/parser/src/parser.rs
@@ -14,6 +14,7 @@ mod ddl;
 mod dml;
 mod expr;
 mod grammar;
+mod plpgsql;
 
 use crate::dialect::Dialect;
 use crate::lexer::Token;
@@ -62,6 +63,7 @@ pub fn parse(tokens: &[Token<'_>], dialect: Dialect) -> Parse {
         dialect,
         eof,
         depth: 0,
+        in_plpgsql: false,
     };
     parser.events.push(Event::StartNode(SyntaxKind::Root));
     while !parser.at_eof() {
@@ -74,6 +76,46 @@ pub fn parse(tokens: &[Token<'_>], dialect: Dialect) -> Parse {
     }
 }
 
+/// Parse a PL/pgSQL function body (the content of a dollar-quoted
+/// `LANGUAGE plpgsql` string) into a CST of `Pl*` statement nodes.
+/// Same guarantees as [`parse`]: always lossless, never fails.
+pub fn parse_plpgsql_body(tokens: &[Token<'_>], dialect: Dialect) -> Parse {
+    let mut toks = Vec::new();
+    let mut offset = 0;
+    for token in tokens {
+        let end = offset + token.text.len();
+        if !token.kind.is_trivia() {
+            toks.push(Tok {
+                kind: token.kind,
+                text: token.text,
+                start: offset,
+                end,
+            });
+        }
+        offset = end;
+    }
+    let eof = offset;
+    let mut parser = Parser {
+        toks,
+        pos: 0,
+        events: Vec::new(),
+        diagnostics: Vec::new(),
+        dialect,
+        eof,
+        depth: 0,
+        in_plpgsql: true,
+    };
+    parser.events.push(Event::StartNode(SyntaxKind::Root));
+    while !parser.at_eof() {
+        plpgsql::body_statement(&mut parser);
+    }
+    parser.events.push(Event::FinishNode);
+    Parse {
+        cst: build_tree(tokens, &parser.events),
+        diagnostics: parser.diagnostics,
+    }
+}
+
 /// A non-trivia token with its byte span.
 struct Tok<'src> {
     kind: SyntaxKind,
@@ -103,6 +145,9 @@ pub(crate) struct Parser<'src> {
     dialect: Dialect,
     eof: usize,
     depth: u32,
+    /// Parsing a PL/pgSQL body: enables `INTO [STRICT]` targets in
+    /// query positions.
+    in_plpgsql: bool,
 }
 
 impl Parser<'_> {
@@ -150,8 +195,12 @@ impl Parser<'_> {
 
     /// Is the current token an operator with exactly this text?
     pub(crate) fn at_op(&self, op: &str) -> bool {
+        self.nth_at_op(0, op)
+    }
+
+    pub(crate) fn nth_at_op(&self, n: usize, op: &str) -> bool {
         self.toks
-            .get(self.pos)
+            .get(self.pos + n)
             .is_some_and(|t| t.kind == SyntaxKind::Operator && t.text == op)
     }
 
@@ -278,7 +327,7 @@ impl Parser<'_> {
 
     // ---- statements & recovery ----
 
-    fn statement(&mut self) {
+    pub(crate) fn statement(&mut self) {
         if self.at(SyntaxKind::Semicolon) {
             self.start(SyntaxKind::EmptyStmt);
             self.bump();
@@ -323,7 +372,7 @@ impl Parser<'_> {
     /// next top-level `;`, and record the diagnostic. Top-level means:
     /// dollar-quoted bodies are already single tokens, and in SQLite a
     /// `BEGIN ... END` trigger body does not end the statement.
-    fn error_statement(&mut self, error: StmtError) {
+    pub(crate) fn error_statement(&mut self, error: StmtError) {
         let (start, end) = match self.toks.get(error.at) {
             Some(t) => (t.start, t.end),
             None => (self.eof, self.eof),
@@ -364,6 +413,10 @@ impl Parser<'_> {
             || self.nth_kind(1).is_none()
     }
 
+    pub(crate) fn in_plpgsql(&self) -> bool {
+        self.in_plpgsql
+    }
+
     pub(crate) fn dialect(&self) -> Dialect {
         self.dialect
     }
diff --git a/crates/parser/src/parser/dml.rs b/crates/parser/src/parser/dml.rs
index 0b0fe6f..d4d7029 100644
--- a/crates/parser/src/parser/dml.rs
+++ b/crates/parser/src/parser/dml.rs
@@ -253,6 +253,9 @@ pub(crate) fn returning_clause(p: &mut Parser<'_>) -> PResult {
     p.start(SyntaxKind::ReturningClause);
     p.expect_kw("returning")?;
     select_list(p)?;
+    if p.in_plpgsql() && p.at_kw("into") {
+        super::grammar::pl_into(p)?;
+    }
     p.finish();
     Ok(())
 }
diff --git a/crates/parser/src/parser/grammar.rs b/crates/parser/src/parser/grammar.rs
index bae9ee1..9611e0a 100644
--- a/crates/parser/src/parser/grammar.rs
+++ b/crates/parser/src/parser/grammar.rs
@@ -26,6 +26,8 @@ const SELECT_ITEM_STOP: &[&str] = &[
     // INSERT ... SELECT tails.
     "on",
     "do",
+    // PL/pgSQL FOR ... IN SELECT ... LOOP.
+    "loop",
 ];
 
 /// Keywords that stop a bare table alias in FROM position.
@@ -54,6 +56,8 @@ const TABLE_ALIAS_STOP: &[&str] = &[
     "except",
     "with",
     "returning",
+    // PL/pgSQL FOR ... IN SELECT ... LOOP.
+    "loop",
 ];
 
 /// A full query statement: `[WITH ...] query [trailing clauses] [;]`.
@@ -219,6 +223,14 @@ fn query_primary_inner(p: &mut Parser<'_>) -> PResult {
 fn select_core(p: &mut Parser<'_>) -> PResult {
     p.start(SyntaxKind::SelectCore);
     p.expect_kw("select")?;
+    select_core_rest(p)?;
+    p.finish();
+    Ok(())
+}
+
+/// Everything after the `SELECT` keyword — also reused by PL/pgSQL
+/// `PERFORM`, which is SELECT syntax under another name.
+pub(crate) fn select_core_rest(p: &mut Parser<'_>) -> PResult {
     if p.at_kw("distinct") {
         p.bump();
         if p.at_kw("on") {
@@ -229,6 +241,9 @@ fn select_core(p: &mut Parser<'_>) -> PResult {
         p.eat_kw("all");
     }
     select_list(p)?;
+    if p.in_plpgsql() && p.at_kw("into") {
+        pl_into(p)?;
+    }
     if p.at_kw("from") {
         from_clause(p)?;
     }
@@ -247,6 +262,20 @@ fn select_core(p: &mut Parser<'_>) -> PResult {
     if p.at_kw("window") {
         window_clause(p)?;
     }
+    Ok(())
+}
+
+/// PL/pgSQL `INTO [STRICT] target [, ...]`.
+pub(crate) fn pl_into(p: &mut Parser<'_>) -> PResult {
+    p.start(SyntaxKind::PlInto);
+    p.expect_kw("into")?;
+    p.eat_kw("strict");
+    loop {
+        qualified_name(p)?;
+        if !p.eat(SyntaxKind::Comma) {
+            break;
+        }
+    }
     p.finish();
     Ok(())
 }
@@ -614,7 +643,7 @@ fn values_clause(p: &mut Parser<'_>) -> PResult {
     Ok(())
 }
 
-fn trailing_clauses(p: &mut Parser<'_>) -> PResult {
+pub(crate) fn trailing_clauses(p: &mut Parser<'_>) -> PResult {
     if p.at_kw("order") {
         order_by_clause(p)?;
     }
diff --git a/crates/parser/src/parser/plpgsql.rs b/crates/parser/src/parser/plpgsql.rs
new file mode 100644
index 0000000..3bf0dde
--- /dev/null
+++ b/crates/parser/src/parser/plpgsql.rs
@@ -0,0 +1,483 @@
+//! PL/pgSQL body grammar (TREE-102).
+//!
+//! A statement-level wrapper language: PL/pgSQL tokenizes exactly like
+//! SQL, and embedded SQL statements dispatch to the existing statement
+//! grammar (with `INTO [STRICT]` enabled via the parser's plpgsql flag).
+//! Every body statement gets the same rollback-to-ErrorStatement
+//! recovery as top-level SQL.
+
+use crate::syntax::SyntaxKind;
+
+use super::expr::{expr, type_name};
+use super::grammar::{pl_into, qualified_name, query_body, select_core_rest, trailing_clauses};
+use super::{PResult, Parser};
+
+/// Keywords that end a statement list inside a block construct.
+const STMT_STOP: &[&str] = &["end", "elsif", "else", "when", "exception"];
+
+/// Parse one body-level statement with error recovery.
+pub(crate) fn body_statement(p: &mut Parser<'_>) {
+    if p.at(SyntaxKind::Semicolon) {
+        p.start(SyntaxKind::EmptyStmt);
+        p.bump();
+        p.finish();
+        return;
+    }
+    let state = p.state();
+    if let Err(error) = pl_statement(p) {
+        p.backtrack(state);
+        p.error_statement(error);
+    }
+}
+
+/// A statement list that stops before block-closing keywords.
+fn pl_statements(p: &mut Parser<'_>) -> PResult {
+    while !p.at_eof() && !p.at_any_kw(STMT_STOP) {
+        body_statement(p);
+    }
+    Ok(())
+}
+
+fn pl_statement(p: &mut Parser<'_>) -> PResult {
+    p.enter_depth()?;
+    let result = pl_statement_inner(p);
+    p.exit_depth();
+    result
+}
+
+fn pl_statement_inner(p: &mut Parser<'_>) -> PResult {
+    if p.at_kw("declare") || p.at_kw("begin") || p.at_op("<<") {
+        return pl_block(p);
+    }
+    if p.at_kw("if") {
+        return pl_if(p);
+    }
+    if p.at_kw("case") {
+        return pl_case(p);
+    }
+    if p.at_any_kw(&["loop", "while", "for", "foreach"]) {
+        return pl_loop(p);
+    }
+    if p.at_kw("exit") || p.at_kw("continue") {
+        return pl_exit(p);
+    }
+    if p.at_kw("return") {
+        return pl_return(p);
+    }
+    if p.at_kw("raise") {
+        return pl_raise(p);
+    }
+    if p.at_kw("perform") {
+        return pl_perform(p);
+    }
+    if p.at_kw("execute") {
+        return pl_execute(p);
+    }
+    if p.at_kw("get") {
+        return pl_get_diagnostics(p);
+    }
+    if p.at_kw("null") && p.nth_at(1, SyntaxKind::Semicolon) {
+        p.start(SyntaxKind::PlNull);
+        p.bump();
+        p.bump();
+        p.finish();
+        return Ok(());
+    }
+    // Assignment: `name[.name][[idx]] := expr;` (also plain `=`).
+    if p.at(SyntaxKind::Ident) || p.at(SyntaxKind::QuotedIdent) {
+        let state = p.state();
+        if pl_assign(p).is_ok() {
+            return Ok(());
+        }
+        p.backtrack(state);
+    }
+    // Everything else: the regular SQL statement grammar (SELECT, DML,
+    // DDL, ...), which carries its own recovery.
+    if p.at_eof() {
+        return Err(p.error("expected a statement"));
+    }
+    p.statement();
+    Ok(())
+}
+
+/// `[<<label>>] [DECLARE decls] BEGIN stmts [EXCEPTION handlers] END
+/// [label];`
+fn pl_block(p: &mut Parser<'_>) -> PResult {
+    p.start(SyntaxKind::PlBlock);
+    if p.at_op("<<") {
+        p.bump();
+        ident(p)?;
+        if !p.at_op(">>") {
+            return Err(p.error("expected `>>`"));
+        }
+        p.bump();
+    }
+    if p.eat_kw("declare") {
+        while !p.at_kw("begin") && !p.at_eof() {
+            pl_declare(p)?;
+        }
+    }
+    p.expect_kw("begin")?;
+    pl_statements(p)?;
+    if p.at_kw("exception") {
+        p.start(SyntaxKind::PlException);
+        p.bump();
+        while p.at_kw("when") {
+            p.start(SyntaxKind::PlWhen);
+            p.bump();
+            expr(p, 0)?;
+            p.expect_kw("then")?;
+            pl_statements(p)?;
+            p.finish();
+        }
+        p.finish();
+    }
+    p.expect_kw("end")?;
+    if p.at(SyntaxKind::Ident) && !p.at_any_kw(&["if", "case", "loop"]) {
+        p.bump(); // closing label
+    }
+    end_semicolon(p)?;
+    p.finish();
+    Ok(())
+}
+
+/// `name [CONSTANT] type [NOT NULL] [{:= | = | DEFAULT} expr];` or
+/// `name ALIAS FOR $n;`
+fn pl_declare(p: &mut Parser<'_>) -> PResult {
+    p.start(SyntaxKind::PlDeclare);
+    ident(p)?;
+    if p.eat_kw("alias") {
+        p.expect_kw("for")?;
+        if !p.eat(SyntaxKind::Param) {
+            ident(p)?;
+        }
+        p.expect(SyntaxKind::Semicolon, "`;`")?;
+        p.finish();
+        return Ok(());
+    }
+    p.eat_kw("constant");
+    type_name(p)?;
+    // `%TYPE` / `%ROWTYPE` suffix.
+    if p.at_op("%") {
+        p.bump();
+        ident(p)?;
+    }
+    if p.eat_kw("not") {
+        p.expect_kw("null")?;
+    }
+    if assignment_operator(p) || p.eat_kw("default") {
+        expr(p, 0)?;
+    }
+    p.expect(SyntaxKind::Semicolon, "`;`")?;
+    p.finish();
+    Ok(())
+}
+
+fn pl_if(p: &mut Parser<'_>) -> PResult {
+    p.start(SyntaxKind::PlIf);
+    p.expect_kw("if")?;
+    expr(p, 0)?;
+    p.expect_kw("then")?;
+    pl_statements(p)?;
+    while p.at_kw("elsif") {
+        p.start(SyntaxKind::PlElsif);
+        p.bump();
+        expr(p, 0)?;
+        p.expect_kw("then")?;
+        pl_statements(p)?;
+        p.finish();
+    }
+    if p.at_kw("else") {
+        p.start(SyntaxKind::PlElse);
+        p.bump();
+        pl_statements(p)?;
+        p.finish();
+    }
+    p.expect_kws(&["end", "if"])?;
+    end_semicolon(p)?;
+    p.finish();
+    Ok(())
+}
+
+fn pl_case(p: &mut Parser<'_>) -> PResult {
+    p.start(SyntaxKind::PlCase);
+    p.expect_kw("case")?;
+    if !p.at_kw("when") {
+        expr(p, 0)?;
+    }
+    while p.at_kw("when") {
+        p.start(SyntaxKind::PlWhen);
+        p.bump();
+        loop {
+            expr(p, 0)?;
+            if !p.eat(SyntaxKind::Comma) {
+                break;
+            }
+        }
+        p.expect_kw("then")?;
+        pl_statements(p)?;
+        p.finish();
+    }
+    if p.at_kw("else") {
+        p.start(SyntaxKind::PlElse);
+        p.bump();
+        pl_statements(p)?;
+        p.finish();
+    }
+    p.expect_kws(&["end", "case"])?;
+    end_semicolon(p)?;
+    p.finish();
+    Ok(())
+}
+
+fn pl_loop(p: &mut Parser<'_>) -> PResult {
+    let kind = if p.at_kw("loop") {
+        SyntaxKind::PlLoop
+    } else if p.at_kw("while") {
+        SyntaxKind::PlWhile
+    } else if p.at_kw("for") {
+        SyntaxKind::PlFor
+    } else {
+        SyntaxKind::PlForeach
+    };
+    p.start(kind);
+    match kind {
+        SyntaxKind::PlLoop => {
+            p.bump();
+        }
+        SyntaxKind::PlWhile => {
+            p.bump();
+            expr(p, 0)?;
+            p.expect_kw("loop")?;
+        }
+        SyntaxKind::PlFor => {
+            p.bump();
+            loop {
+                ident(p)?;
+                if !p.eat(SyntaxKind::Comma) {
+                    break;
+                }
+            }
+            p.expect_kw("in")?;
+            p.eat_kw("reverse");
+            if p.at_any_kw(&["select", "with", "values"]) || p.at(SyntaxKind::LParen) {
+                query_body(p)?;
+            } else if p.at_kw("execute") {
+                pl_execute_tail(p)?;
+            } else {
+                // Integer range: `expr .. expr [BY expr]`. The lexer may
+                // fold `..10` into a single `.10`-style number; accept
+                // both shapes.
+                expr(p, 0)?;
+                if p.at(SyntaxKind::Dot) {
+                    p.bump();
+                    p.eat(SyntaxKind::Dot);
+                    if !p.at_kw("loop") && !p.at_kw("by") {
+                        expr(p, 0)?;
+                    }
+                }
+                if p.eat_kw("by") {
+                    expr(p, 0)?;
+                }
+            }
+            p.expect_kw("loop")?;
+        }
+        _ => {
+            // FOREACH target [SLICE n] IN ARRAY expr
+            p.bump();
+            qualified_name(p)?;
+            if p.eat_kw("slice") {
+                expr(p, 0)?;
+            }
+            p.expect_kws(&["in", "array"])?;
+            expr(p, 0)?;
+            p.expect_kw("loop")?;
+        }
+    }
+    pl_statements(p)?;
+    p.expect_kws(&["end", "loop"])?;
+    if p.at(SyntaxKind::Ident) {
+        p.bump(); // closing label
+    }
+    end_semicolon(p)?;
+    p.finish();
+    Ok(())
+}
+
+fn pl_exit(p: &mut Parser<'_>) -> PResult {
+    p.start(SyntaxKind::PlExit);
+    p.bump(); // EXIT | CONTINUE
+    if p.at(SyntaxKind::Ident) && !p.at_kw("when") {
+        p.bump(); // label
+    }
+    if p.eat_kw("when") {
+        expr(p, 0)?;
+    }
+    p.expect(SyntaxKind::Semicolon, "`;`")?;
+    p.finish();
+    Ok(())
+}
+
+fn pl_return(p: &mut Parser<'_>) -> PResult {
+    p.start(SyntaxKind::PlReturn);
+    p.expect_kw("return")?;
+    if p.eat(SyntaxKind::Semicolon) {
+        p.finish();
+        return Ok(());
+    }
+    if p.eat_kw("next") {
+        expr(p, 0)?;
+    } else if p.eat_kw("query") {
+        if p.at_kw("execute") {
+            pl_execute_tail(p)?;
+        } else {
+            query_body(p)?;
+        }
+    } else {
+        expr(p, 0)?;
+    }
+    p.expect(SyntaxKind::Semicolon, "`;`")?;
+    p.finish();
+    Ok(())
+}
+
+const RAISE_LEVELS: &[&str] = &["debug", "log", "info", "notice", "warning", "exception"];
+
+fn pl_raise(p: &mut Parser<'_>) -> PResult {
+    p.start(SyntaxKind::PlRaise);
+    p.expect_kw("raise")?;
+    if p.at_any_kw(RAISE_LEVELS) {
+        p.bump();
+    }
+    if !p.at(SyntaxKind::Semicolon) && !p.at_kw("using") {
+        // Format string / condition name / SQLSTATE, plus arguments.
+        expr(p, 0)?;
+        while p.eat(SyntaxKind::Comma) {
+            expr(p, 0)?;
+        }
+    }
+    if p.eat_kw("using") {
+        loop {
+            ident(p)?;
+            if !p.at_op("=") {
+                return Err(p.error("expected `=`"));
+            }
+            p.bump();
+            expr(p, 0)?;
+            if !p.eat(SyntaxKind::Comma) {
+                break;
+            }
+        }
+    }
+    p.expect(SyntaxKind::Semicolon, "`;`")?;
+    p.finish();
+    Ok(())
+}
+
+fn pl_perform(p: &mut Parser<'_>) -> PResult {
+    p.start(SyntaxKind::PlPerform);
+    p.expect_kw("perform")?;
+    // PERFORM is SELECT under another name, trailing clauses included
+    // (`PERFORM 1 FROM t FOR UPDATE`, `... LIMIT 1`).
+    select_core_rest(p)?;
+    trailing_clauses(p)?;
+    p.expect(SyntaxKind::Semicolon, "`;`")?;
+    p.finish();
+    Ok(())
+}
+
+fn pl_execute(p: &mut Parser<'_>) -> PResult {
+    p.start(SyntaxKind::PlExecute);
+    pl_execute_tail(p)?;
+    p.expect(SyntaxKind::Semicolon, "`;`")?;
+    p.finish();
+    Ok(())
+}
+
+/// `EXECUTE expr [INTO [STRICT] targets] [USING exprs]` without the `;`
+/// (also used by FOR ... IN EXECUTE and RETURN QUERY EXECUTE).
+fn pl_execute_tail(p: &mut Parser<'_>) -> PResult {
+    p.expect_kw("execute")?;
+    expr(p, 0)?;
+    if p.at_kw("into") {
+        pl_into(p)?;
+    }
+    if p.eat_kw("using") {
+        loop {
+            expr(p, 0)?;
+            if !p.eat(SyntaxKind::Comma) {
+                break;
+            }
+        }
+    }
+    Ok(())
+}
+
+fn pl_get_diagnostics(p: &mut Parser<'_>) -> PResult {
+    p.start(SyntaxKind::PlGetDiag);
+    p.expect_kw("get")?;
+    p.eat_kw("stacked");
+    p.expect_kw("diagnostics")?;
+    loop {
+        qualified_name(p)?;
+        if !assignment_operator(p) {
+            return Err(p.error("expected `:=` or `=`"));
+        }
+        ident(p)?;
+        if !p.eat(SyntaxKind::Comma) {
+            break;
+        }
+    }
+    p.expect(SyntaxKind::Semicolon, "`;`")?;
+    p.finish();
+    Ok(())
+}
+
+/// `target := expr;` — target may be qualified and subscripted.
+fn pl_assign(p: &mut Parser<'_>) -> PResult {
+    p.start(SyntaxKind::PlAssign);
+    qualified_name(p)?;
+    while p.at(SyntaxKind::LBracket) {
+        p.bump();
+        expr(p, 0)?;
+        p.expect(SyntaxKind::RBracket, "`]`")?;
+    }
+    if !assignment_operator(p) {
+        return Err(p.error("expected `:=` or `=`"));
+    }
+    expr(p, 0)?;
+    p.expect(SyntaxKind::Semicolon, "`;`")?;
+    p.finish();
+    Ok(())
+}
+
+/// Eat `:=` (Colon + `=`) or plain `=`; false if neither.
+fn assignment_operator(p: &mut Parser<'_>) -> bool {
+    if p.at(SyntaxKind::Colon) && p.nth_at_op(1, "=") {
+        p.bump();
+        p.bump();
+        true
+    } else if p.at_op("=") {
+        p.bump();
+        true
+    } else {
+        false
+    }
+}
+
+/// The body's outermost END often has no trailing `;` before EOF.
+fn end_semicolon(p: &mut Parser<'_>) -> PResult {
+    if !p.at_eof() {
+        p.expect(SyntaxKind::Semicolon, "`;`")?;
+    }
+    Ok(())
+}
+
+fn ident(p: &mut Parser<'_>) -> PResult {
+    if p.at(SyntaxKind::Ident) || p.at(SyntaxKind::QuotedIdent) {
+        p.bump();
+        Ok(())
+    } else {
+        Err(p.error("expected a name"))
+    }
+}
diff --git a/crates/parser/syntax.def b/crates/parser/syntax.def
index 19fb20b..e0ab2dd 100644
--- a/crates/parser/syntax.def
+++ b/crates/parser/syntax.def
@@ -69,6 +69,31 @@ node OnConflictClause
 node ReturningClause
 node UsingClause
 
+# ---- PL/pgSQL (function-body statements) ----
+
+node PlBlock
+node PlDeclare
+node PlIf
+node PlElsif
+node PlElse
+node PlCase
+node PlWhen
+node PlLoop
+node PlWhile
+node PlFor
+node PlForeach
+node PlExit
+node PlReturn
+node PlRaise
+node PlAssign
+node PlPerform
+node PlExecute
+node PlGetDiag
+node PlNull
+node PlException
+# `INTO [STRICT] targets` inside body SQL (SELECT/RETURNING/EXECUTE).
+node PlInto
+
 # ---- DDL and utility statements ----
 
 # Structured-but-tolerant DDL: leading keywords, top-level commas split
diff --git a/crates/parser/tests/plpgsql.rs b/crates/parser/tests/plpgsql.rs
new file mode 100644
index 0000000..56957c5
--- /dev/null
+++ b/crates/parser/tests/plpgsql.rs
@@ -0,0 +1,195 @@
+//! TREE-102: PL/pgSQL body grammar — unit coverage and all corpus
+//! bodies.
+
+use std::path::{Path, PathBuf};
+
+use parser::Dialect;
+use parser::lexer::lex;
+use parser::parser::parse_plpgsql_body;
+
+#[track_caller]
+fn parse_ok(body: &str) {
+    let tokens = lex(body, Dialect::Postgres);
+    let parse = parse_plpgsql_body(&tokens, Dialect::Postgres);
+    assert_eq!(parse.cst.text(), body, "round-trip failed");
+    assert!(
+        parse.diagnostics.is_empty(),
+        "diagnostics for {body:?}: {:?}",
+        parse.diagnostics
+    );
+}
+
+#[test]
+fn blocks_and_declarations() {
+    parse_ok(
+        "DECLARE\n\
+         \tcount integer := 0;\n\
+         \tname text NOT NULL DEFAULT 'x';\n\
+         \trec users%ROWTYPE;\n\
+         \tv_id users.id%TYPE;\n\
+         \targ ALIAS FOR $1;\n\
+         BEGIN\n\
+         \tRETURN count;\n\
+         END;",
+    );
+    parse_ok("BEGIN NULL; END");
+    parse_ok("<<outer>> BEGIN NULL; END outer;");
+    parse_ok("BEGIN BEGIN NULL; END; END;");
+}
+
+#[test]
+fn control_flow() {
+    parse_ok(
+        "BEGIN\n\
+         IF a > 1 THEN RETURN 1;\n\
+         ELSIF a > 0 THEN RETURN 0;\n\
+         ELSE RETURN -1;\n\
+         END IF;\n\
+         END;",
+    );
+    parse_ok(
+        "BEGIN\n\
+         CASE x WHEN 1, 2 THEN NULL; ELSE NULL; END CASE;\n\
+         CASE WHEN x > 0 THEN NULL; END CASE;\n\
+         END;",
+    );
+    parse_ok(
+        "BEGIN\n\
+         LOOP EXIT WHEN done; END LOOP;\n\
+         WHILE i < 10 LOOP i := i + 1; END LOOP;\n\
+         FOR i IN 1..10 LOOP CONTINUE WHEN i = 5; END LOOP;\n\
+         FOR i IN REVERSE 10..1 BY 2 LOOP NULL; END LOOP;\n\
+         FOR r IN SELECT id FROM users LOOP PERFORM audit(r.id); END LOOP;\n\
+         FOREACH v IN ARRAY arr LOOP NULL; END LOOP;\n\
+         END;",
+    );
+}
+
+#[test]
+fn statements() {
+    parse_ok(
+        "BEGIN\n\
+         x := 1;\n\
+         y.z = 'two';\n\
+         arr[1] := 3;\n\
+         PERFORM pg_notify('chan', payload::text);\n\
+         EXECUTE format('DROP TABLE %I', tbl) USING a, b;\n\
+         EXECUTE 'SELECT count(*) FROM t' INTO STRICT n;\n\
+         GET DIAGNOSTICS n = ROW_COUNT;\n\
+         RAISE NOTICE 'value is %', x;\n\
+         RAISE EXCEPTION 'bad % and %', a, b USING ERRCODE = 'P0001', HINT = 'no';\n\
+         RAISE;\n\
+         RETURN NEXT r;\n\
+         RETURN QUERY SELECT * FROM t;\n\
+         RETURN QUERY EXECUTE 'SELECT 1';\n\
+         RETURN;\n\
+         END;",
+    );
+}
+
+#[test]
+fn embedded_sql_with_into() {
+    parse_ok(
+        "BEGIN\n\
+         SELECT id, name INTO STRICT v_id, v_name FROM users WHERE id = uid;\n\
+         INSERT INTO audit (kind) VALUES ('x') RETURNING id INTO aid;\n\
+         UPDATE t SET n = n + 1 WHERE id = 1;\n\
+         DELETE FROM t WHERE id = 2;\n\
+         CREATE TEMP TABLE scratch (id int);\n\
+         END;",
+    );
+}
+
+#[test]
+fn exception_handlers() {
+    parse_ok(
+        "BEGIN\n\
+         INSERT INTO t VALUES (1);\n\
+         EXCEPTION\n\
+         WHEN unique_violation THEN NULL;\n\
+         WHEN OTHERS THEN\n\
+         RAISE WARNING 'oops: %', SQLERRM;\n\
+         RETURN false;\n\
+         END;",
+    );
+}
+
+#[test]
+fn recovery_keeps_tokens() {
+    let body = "BEGIN\nFROBNICATE badly here;\nRETURN 1;\nEND;";
+    let tokens = lex(body, Dialect::Postgres);
+    let parse = parse_plpgsql_body(&tokens, Dialect::Postgres);
+    assert_eq!(parse.cst.text(), body, "recovery must be lossless");
+    assert!(!parse.diagnostics.is_empty());
+}
+
+// ---- corpus ----
+
+fn collect_sql_files(dir: &Path, out: &mut Vec<PathBuf>) {
+    for entry in std::fs::read_dir(dir).expect("read dir") {
+        let path = entry.expect("entry").path();
+        if path.is_dir() {
+            collect_sql_files(&path, out);
+        } else if path.extension().is_some_and(|ext| ext == "sql") {
+            out.push(path);
+        }
+    }
+}
+
+/// Every `LANGUAGE plpgsql` dollar-quoted body in the corpus parses with
+/// zero error statements and round-trips losslessly.
+#[test]
+fn corpus_plpgsql_bodies_parse() {
+    let root = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../corpus");
+    let mut files = Vec::new();
+    collect_sql_files(&root, &mut files);
+    files.sort();
+
+    let mut bodies = 0;
+    let mut failures = Vec::new();
+    for path in files {
+        let source = std::fs::read_to_string(&path).expect("read corpus file");
+        if !source.to_ascii_lowercase().contains("plpgsql") {
+            continue;
+        }
+        let tokens = lex(&source, Dialect::Postgres);
+        for token in tokens
+            .iter()
+            .filter(|t| t.kind == parser::syntax::SyntaxKind::DollarString)
+        {
+            let Some(open) = token.text[1..].find('$').map(|i| i + 2) else {
+                continue;
+            };
+            let tag = &token.text[..open];
+            let Some(body) = token.text[tag.len()..].strip_suffix(tag) else {
+                continue;
+            };
+            if body.trim().is_empty() {
+                continue;
+            }
+            bodies += 1;
+            let body_tokens = lex(body, Dialect::Postgres);
+            let parse = parse_plpgsql_body(&body_tokens, Dialect::Postgres);
+            assert_eq!(
+                parse.cst.text(),
+                body,
+                "round-trip failed in {}",
+                path.display()
+            );
+            if !parse.diagnostics.is_empty() {
+                failures.push(format!(
+                    "{}: {}",
+                    path.display(),
+                    parse.diagnostics[0].message
+                ));
+            }
+        }
+    }
+    assert!(bodies >= 70, "expected at least 70 bodies, found {bodies}");
+    assert!(
+        failures.is_empty(),
+        "{} of {bodies} bodies failed:\n{}",
+        failures.len(),
+        failures.join("\n")
+    );
+}