@lzehrung/codegraph 3.0.1 → 3.1.1

package/dist/sql/extract-facts.js

@@ -1,8 +1,10 @@
 import { collectLineStartOffsets } from "../util/lines.js";
 import { normalizePath } from "../util/paths.js";
 import { classifySqlFile } from "./classify-sql-file.js";
-import { createSqlObjectNameRegExp, maskSqlStringsAndComments, normalizeSqlObjectName, SQL_OBJECT_NAME_PATTERN, splitTopLevelCommaSeparated, sqlParenDepthAt, } from "./lex.js";
+import { atForward, createSqlObjectNameRegExp, isBareSqlKeyword, maskSqlQuotedIdentifiers, maskSqlStringsAndComments, normalizeSqlObjectName, sqlObjectLookupKey, SQL_OBJECT_NAME_PATTERN, splitTopLevelCommaSeparated, sqlParenDepthAt, sqlMatchingParen as findMatchingParen, sqlQueryScopes, sqlSourceClauses, sqlTriviaBoundaries, } from "./lex.js";
 import { sqlObjectLookupKeys } from "./lookup.js";
+import { SQL_ROUTINE_DEFINITION_RE } from "./routine-mentions.js";
+import { skipWhitespace } from "../util/text-scanning.js";
 export { maskSqlStringsAndComments, normalizeSqlObjectName, sqlObjectBaseName } from "./lex.js";
 const OBJECT_NAME_RE = createSqlObjectNameRegExp("iy");
 const SQL_KEYWORDS = new Set([
@@ -71,20 +73,339 @@ function statementSlice(source, lineStarts, start, end) {
         endIndex,
     };
 }
-function splitSqlStatements(source) {
+/** Words that can follow END in `END LOOP` or `END CASE`. Anything else is a plain END. */
+const SQL_END_FOLLOWER = new Set(["case", "for", "if", "loop", "repeat", "while"]);
+function readBareWord(text, index) {
+    if (!/[A-Za-z_]/.test(text[index] ?? ""))
+        return null;
+    let end = index + 1;
+    while (/[A-Za-z0-9_$]/.test(text[end] ?? ""))
+        end += 1;
+    return { word: text.slice(index, end).toLowerCase(), end };
+}
+/** A bare or quoted identifier: the optional label in `END LOOP label` or `END CASE label`. */
+function identifierEnd(text, index) {
+    const open = text[index] ?? "";
+    if (open === '"' || open === "`" || open === "[") {
+        const close = open === "[" ? "]" : open;
+        let cursor = index + 1;
+        while (cursor < text.length) {
+            if ((text[cursor] ?? "") !== close) {
+                cursor += 1;
+                continue;
+            }
+            if ((text[cursor + 1] ?? "") === close) {
+                cursor += 2;
+                continue;
+            }
+            return cursor + 1;
+        }
+        return null;
+    }
+    if (!/[A-Za-z_]/.test(open))
+        return null;
+    let end = index + 1;
+    while (/[A-Za-z0-9_$]/.test(text[end] ?? ""))
+        end += 1;
+    return end;
+}
+/** `;`, or no further significant token, completes `END LOOP [label]` and `END CASE [label]`. */
+function finishesCompound(text, index, trivia) {
+    const next = atForward(trivia, index);
+    return next >= text.length || (text[next] ?? "") === ";";
+}
+/** `GO` on its own line is a batch separator, not the label of an `END LOOP`. */
+function isOwnLineGo(text, index) {
+    if (readBareWord(text, index)?.word !== "go")
+        return false;
+    let lineStart = index;
+    while (lineStart > 0 && (text[lineStart - 1] ?? "") !== "\n")
+        lineStart -= 1;
+    return /^[\t ]*go(?:[\t ]*(?:--[^\r\n]*)?)?(?:\r?\n|$)/i.test(text.slice(lineStart));
+}
+/**
+ * `END CASE` closes a CASE wherever it sits. `END IF|LOOP|WHILE|REPEAT|FOR` closes nothing
+ * only when the innermost frame is BEGIN or the stack is empty. An open CASE makes the same
+ * words the end of that expression: `END loop` is an alias, and `END FOR UPDATE` is a clause.
+ */
+function compoundEndAction(keyword, innermost) {
+    if (keyword === "case")
+        return "case";
+    if (innermost === "case")
+        return "close";
+    return "noop";
+}
+/**
+ * `END CASE [label]` then `;` or the end of the text closes the innermost CASE. The same shape of
+ * `END IF|LOOP|WHILE|REPEAT|FOR [label]` closes nothing when the innermost frame is BEGIN or the
+ * stack is empty, and closes the CASE when that is the innermost frame. Any other END, including
+ * T-SQL `END IF @x` with no semicolon after IF, closes the innermost frame. The returned index
+ * stops before the semicolon so the statement scan can still split on it.
+ */
+function classifyEnd(text, endWordEnd, trivia, innermost) {
+    const close = { action: "close", resume: endWordEnd };
+    const keywordAt = atForward(trivia, endWordEnd);
+    if (isOwnLineGo(text, keywordAt))
+        return close;
+    const keyword = readBareWord(text, keywordAt);
+    if (!keyword || !SQL_END_FOLLOWER.has(keyword.word))
+        return close;
+    if (!isBareSqlKeyword(text, keywordAt, keyword.end, trivia))
+        return close;
+    const action = compoundEndAction(keyword.word, innermost);
+    if (finishesCompound(text, keyword.end, trivia)) {
+        return { action, resume: keyword.end };
+    }
+    const labelAt = atForward(trivia, keyword.end);
+    if (isOwnLineGo(text, labelAt))
+        return close;
+    const labelEnd = identifierEnd(text, labelAt);
+    if (labelEnd === null || !finishesCompound(text, labelEnd, trivia))
+        return close;
+    return { action, resume: labelEnd };
+}
+function closeInnermostCase(stack) {
+    for (let index = stack.length - 1; index >= 0; index -= 1) {
+        if (stack[index] !== "case")
+            continue;
+        stack.length = index;
+        return;
+    }
+}
+/**
+ * Bare BEGIN and bare CASE open a frame. The bare-keyword check, using this scan's trivia
+ * table, leaves `t.case`, `@case`, a quoted name, and `CASE .5` as ordinary tokens.
+ */
+function advanceSqlBlockWord(text, index, stack, trivia) {
+    const read = readBareWord(text, index);
+    if (!read)
+        return index + 1;
+    if (!isBareSqlKeyword(text, index, read.end, trivia))
+        return read.end;
+    if (read.word === "begin" || read.word === "case") {
+        stack.push(read.word);
+        return read.end;
+    }
+    if (read.word !== "end")
+        return read.end;
+    const classified = classifyEnd(text, read.end, trivia, stack[stack.length - 1]);
+    if (classified.action === "case")
+        closeInnermostCase(stack);
+    else if (classified.action === "close")
+        stack.pop();
+    return classified.resume;
+}
+/** MySQL allows one compound statement, with no BEGIN, as the body of a routine. */
+const COMPOUND_BODY_WORDS = new Set(["case", "if", "loop", "repeat", "while"]);
+/**
+ * Words that can sit between the parameter list and that body: `RETURNS integer`,
+ * `DETERMINISTIC`, `LANGUAGE SQL`, and the other MySQL characteristics.
+ */
+const ROUTINE_CHARACTERISTICS = new Set([
+    "comment",
+    "contains",
+    "data",
+    "definer",
+    "deterministic",
+    "invoker",
+    "modifies",
+    "no",
+    "not",
+    "null",
+    "reads",
+    "security",
+    "sql",
+]);
+/** A nested compound of the same keyword starts after one of these, or after a semicolon. */
+const COMPOUND_NEST_WORDS = new Set(["begin", "do", "else", "elseif", "loop", "repeat", "then"]);
+/** Words that mean the body is not a bare compound statement. */
+const ROUTINE_BODY_STOP = new Set([
+    "as",
+    "begin",
+    "call",
+    "declare",
+    "delete",
+    "insert",
+    "perform",
+    "return",
+    "select",
+    "update",
+]);
+/**
+ * When a CREATE PROCEDURE or FUNCTION has a parameter list and the next bare token, after
+ * characteristics, is IF, LOOP, REPEAT, WHILE, or CASE, `depth` counts that keyword only.
+ * `END` plus the same keyword closes one level. Null when this routine has no such body.
+ */
+function scanRoutineCompound(code, trivia, start, end) {
+    let phase = "start";
+    let paramDepth = 0;
+    let typeDepth = 0;
+    let keyword = "";
+    let keywordEnd = -1;
+    let depth = 0;
+    let prevWord = "";
+    let prevWasSemi = false;
+    let index = start;
+    while (index < end) {
+        const char = code[index] ?? "";
+        if (char === "(") {
+            if (phase === "name" || phase === "after-name") {
+                phase = "params";
+                paramDepth = 1;
+            }
+            else if (phase === "params")
+                paramDepth += 1;
+            else if (phase === "type")
+                typeDepth += 1;
+            index += 1;
+            continue;
+        }
+        if (char === ")") {
+            if (phase === "params" && paramDepth > 0) {
+                paramDepth -= 1;
+                if (paramDepth === 0)
+                    phase = "chars";
+            }
+            else if (phase === "type" && typeDepth > 0)
+                typeDepth -= 1;
+            index += 1;
+            continue;
+        }
+        if (char === ";") {
+            prevWasSemi = true;
+            prevWord = "";
+            index += 1;
+            continue;
+        }
+        if (char === "." && phase === "after-name") {
+            phase = "name";
+            index += 1;
+            continue;
+        }
+        if (!/[A-Za-z_]/.test(char)) {
+            index += 1;
+            continue;
+        }
+        const read = readBareWord(code, index);
+        if (!read) {
+            index += 1;
+            continue;
+        }
+        if (phase === "name") {
+            phase = "after-name";
+            index = read.end;
+            continue;
+        }
+        if (!isBareSqlKeyword(code, index, read.end, trivia)) {
+            index = read.end;
+            continue;
+        }
+        const word = read.word;
+        index = read.end;
+        if (phase === "params")
+            continue;
+        if (phase === "language") {
+            phase = "chars";
+            prevWord = word;
+            prevWasSemi = false;
+            continue;
+        }
+        if (phase === "type" && typeDepth > 0)
+            continue;
+        if (phase === "chars" || phase === "type") {
+            if (typeDepth === 0 && COMPOUND_BODY_WORDS.has(word)) {
+                keyword = word;
+                keywordEnd = index;
+                depth = 1;
+                phase = "body";
+            }
+            else if (word === "returns")
+                phase = "type";
+            else if (word === "language")
+                phase = "language";
+            else if (ROUTINE_CHARACTERISTICS.has(word))
+                phase = "chars";
+            else if (phase === "type" && !ROUTINE_BODY_STOP.has(word)) {
+                // A type word: integer, unsigned, varying, precision.
+            }
+            else
+                return null;
+            prevWord = word;
+            prevWasSemi = false;
+            continue;
+        }
+        if (phase === "body") {
+            if (word === "end") {
+                const followerAt = atForward(trivia, index);
+                const follower = followerAt < end ? readBareWord(code, followerAt) : null;
+                if (follower &&
+                    follower.end <= end &&
+                    follower.word === keyword &&
+                    isBareSqlKeyword(code, followerAt, follower.end, trivia)) {
+                    depth -= 1;
+                    index = follower.end;
+                    prevWord = follower.word;
+                    prevWasSemi = false;
+                    continue;
+                }
+            }
+            else if (word === keyword && (prevWasSemi || COMPOUND_NEST_WORDS.has(prevWord))) {
+                depth += 1;
+            }
+            prevWord = word;
+            prevWasSemi = false;
+            continue;
+        }
+        if (phase === "start")
+            phase = word === "create" ? "create" : "start";
+        else if (phase === "create") {
+            if (word === "or")
+                phase = "or";
+            else if (word === "procedure" || word === "function")
+                phase = "name";
+            else
+                return null;
+        }
+        else if (phase === "or")
+            phase = word === "replace" ? "replace" : "start";
+        else if (phase === "replace")
+            phase = word === "procedure" || word === "function" ? "name" : "start";
+        if (phase === "start" || phase === "after-name")
+            return null;
+        prevWord = word;
+        prevWasSemi = false;
+    }
+    if (phase !== "body" || keywordEnd < 0)
+        return null;
+    return { keywordEnd, depth };
+}
+/**
+ * Splits SQL text into statements. PostgreSQL and SQL Server let a block comment hold block comments,
+ * which `nestedComments` reads. Without it, a block comment ends at its first closing delimiter.
+ */
+function scanSqlStatements(source, nestedComments) {
+    // Block keywords use trivia boundaries from this mask, so each look is one table read.
+    // A dash-dash inside a quote is already blank and cannot be read as a line comment.
+    const masked = maskSqlStringsAndComments(source, {
+        nestedBlockComments: nestedComments,
+        escapeStrings: true,
+    });
+    const code = maskSqlQuotedIdentifiers(masked);
+    const trivia = sqlTriviaBoundaries(masked);
     const statements = [];
     const lineStarts = lineStartsFor(source);
     let start = 0;
     let lineStart = 0;
     let i = 0;
     let lookingForStatementStart = true;
-    let blockDepth = 0;
+    const openBlocks = [];
     let singleQuoted = false;
+    let escapeString = false;
     let doubleQuoted = false;
     let backtickQuoted = false;
     let bracketQuoted = false;
     let lineComment = false;
-    let blockComment = false;
+    let commentDepth = 0;
     let dollarQuote = null;
     const pushStatement = (end, nextStart = end + 1) => {
         const statement = statementSlice(source, lineStarts, start, end);
@@ -110,11 +431,16 @@ function splitSqlStatements(source) {
             i += 1;
             continue;
         }
-        if (blockComment) {
+        if (commentDepth) {
+            if (nestedComments && char === "/" && next === "*") {
+                commentDepth += 1;
+                i += 2;
+                continue;
+            }
             if (char === "*" && next === "/") {
-                blockComment = false;
+                commentDepth -= 1;
                 i += 2;
-                if (lookingForStatementStart) {
+                if (!commentDepth && lookingForStatementStart) {
                     start = i;
                 }
                 continue;
@@ -122,16 +448,11 @@ function splitSqlStatements(source) {
             i += 1;
             continue;
         }
-        if (i === lineStart &&
-            !blockDepth &&
-            !singleQuoted &&
-            !doubleQuoted &&
-            !backtickQuoted &&
-            !bracketQuoted &&
-            !dollarQuote) {
+        if (i === lineStart && !singleQuoted && !doubleQuoted && !backtickQuoted && !bracketQuoted && !dollarQuote) {
             const batchSeparator = source.slice(i).match(/^[\t ]*GO(?:[\t ]*(?:--[^\r\n]*)?)?(?:\r?\n|$)/i);
             if (batchSeparator?.[0]) {
                 const nextStart = i + batchSeparator[0].length;
+                openBlocks.length = 0;
                 pushStatement(i, nextStart);
                 i = nextStart;
                 lineStart = nextStart;
@@ -150,7 +471,7 @@ function splitSqlStatements(source) {
                 continue;
             }
             if (char === "/" && next === "*") {
-                blockComment = true;
+                commentDepth = 1;
                 i += 2;
                 continue;
             }
@@ -167,12 +488,18 @@ function splitSqlStatements(source) {
             continue;
         }
         if (singleQuoted) {
+            if (escapeString && char === "\\" && next) {
+                i += 2;
+                continue;
+            }
             if (char === "'" && next === "'") {
                 i += 2;
                 continue;
             }
-            if (char === "'")
+            if (char === "'") {
                 singleQuoted = false;
+                escapeString = false;
+            }
             i += 1;
             continue;
         }
@@ -204,12 +531,14 @@ function splitSqlStatements(source) {
             continue;
         }
         if (char === "/" && next === "*") {
-            blockComment = true;
+            commentDepth = 1;
             i += 2;
             continue;
         }
         if (char === "'") {
             singleQuoted = true;
+            // Only PostgreSQL E'...' strings give backslashes special meaning.
+            escapeString = /[eE]/.test(source[i - 1] ?? "") && !/[\w$]/.test(source[i - 2] ?? "");
             i += 1;
             continue;
         }
@@ -237,36 +566,33 @@ function splitSqlStatements(source) {
             }
         }
         if (/[A-Za-z_]/.test(char)) {
-            let wordEnd = i + 1;
-            while (/[A-Za-z0-9_$]/.test(source[wordEnd] ?? "")) {
-                wordEnd += 1;
-            }
-            const word = source.slice(i, wordEnd).toLowerCase();
-            if (word === "begin")
-                blockDepth += 1;
-            if (word === "end" && blockDepth)
-                blockDepth -= 1;
-            i = wordEnd;
+            i = advanceSqlBlockWord(masked, i, openBlocks, trivia);
             continue;
         }
-        if (char === ";" && !blockDepth) {
-            pushStatement(i);
+        // A compound routine body stays one statement until its own END keyword. BEGIN and CASE
+        // frames are unchanged, and a qualified name such as t.if is not that keyword.
+        if (char === ";" && openBlocks.length === 0) {
+            const compound = scanRoutineCompound(code, trivia, start, i);
+            if (!compound || compound.depth <= 0)
+                pushStatement(i);
         }
         i += 1;
     }
     const tail = statementSlice(source, lineStarts, start, source.length);
     if (tail)
         statements.push(tail);
-    return statements;
+    return { statements, endsInBlockComment: commentDepth > 0 };
 }
-const SQL_OBJECT_MODIFIERS = new Set(["lateral", "only"]);
-function skipWhitespace(text, index) {
-    let nextIndex = index;
-    while (nextIndex < text.length && /\s/.test(text[nextIndex] ?? "")) {
-        nextIndex += 1;
-    }
-    return nextIndex;
+/**
+ * PostgreSQL and SQL Server nest block comments; MySQL, SQLite, and Oracle end one at its first closing
+ * delimiter, and the text does not say which it is. It reads as nested unless a comment then never
+ * closes, which no PostgreSQL or SQL Server text does. Such text reads the way MySQL does.
+ */
+function splitSqlStatements(source) {
+    const nested = scanSqlStatements(source, true);
+    return nested.endsInBlockComment ? scanSqlStatements(source, false).statements : nested.statements;
 }
+const SQL_OBJECT_MODIFIERS = new Set(["lateral", "only"]);
 function objectAt(text, index, skipModifiers = SQL_OBJECT_MODIFIERS) {
     let cursor = skipWhitespace(text, index);
     while (cursor < text.length) {
@@ -302,41 +628,38 @@ function collectObjectsAfterKeywords(text, keywords, opts) {
     }
     return Array.from(new Set(names));
 }
-function clauseEndIndex(text, start) {
-    const rest = text.slice(start);
-    const boundary = rest.search(/\b(?:where|group\s+by|order\s+by|having|limit|offset|returning|union|intersect|except|inner\s+join|left\s+join|right\s+join|full\s+join|cross\s+join|join)\b/i);
-    return boundary < 0 ? text.length : start + boundary;
-}
-function collectCommaSeparatedObjectsAfterKeywords(text, keywords) {
+function collectReadSources(text) {
+    const scan = maskSqlQuotedIdentifiers(text);
+    const trivia = sqlTriviaBoundaries(scan);
+    const scopes = sqlQueryScopes(scan, trivia);
     const names = [];
-    const keywordPattern = keywords.map((keyword) => keyword.replace(/\s+/g, String.raw `\s+`)).join("|");
-    const re = new RegExp(String.raw `\b(?:${keywordPattern})\s+`, "gi");
-    for (const match of text.matchAll(re)) {
-        if (sqlParenDepthAt(text, match.index ?? 0) > 0)
-            continue;
-        const start = (match.index ?? 0) + match[0].length;
-        const clause = text.slice(start, clauseEndIndex(text, start));
-        for (const part of splitTopLevelCommaSeparated(clause)) {
-            const name = objectAt(part, 0);
-            if (name && !SQL_KEYWORDS.has(name.toLowerCase()))
+    const fromNamesByScope = new Map();
+    const joins = [];
+    for (const clause of sqlSourceClauses(scan, trivia)) {
+        const scope = scopes.at(clause.start);
+        if (clause.kind === "from" || clause.kind === "using") {
+            for (const part of splitTopLevelCommaSeparated(text.slice(clause.end, clause.clauseEnd))) {
+                const name = objectAt(part, 0);
+                if (!name || SQL_KEYWORDS.has(name.toLowerCase()))
+                    continue;
                 names.push(name);
+                const inScope = fromNamesByScope.get(scope);
+                if (inScope)
+                    inScope.push(name);
+                else
+                    fromNamesByScope.set(scope, [name]);
+            }
         }
-    }
-    return Array.from(new Set(names));
-}
-function findMatchingParen(text, openIndex) {
-    let depth = 0;
-    for (let index = openIndex; index < text.length; index += 1) {
-        const char = text[index];
-        if (char === "(")
-            depth += 1;
-        if (char === ")") {
-            depth -= 1;
-            if (depth === 0)
-                return index;
+        else if (clause.kind === "join") {
+            const name = objectAt(text, clause.end);
+            if (name && !SQL_KEYWORDS.has(name.toLowerCase()))
+                joins.push({ name, scope });
         }
     }
-    return -1;
+    return {
+        names: Array.from(new Set(names)),
+        joins: joins.map((join) => ({ name: join.name, scopeFromNames: fromNamesByScope.get(join.scope) ?? [] })),
+    };
 }
 function collectCteReads(text) {
     const names = new Set();
@@ -378,7 +701,7 @@ function createDefinitionFact(text) {
             relatedObjectName: findObjectAfter(text, /\bon\s+/i),
         };
     }
-    const routineName = findObjectAfter(text, /\bcreate\s+(?:or\s+replace\s+)?(?:function|procedure|trigger)\s+/i);
+    const routineName = findObjectAfter(text, SQL_ROUTINE_DEFINITION_RE);
     if (routineName)
         return { kind: "defines_routine", objectName: routineName, relatedObjectName: null };
     return null;
@@ -396,31 +719,148 @@ function extractCreateTableConstraintFacts(text, tableName) {
 function extractReadFacts(text) {
     const cteReads = collectCteReads(text);
     const isCteName = (name) => sqlObjectLookupKeys(name).some((key) => cteReads.names.has(key));
-    const fromObjects = collectCommaSeparatedObjectsAfterKeywords(text, ["from", "using"]).filter((name) => !isCteName(name));
-    const joinObjects = collectObjectsAfterKeywords(text, ["join", "inner join", "left join", "right join", "full join", "cross join"], { topLevelOnly: true }).filter((name) => !isCteName(name));
-    const primaryRead = fromObjects[0] ?? null;
+    const sources = collectReadSources(text);
+    const fromObjects = sources.names.filter((name) => !isCteName(name));
     const facts = [...cteReads.facts];
+    const seenReads = new Set();
+    for (const fact of cteReads.facts) {
+        if (fact.kind === "reads_from" && fact.objectName)
+            seenReads.add(sqlObjectLookupKey(fact.objectName));
+    }
     for (const fromName of fromObjects) {
+        const key = sqlObjectLookupKey(fromName);
+        if (seenReads.has(key))
+            continue;
+        seenReads.add(key);
         facts.push({ kind: "reads_from", objectName: fromName, relatedObjectName: null });
     }
-    for (const joinName of joinObjects) {
-        facts.push({ kind: "joins", objectName: joinName, relatedObjectName: primaryRead });
+    const seenJoins = new Set();
+    const joinKey = (name, related) => {
+        const relatedKey = related === null ? "" : sqlObjectLookupKey(related);
+        return sqlObjectLookupKey(name) + ":" + relatedKey;
+    };
+    for (const fact of cteReads.facts) {
+        if (fact.kind === "joins" && fact.objectName) {
+            seenJoins.add(joinKey(fact.objectName, fact.relatedObjectName));
+        }
+    }
+    for (const join of sources.joins) {
+        if (isCteName(join.name))
+            continue;
+        const related = join.scopeFromNames.find((name) => !isCteName(name)) ?? null;
+        const key = joinKey(join.name, related);
+        if (seenJoins.has(key))
+            continue;
+        seenJoins.add(key);
+        facts.push({ kind: "joins", objectName: join.name, relatedObjectName: related });
     }
     return facts;
 }
+/**
+ * The text between a routine body's BEGIN and its matching END. A BEGIN inside parentheses, as in
+ * a parameter named begin, is not the body. Bare CASE opens a frame and `END CASE` closes the
+ * innermost CASE. `END IF`, `END LOOP`, `END WHILE`, `END REPEAT`, and `END FOR` close nothing
+ * when the innermost frame is BEGIN, and close a CASE when that is the innermost frame. Any other
+ * END closes the innermost frame. A variable or qualified name such as `@case` or `t . case`
+ * is not a block keyword. Null when the statement has no such body. A dollar-quoted body is already
+ * blank, so only a BEGIN/END that the statement splitter kept as one statement is read.
+ */
+function beginEndBody(text) {
+    const scan = maskSqlQuotedIdentifiers(text);
+    const trivia = sqlTriviaBoundaries(scan);
+    const stack = [];
+    let parenDepth = 0;
+    let cursor = 0;
+    let bodyStart = -1;
+    while (cursor < scan.length && bodyStart < 0) {
+        const code = scan.charCodeAt(cursor);
+        if (code === 40) {
+            parenDepth += 1;
+            cursor += 1;
+            continue;
+        }
+        if (code === 41) {
+            parenDepth = Math.max(0, parenDepth - 1);
+            cursor += 1;
+            continue;
+        }
+        if (!/[A-Za-z_]/.test(scan[cursor] ?? "")) {
+            cursor += 1;
+            continue;
+        }
+        const word = readBareWord(scan, cursor);
+        if (parenDepth === 0 && word?.word === "begin" && isBareSqlKeyword(scan, cursor, word.end, trivia)) {
+            bodyStart = word.end;
+            stack.push("begin");
+            cursor = word.end;
+            break;
+        }
+        cursor = word?.end ?? cursor + 1;
+    }
+    if (bodyStart < 0)
+        return null;
+    while (cursor < scan.length) {
+        if (/[A-Za-z_]/.test(scan[cursor] ?? "")) {
+            const atWord = cursor;
+            cursor = advanceSqlBlockWord(scan, cursor, stack, trivia);
+            if (stack.length === 0)
+                return text.slice(bodyStart, atWord);
+            continue;
+        }
+        cursor += 1;
+    }
+    return null;
+}
+/** Read facts of statements split out of a routine body. */
+function readsOfStatements(body) {
+    const seen = new Set();
+    const facts = [];
+    for (const inner of splitSqlStatements(body)) {
+        for (const fact of extractReadFacts(inner.text)) {
+            const key = `${fact.kind}:${fact.objectName ?? ""}:${fact.relatedObjectName ?? ""}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            facts.push(fact);
+        }
+    }
+    return facts;
+}
+/** Read facts of the statements inside a `BEGIN`/`END` body, split by the statement splitter. */
+function readsInsideBeginEnd(masked) {
+    const body = beginEndBody(masked);
+    if (body === null)
+        return [];
+    return readsOfStatements(body);
+}
+/**
+ * Read facts inside a compound routine body the same way as a BEGIN/END body.
+ * Null when the routine body is not that single compound statement.
+ */
+function readsInsideCompoundRoutine(masked) {
+    const code = maskSqlQuotedIdentifiers(masked);
+    const found = scanRoutineCompound(code, sqlTriviaBoundaries(masked), 0, code.length);
+    if (!found)
+        return null;
+    return readsOfStatements(masked.slice(found.keywordEnd));
+}
 function withoutSelfRead(readFacts, objectName) {
     if (!objectName)
         return readFacts;
     return readFacts.filter((fact) => fact.objectName !== objectName);
 }
 function extractStatementFactDrafts(statementText) {
-    const text = maskSqlStringsAndComments(statementText);
+    const text = maskSqlStringsAndComments(statementText, { escapeStrings: true });
     const definitionFact = createDefinitionFact(text);
     if (definitionFact) {
         const constraintFacts = definitionFact.kind === "defines_table" ? extractCreateTableConstraintFacts(text, definitionFact.objectName) : [];
-        const readFacts = definitionFact.kind === "defines_view" || /\bas\s+select\b/i.test(text)
-            ? withoutSelfRead(extractReadFacts(text), definitionFact.objectName)
-            : [];
+        let readFacts = [];
+        if (definitionFact.kind === "defines_view" || /\bas\s+select\b/i.test(text)) {
+            readFacts = withoutSelfRead(extractReadFacts(text), definitionFact.objectName);
+        }
+        else if (definitionFact.kind === "defines_routine") {
+            readFacts = readsInsideCompoundRoutine(text) ?? readsInsideBeginEnd(text);
+        }
         return [definitionFact, ...constraintFacts, ...readFacts];
     }
     const renameSourceName = findObjectAfter(text, /\balter\s+table\s+(?:if\s+exists\s+)?/i);