diff --git a/CHANGELOG.md b/CHANGELOG.md
index c71f41a983..15389e0d2c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -38,6 +38,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Fixed
 
+- Oracle PL/SQL blocks split at their inner semicolons and sent as fragments, failing with PLS-00103. (#2984)
+- Oracle procedures, packages and triggers created from the editor stored INVALID while the run reported success.
+- SQL*Plus `/` lines, `q'[…]'` literals and backslashes in strings misread in Oracle scripts.
+- `:NEW` and `:OLD` in an Oracle trigger body opening the parameter panel.
+- 1 row affected reported for every Oracle PL/SQL block.
+- MySQL procedures with a `CASE` statement swallowing the statements after them in the editor.
 - Icon-only buttons announced as nothing by VoiceOver across the data grid, row inspector, editor find bar, filter bar, structure, dashboard and settings.
 - Status icons that carried a result only as a symbol and a colour, silent to VoiceOver, in the AWS and app import steps and the plugin lists.
 - Foreign key picker rows that could only be chosen with a mouse.
diff --git a/Packages/TableProOracle/Sources/TableProOracleCore/OraclePLSQLUnit.swift b/Packages/TableProOracle/Sources/TableProOracleCore/OraclePLSQLUnit.swift
new file mode 100644
index 0000000000..e8bfd0f7ca
--- /dev/null
+++ b/Packages/TableProOracle/Sources/TableProOracleCore/OraclePLSQLUnit.swift
@@ -0,0 +1,212 @@
+import Foundation
+
+/// A stored PL/SQL unit a `CREATE` statement defines, read from the statement's header.
+///
+/// Oracle answers a `CREATE PROCEDURE` whose body does not compile with success: the object is stored INVALID and the
+/// failure travels only as a warning flag, which the driver drops. The errors are in `ALL_ERRORS`, keyed by owner,
+/// name and type, so reporting them takes knowing which unit the statement defined.
+public struct OraclePLSQLUnit: Sendable, Equatable {
+    /// The type as `ALL_ERRORS.TYPE` spells it, such as `PACKAGE BODY`.
+    public let type: String
+
+    /// The schema the header names, or nil when the unit is created in the session's current schema.
+    public let owner: String?
+    public let name: String
+
+    public init(type: String, owner: String?, name: String) {
+        self.type = type
+        self.owner = owner
+        self.name = name
+    }
+
+    private static let modifiers: Set<String> = ["OR", "REPLACE", "EDITIONABLE", "NONEDITIONABLE"]
+    private static let unitTypes: Set<String> = ["PROCEDURE", "FUNCTION", "PACKAGE", "TRIGGER", "TYPE"]
+
+    /// The unit `sql` creates, or nil when it creates something else or nothing at all.
+    public static func definition(in sql: String) -> OraclePLSQLUnit? {
+        var reader = HeaderReader(sql)
+        guard reader.nextWord() == "CREATE" else { return nil }
+        var word = reader.nextWord()
+        while let modifier = word, modifiers.contains(modifier) {
+            word = reader.nextWord()
+        }
+        guard let kind = word, unitTypes.contains(kind) else { return nil }
+        var type = kind
+        if kind == "PACKAGE" || kind == "TYPE", reader.peekWord() == "BODY" {
+            _ = reader.nextWord()
+            type = "\(kind) BODY"
+        }
+        if reader.peekWord() == "IF" {
+            _ = reader.nextWord()
+            guard reader.nextWord() == "NOT", reader.nextWord() == "EXISTS" else { return nil }
+        }
+        guard let first = reader.nextIdentifier() else { return nil }
+        guard reader.consumePeriod() else {
+            return OraclePLSQLUnit(type: type, owner: nil, name: first)
+        }
+        guard let second = reader.nextIdentifier() else { return nil }
+        return OraclePLSQLUnit(type: type, owner: first, name: second)
+    }
+
+    /// Whether `sql` is an anonymous block, which opens with `DECLARE` or `BEGIN` after any `<<label>>`.
+    ///
+    /// The driver reports a row count of 1 for every block it runs, which is not a number of rows anything changed.
+    public static func isAnonymousBlock(_ sql: String) -> Bool {
+        var reader = HeaderReader(sql)
+        reader.skipLabels()
+        let word = reader.nextWord()
+        return word == "DECLARE" || word == "BEGIN"
+    }
+
+    /// The compilation errors Oracle recorded for this unit, most recent compile only, in the order it reported them.
+    ///
+    /// Warnings are left out: with `PLSQL_WARNINGS` enabled Oracle records them against units that compiled.
+    public var errorsQuery: String {
+        let owner = owner.map { "'\(OracleSchemaQueries.escapeLiteral($0))'" }
+            ?? "SYS_CONTEXT('USERENV', 'CURRENT_SCHEMA')"
+        return """
+            SELECT LINE, POSITION, TEXT FROM ALL_ERRORS \
+            WHERE OWNER = \(owner) \
+            AND NAME = '\(OracleSchemaQueries.escapeLiteral(name))' \
+            AND TYPE = '\(OracleSchemaQueries.escapeLiteral(type))' \
+            AND ATTRIBUTE = 'ERROR' \
+            ORDER BY SEQUENCE
+            """
+    }
+
+    /// What the editor shows for a unit that was stored but does not compile, one error per line.
+    public func compilationFailureMessage(errors: [OracleCompilationError]) -> String {
+        let header = String(
+            format: String(localized: "%1$@ %2$@ was created with compilation errors:"),
+            type, name
+        )
+        let lines = errors.map { error in
+            String(
+                format: String(localized: "Line %1$lld, column %2$lld: %3$@"),
+                Int64(error.line), Int64(error.position), error.text
+            )
+        }
+        return ([header] + lines).joined(separator: "\n")
+    }
+}
+
+public struct OracleCompilationError: Sendable, Equatable {
+    public let line: Int
+    public let position: Int
+    public let text: String
+
+    public init(line: Int, position: Int, text: String) {
+        self.line = line
+        self.position = position
+        self.text = text.trimmingCharacters(in: .whitespacesAndNewlines)
+    }
+
+    /// Reads one `ALL_ERRORS` row as ``OraclePLSQLUnit/errorsQuery`` selects it.
+    public init?(row: [OracleRawCell]) {
+        guard row.count >= 3,
+              let line = row[0].stringValue.flatMap(Int.init),
+              let position = row[1].stringValue.flatMap(Int.init),
+              let text = row[2].stringValue
+        else {
+            return nil
+        }
+        self.init(line: line, position: position, text: text)
+    }
+}
+
+/// Reads the words and identifiers at the head of a statement, past comments.
+private struct HeaderReader {
+    private let scalars: [Unicode.Scalar]
+    private var index = 0
+
+    init(_ sql: String) {
+        scalars = Array(sql.unicodeScalars)
+    }
+
+    mutating func nextWord() -> String? {
+        skipTrivia()
+        let start = index
+        while index < scalars.count, Self.isWordScalar(scalars[index]) {
+            index += 1
+        }
+        guard index > start else { return nil }
+        return String(String.UnicodeScalarView(scalars[start..<index])).uppercased()
+    }
+
+    func peekWord() -> String? {
+        var copy = self
+        return copy.nextWord()
+    }
+
+    /// A quoted identifier keeps its case; an unquoted one is stored uppercased, as Oracle stores it.
+    mutating func nextIdentifier() -> String? {
+        skipTrivia()
+        guard index < scalars.count else { return nil }
+        guard scalars[index] == "\"" else { return nextWord() }
+        var name = String.UnicodeScalarView()
+        index += 1
+        while index < scalars.count {
+            if scalars[index] == "\"" {
+                guard index + 1 < scalars.count, scalars[index + 1] == "\"" else {
+                    index += 1
+                    return String(name)
+                }
+                name.append("\"")
+                index += 2
+                continue
+            }
+            name.append(scalars[index])
+            index += 1
+        }
+        return nil
+    }
+
+    mutating func skipLabels() {
+        while true {
+            skipTrivia()
+            guard index + 1 < scalars.count, scalars[index] == "<", scalars[index + 1] == "<" else { return }
+            index += 2
+            while index + 1 < scalars.count, !(scalars[index] == ">" && scalars[index + 1] == ">") {
+                index += 1
+            }
+            index = min(index + 2, scalars.count)
+        }
+    }
+
+    mutating func consumePeriod() -> Bool {
+        skipTrivia()
+        guard index < scalars.count, scalars[index] == "." else { return false }
+        index += 1
+        return true
+    }
+
+    private mutating func skipTrivia() {
+        while index < scalars.count {
+            let scalar = scalars[index]
+            if scalar.properties.isWhitespace {
+                index += 1
+                continue
+            }
+            if scalar == "-", index + 1 < scalars.count, scalars[index + 1] == "-" {
+                while index < scalars.count, scalars[index] != "\n" {
+                    index += 1
+                }
+                continue
+            }
+            if scalar == "/", index + 1 < scalars.count, scalars[index + 1] == "*" {
+                index += 2
+                while index + 1 < scalars.count, !(scalars[index] == "*" && scalars[index + 1] == "/") {
+                    index += 1
+                }
+                index = min(index + 2, scalars.count)
+                continue
+            }
+            return
+        }
+    }
+
+    private static func isWordScalar(_ scalar: Unicode.Scalar) -> Bool {
+        scalar.properties.isAlphabetic || ("0"..."9").contains(scalar) || scalar == "_" || scalar == "$"
+            || scalar == "#"
+    }
+}
diff --git a/Packages/TableProOracle/Tests/TableProOracleCoreTests/OraclePLSQLUnitTests.swift b/Packages/TableProOracle/Tests/TableProOracleCoreTests/OraclePLSQLUnitTests.swift
new file mode 100644
index 0000000000..02fadad55a
--- /dev/null
+++ b/Packages/TableProOracle/Tests/TableProOracleCoreTests/OraclePLSQLUnitTests.swift
@@ -0,0 +1,82 @@
+@testable import TableProOracleCore
+import XCTest
+
+/// Oracle stores a unit that does not compile and reports success, so the plugin reads the unit's errors back by the
+/// owner, name and type the `CREATE` header names. Reading the wrong name reports a broken unit as fine.
+final class OraclePLSQLUnitTests: XCTestCase {
+    func testReadsTheUnitEachHeaderDefines() {
+        let cases: [(sql: String, unit: OraclePLSQLUnit)] = [
+            ("CREATE PROCEDURE p IS BEGIN NULL; END;", OraclePLSQLUnit(type: "PROCEDURE", owner: nil, name: "P")),
+            (
+                "create or replace editionable function hr.f return number is begin return 1; end;",
+                OraclePLSQLUnit(type: "FUNCTION", owner: "HR", name: "F")
+            ),
+            ("CREATE OR REPLACE PACKAGE BODY pkg AS END;", OraclePLSQLUnit(type: "PACKAGE BODY", owner: nil, name: "PKG")),
+            ("CREATE PACKAGE pkg AS END;", OraclePLSQLUnit(type: "PACKAGE", owner: nil, name: "PKG")),
+            ("CREATE TYPE BODY t AS END;", OraclePLSQLUnit(type: "TYPE BODY", owner: nil, name: "T")),
+            ("CREATE TYPE t AS OBJECT (a NUMBER);", OraclePLSQLUnit(type: "TYPE", owner: nil, name: "T")),
+            (
+                "-- note\nCREATE OR REPLACE TRIGGER \"App\".\"Audit\" BEFORE INSERT ON x FOR EACH ROW BEGIN NULL; END;",
+                OraclePLSQLUnit(type: "TRIGGER", owner: "App", name: "Audit")
+            ),
+            (
+                "CREATE PROCEDURE IF NOT EXISTS p IS BEGIN NULL; END;",
+                OraclePLSQLUnit(type: "PROCEDURE", owner: nil, name: "P")
+            ),
+            ("CREATE NONEDITIONABLE PROCEDURE x$y#z IS BEGIN NULL; END;", OraclePLSQLUnit(type: "PROCEDURE", owner: nil, name: "X$Y#Z")),
+        ]
+        for example in cases {
+            XCTAssertEqual(OraclePLSQLUnit.definition(in: example.sql), example.unit, example.sql)
+        }
+    }
+
+    func testStatementsThatDefineNoUnit() {
+        for sql in [
+            "CREATE TABLE t (a NUMBER)",
+            "CREATE OR REPLACE VIEW v AS SELECT 1 FROM dual",
+            "BEGIN NULL; END;",
+            "DROP PROCEDURE p",
+            "SELECT 'CREATE PROCEDURE p' FROM dual",
+        ] {
+            XCTAssertNil(OraclePLSQLUnit.definition(in: sql), sql)
+        }
+    }
+
+    func testErrorsQueryEscapesAndFallsBackToTheSessionSchema() {
+        let named = OraclePLSQLUnit(type: "PACKAGE BODY", owner: "O'NEIL", name: "IT'S")
+        XCTAssertTrue(named.errorsQuery.contains("OWNER = 'O''NEIL'"))
+        XCTAssertTrue(named.errorsQuery.contains("NAME = 'IT''S'"))
+        XCTAssertTrue(named.errorsQuery.contains("TYPE = 'PACKAGE BODY'"))
+        XCTAssertTrue(named.errorsQuery.contains("ATTRIBUTE = 'ERROR'"))
+
+        let unqualified = OraclePLSQLUnit(type: "PROCEDURE", owner: nil, name: "P")
+        XCTAssertTrue(unqualified.errorsQuery.contains("OWNER = SYS_CONTEXT('USERENV', 'CURRENT_SCHEMA')"))
+    }
+
+    func testFailureMessageListsEveryError() {
+        let unit = OraclePLSQLUnit(type: "PROCEDURE", owner: nil, name: "P")
+        let message = unit.compilationFailureMessage(errors: [
+            OracleCompilationError(line: 5, position: 3, text: "PLS-00103: Encountered the symbol \"end-of-file\"\n"),
+            OracleCompilationError(line: 7, position: 1, text: "PL/SQL: Statement ignored"),
+        ])
+        XCTAssertEqual(message, """
+            PROCEDURE P was created with compilation errors:
+            Line 5, column 3: PLS-00103: Encountered the symbol "end-of-file"
+            Line 7, column 1: PL/SQL: Statement ignored
+            """)
+    }
+
+    func testCompilationErrorReadsAnErrorsRow() {
+        let error = OracleCompilationError(row: [.string("5"), .string("3"), .string("PLS-00103: x")])
+        XCTAssertEqual(error, OracleCompilationError(line: 5, position: 3, text: "PLS-00103: x"))
+        XCTAssertNil(OracleCompilationError(row: [.null, .string("3"), .string("x")]))
+    }
+
+    func testAnonymousBlocksAreRecognisedPastLabelsAndComments() {
+        XCTAssertTrue(OraclePLSQLUnit.isAnonymousBlock("BEGIN NULL; END;"))
+        XCTAssertTrue(OraclePLSQLUnit.isAnonymousBlock("declare v number; begin null; end;"))
+        XCTAssertTrue(OraclePLSQLUnit.isAnonymousBlock("-- c\n<<outer>>\n<<inner>> BEGIN NULL; END;"))
+        XCTAssertFalse(OraclePLSQLUnit.isAnonymousBlock("SELECT 1 FROM dual"))
+        XCTAssertFalse(OraclePLSQLUnit.isAnonymousBlock("CALL p()"))
+    }
+}
diff --git a/Plugins/OracleDriverPlugin/OraclePlugin.swift b/Plugins/OracleDriverPlugin/OraclePlugin.swift
index 604042668a..7391665343 100644
--- a/Plugins/OracleDriverPlugin/OraclePlugin.swift
+++ b/Plugins/OracleDriverPlugin/OraclePlugin.swift
@@ -305,6 +305,7 @@ final class OraclePluginDriver: PluginDatabaseDriver, @unchecked Sendable {
         // Health monitor sends "SELECT 1" as a ping; Oracle requires FROM DUAL.
         let isBareSelectOne = query.trimmingCharacters(in: .whitespacesAndNewlines).lowercased() == "select 1"
         var result = try await rawQuery(isBareSelectOne ? OracleSchemaQueries.ping : query)
+        try await reportCompilationErrors(of: query)
         let executionTime = Date().timeIntervalSince(startTime)
 
         // OracleNIO may not populate column metadata for empty result sets.
@@ -312,10 +313,25 @@ final class OraclePluginDriver: PluginDatabaseDriver, @unchecked Sendable {
            let recovered = try? await emptyResultColumns(for: query) {
             result = recovered
         }
+        if OraclePLSQLUnit.isAnonymousBlock(query) {
+            result = OracleRawResult(columns: result.columns, rows: result.rows, affectedRows: 0, isTruncated: false)
+        }
 
         return result.toPluginResult(executionTime: executionTime)
     }
 
+    /// Turns a `CREATE` that stored an INVALID unit into the failure it is.
+    ///
+    /// Oracle accepts the statement and flags the compile failure only as a warning, which oracle-nio drops, so the
+    /// unit's own errors are read back from `ALL_ERRORS`. A unit the header does not name, or one that compiled, adds
+    /// nothing.
+    func reportCompilationErrors(of query: String) async throws {
+        guard let unit = OraclePLSQLUnit.definition(in: query) else { return }
+        let errors = try await rawQuery(unit.errorsQuery).rows.compactMap(OracleCompilationError.init(row:))
+        guard !errors.isEmpty else { return }
+        throw OraclePluginError(core: .queryFailed(unit.compilationFailureMessage(errors: errors)))
+    }
+
     internal func rawQuery(_ query: String) async throws -> OracleRawResult {
         guard let core else { throw OraclePluginError(core: .notConnected) }
         do {
@@ -345,7 +361,9 @@ final class OraclePluginDriver: PluginDatabaseDriver, @unchecked Sendable {
     // MARK: - Streaming
 
     func executeBoundedQuery(query: String, rowCap: Int) async throws -> PluginQueryResult? {
-        try await boundedQueryFromStream(query: query, rowCap: rowCap)
+        let result = try await boundedQueryFromStream(query: query, rowCap: rowCap)
+        try await reportCompilationErrors(of: query)
+        return result
     }
 
     func streamRows(query: String) -> AsyncThrowingStream<PluginStreamElement, Error> {
diff --git a/Plugins/TableProPluginKit/SqlDialect.swift b/Plugins/TableProPluginKit/SqlDialect.swift
index d600dcfdc9..7571dc90b3 100644
--- a/Plugins/TableProPluginKit/SqlDialect.swift
+++ b/Plugins/TableProPluginKit/SqlDialect.swift
@@ -4,6 +4,7 @@ public enum SqlDialect: String, Sendable, CaseIterable {
     case postgres
     case mysql
     case sqlite
+    case oracle
     case generic
 
     public static func from(databaseTypeId: String) -> SqlDialect {
@@ -14,6 +15,8 @@ public enum SqlDialect: String, Sendable, CaseIterable {
             return .mysql
         case "SQLite", "libSQL", "Turso", "DuckDB", "Cloudflare D1":
             return .sqlite
+        case "Oracle":
+            return .oracle
         default:
             return .generic
         }
@@ -38,4 +41,16 @@ public enum SqlDialect: String, Sendable, CaseIterable {
     public var supportsAdjacentStringConcatenation: Bool {
         self != .mysql
     }
+
+    /// Oracle's `q'[...]'` literal, whose body runs to the matching delimiter followed by a quote, so a lone `'`
+    /// inside it does not end it.
+    public var supportsAlternativeQuoting: Bool {
+        self == .oracle
+    }
+
+    /// SQL*Plus ends a statement at a line holding only `/`, which is how a PL/SQL unit is terminated in every script
+    /// written for SQL*Plus, SQLcl or SQL Developer. The line is a client command, never text the server accepts.
+    public var endsStatementsAtSlashLines: Bool {
+        self == .oracle
+    }
 }
diff --git a/TablePro/Core/Compare/CompareSyncExecutor.swift b/TablePro/Core/Compare/CompareSyncExecutor.swift
index e627fd8914..6960c249d6 100644
--- a/TablePro/Core/Compare/CompareSyncExecutor.swift
+++ b/TablePro/Core/Compare/CompareSyncExecutor.swift
@@ -185,18 +185,28 @@ internal actor CompareSyncExecutor {
                 mode: mode,
                 settings: settings,
                 driver: driver,
+                dialect: SqlDialect.from(databaseTypeId: target.databaseType.rawValue),
                 progress: progress,
                 nonTransactionalObjects: nonTransactionalObjects
             )
         }
     }
 
+    /// The script text a statement is shown with ends in `;`, and on Oracle that `;` belongs to some statements and
+    /// breaks others: a trigger whose body is a `CALL` is stored INVALID with one. Oracle's statements therefore go out
+    /// the way the editor sends them. Every other engine takes the script text as written.
+    private static func driverText(of statement: SyncStatement, dialect: SqlDialect) -> String {
+        guard dialect == .oracle else { return statement.sql }
+        return SQLStatementScanner.executableText(of: statement.sql, dialect: dialect)
+    }
+
     private func run(
         runnable: [SyncStatement],
         heldBack: [SyncStatement],
         mode: CompareSyncMode,
         settings: CompareSyncExecutionSettings,
         driver: any PluginDatabaseDriver,
+        dialect: SqlDialect,
         progress: Progress,
         nonTransactionalObjects: Set<String>
     ) async throws -> CompareSyncRunResult {
@@ -220,7 +230,7 @@ internal actor CompareSyncExecutor {
             }
             var didExecute = false
             do {
-                let result = try await driver.execute(query: statement.sql)
+                let result = try await driver.execute(query: Self.driverText(of: statement, dialect: dialect))
                 didExecute = true
                 try Self.verify(statement, rowsAffected: result.rowsAffected)
                 /// A scope is only closed once its closing statement has actually run. Dropping it
diff --git a/TablePro/Core/Coordinators/QueryExecutionCoordinator+Parameters.swift b/TablePro/Core/Coordinators/QueryExecutionCoordinator+Parameters.swift
index e326f663ee..041d1ad46e 100644
--- a/TablePro/Core/Coordinators/QueryExecutionCoordinator+Parameters.swift
+++ b/TablePro/Core/Coordinators/QueryExecutionCoordinator+Parameters.swift
@@ -395,7 +395,9 @@ extension QueryExecutionCoordinator {
         rules: SQLLexicalRules
     ) -> PreparedStatement {
         let sql = statement.sql
-        let parameterNames = parameters.isEmpty ? [] : SQLParameterExtractor.extractParameters(from: sql)
+        let parameterNames = parameters.isEmpty || !statement.acceptsBindParameters
+            ? []
+            : SQLParameterExtractor.extractParameters(from: sql)
         let conversion = parameterNames.isEmpty
             ? nil
             : SQLParameterExtractor.convertToNativeStyle(sql: sql, parameters: parameters, style: style)
diff --git a/TablePro/Core/Coordinators/QueryExecutionCoordinator.swift b/TablePro/Core/Coordinators/QueryExecutionCoordinator.swift
index 524a5a2aea..6063dcdaef 100644
--- a/TablePro/Core/Coordinators/QueryExecutionCoordinator.swift
+++ b/TablePro/Core/Coordinators/QueryExecutionCoordinator.swift
@@ -27,7 +27,7 @@ final class QueryExecutionCoordinator: ObservableObject {
         guard !statements.isEmpty else { return }
 
         if AppSettingsManager.shared.editor.queryParametersEnabled, parent.statementModel == .sql {
-            let combinedSQL = statements.map(\.sql).joined(separator: "; ")
+            let combinedSQL = SQLParameterExtractor.parameterSource(of: statements)
             let detectedNames = SQLParameterExtractor.extractParameters(from: combinedSQL)
 
             if !detectedNames.isEmpty {
diff --git a/TablePro/Core/Database/Access/DatabaseAccessBridge.swift b/TablePro/Core/Database/Access/DatabaseAccessBridge.swift
index ded832023e..9316b42e73 100644
--- a/TablePro/Core/Database/Access/DatabaseAccessBridge.swift
+++ b/TablePro/Core/Database/Access/DatabaseAccessBridge.swift
@@ -5,6 +5,7 @@
 
 import Foundation
 import os
+import TableProPluginKit
 
 /// Connecting, switching container and running one statement, for a caller that is not a person
 /// clicking in the app.
@@ -174,11 +175,17 @@ internal actor DatabaseAccessBridge {
         timeoutSeconds: Int,
         cancellation: (any StatementCancellationSignal)?
     ) async throws -> StatementOutcome {
-        let normalizedQuery = Self.stripTrailingSemicolons(query)
-        guard !normalizedQuery.isEmpty else {
+        guard !Self.statementText(query, dialect: .generic).isEmpty else {
             throw DatabaseAccessError.invalidArgument(String(localized: "The query is empty."))
         }
         let databaseType = try await ensureConnected(scope.connectionId)
+        let normalizedQuery = Self.statementText(
+            query,
+            dialect: SqlDialect.from(databaseTypeId: databaseType.rawValue)
+        )
+        guard !normalizedQuery.isEmpty else {
+            throw DatabaseAccessError.invalidArgument(String(localized: "The query is empty."))
+        }
         let classification = QueryClassifier.classify(normalizedQuery, databaseType: databaseType)
         let hasReturning = normalizedQuery.range(
             of: #"\bRETURNING\b"#,
@@ -295,12 +302,14 @@ internal actor DatabaseAccessBridge {
         }
     }
 
-    internal static func stripTrailingSemicolons(_ query: String) -> String {
-        var result = StatementBlank.trimming(query)
-        while result.hasSuffix(";") {
-            result = StatementBlank.trimming(String(result.dropLast()))
-        }
-        return result
+    /// The text an external client's statement reaches the driver as.
+    ///
+    /// Trailing separators come off and a terminator that belongs to the statement stays, as the editor decides it:
+    /// a PL/SQL unit sent without the `;` after its `END` fails, or is stored INVALID, on Oracle. The emptiness of a
+    /// statement does not depend on the dialect for anything but an Oracle `/` line, so a caller may check it with
+    /// `.generic` before it knows the engine and again once it does.
+    internal static func statementText(_ query: String, dialect: SqlDialect) -> String {
+        SQLStatementScanner.executableText(of: query, dialect: dialect)
     }
 }
 
diff --git a/TablePro/Core/MCP/MCPConnectionBridge+Data.swift b/TablePro/Core/MCP/MCPConnectionBridge+Data.swift
index 9b4458933b..1db34ca43a 100644
--- a/TablePro/Core/MCP/MCPConnectionBridge+Data.swift
+++ b/TablePro/Core/MCP/MCPConnectionBridge+Data.swift
@@ -370,7 +370,7 @@ extension MCPConnectionBridge {
         } else {
             prefix = analyze ? "EXPLAIN ANALYZE" : "EXPLAIN"
         }
-        let trimmed = stripTrailingSemicolons(query)
+        let trimmed = statementText(query, databaseType: databaseType)
         guard !trimmed.isEmpty else {
             throw DatabaseAccessError.invalidArgument(String(localized: "The query is empty."))
         }
diff --git a/TablePro/Core/MCP/MCPConnectionBridge.swift b/TablePro/Core/MCP/MCPConnectionBridge.swift
index 51e7e51949..383bcb8f30 100644
--- a/TablePro/Core/MCP/MCPConnectionBridge.swift
+++ b/TablePro/Core/MCP/MCPConnectionBridge.swift
@@ -218,8 +218,8 @@ public actor MCPConnectionBridge {
         try await access.resolveConnection(connectionId)
     }
 
-    static func stripTrailingSemicolons(_ query: String) -> String {
-        DatabaseAccessBridge.stripTrailingSemicolons(query)
+    static func statementText(_ query: String, databaseType: DatabaseType) -> String {
+        DatabaseAccessBridge.statementText(query, dialect: SqlDialect.from(databaseTypeId: databaseType.rawValue))
     }
 }
 
diff --git a/TablePro/Core/Services/Execution/BatchTransactionPolicy.swift b/TablePro/Core/Services/Execution/BatchTransactionPolicy.swift
index e19516bda0..470a792910 100644
--- a/TablePro/Core/Services/Execution/BatchTransactionPolicy.swift
+++ b/TablePro/Core/Services/Execution/BatchTransactionPolicy.swift
@@ -4,6 +4,7 @@
 //
 
 import Foundation
+import TableProPluginKit
 
 /// How the app treats the transaction around a multi-statement run, decided from the text alone
 /// before any driver is leased.
@@ -72,6 +73,7 @@ internal enum BatchTransactionPolicy {
         guard let keyword = cursor.next()?.word else { return false }
         switch keyword {
         case "BEGIN":
+            guard rules.dialect != .oracle else { return false }
             return SqlBlockStructure.beginStartsTransaction(followedBy: cursor.next()?.word)
         case "START":
             return cursor.next()?.word == "TRANSACTION"
diff --git a/TablePro/Core/Utilities/SQL/CatalogChangeClassifier.swift b/TablePro/Core/Utilities/SQL/CatalogChangeClassifier.swift
index a9b0bf578b..110d25912b 100644
--- a/TablePro/Core/Utilities/SQL/CatalogChangeClassifier.swift
+++ b/TablePro/Core/Utilities/SQL/CatalogChangeClassifier.swift
@@ -45,6 +45,9 @@ enum CatalogChangeClassifier {
             let tier = QueryClassifier.classifyTier(trimmed, databaseType: databaseType)
             return tier == .safe ? .none : opaque
         }
+        if QueryClassifier.runsPLSQL(trimmed, databaseType: databaseType) {
+            return opaque
+        }
         return sqlEffect(trimmed)
     }
 
diff --git a/TablePro/Core/Utilities/SQL/Folding/SQLFoldScanner.swift b/TablePro/Core/Utilities/SQL/Folding/SQLFoldScanner.swift
index 05feabfa0b..2c29ae600a 100644
--- a/TablePro/Core/Utilities/SQL/Folding/SQLFoldScanner.swift
+++ b/TablePro/Core/Utilities/SQL/Folding/SQLFoldScanner.swift
@@ -41,10 +41,15 @@ private struct Scan {
     private var index = 0
     private var line = 0
 
+    /// The statement scanner's own grammar, asked whether a `;` ends the statement so the fold and the run control
+    /// in the same gutter agree about where a statement stops.
+    private var boundaries: any SQLStatementBoundaryTracking
+
     init(text: NSString, dialect: SqlDialect) {
         self.text = text
         self.length = text.length
         self.dialect = dialect
+        self.boundaries = SQLStatementBoundaries.makeTracker(for: dialect)
     }
 
     // MARK: - Pass
@@ -63,6 +68,8 @@ private struct Scan {
         if consumeComment(character) { return }
         if consumeQuotedString(character) { return }
         if consumeDollarQuotedBody(character) { return }
+        if consumeAlternativeQuotedString() { return }
+        if consumeSlashLine(character) { return }
 
         openStatementIfNeeded()
         consumeStructure(character)
@@ -99,9 +106,13 @@ private struct Scan {
     /// Closes the innermost frame when it is the kind being closed. A `)` that does not match an open group, or an
     /// `END` with no `BEGIN`, belongs to structure this scanner does not track and is left alone.
     private mutating func popFrame(_ kind: SQLFoldRegion.Kind, end: Int) {
+        popFrame(kind, end: end, endLine: line)
+    }
+
+    private mutating func popFrame(_ kind: SQLFoldRegion.Kind, end: Int, endLine: Int) {
         guard let frame = frames.last, frame.kind == kind else { return }
         frames.removeLast()
-        complete(frame, end: end, endLine: line)
+        complete(frame, end: end, endLine: endLine)
     }
 
     private mutating func complete(_ frame: Frame, end: Int, endLine: Int) {
@@ -137,34 +148,58 @@ private struct Scan {
     private mutating func consumeStructure(_ character: UInt16) {
         switch character {
         case SqlLexer.openParen:
+            boundaries.observeSymbol(character)
             pushFrame(.parenGroup, openingToken: index, startLine: line)
             index += 1
         case SqlLexer.closeParen:
+            boundaries.observeSymbol(character)
             popFrame(.parenGroup, end: index)
             index += 1
         case SqlLexer.semicolon:
             consumeSemicolon()
         default:
-            consumeKeyword()
+            consumeKeyword(character)
         }
     }
 
-    /// A semicolon only ends the statement when the statement is the innermost open frame. Inside a `BEGIN` block or
-    /// a parenthesised group it separates something nested instead.
+    /// A semicolon only ends the statement when the statement grammar says it does and the statement is the innermost
+    /// open frame. Inside a `BEGIN` block or a parenthesised group it separates something nested instead.
+    ///
+    /// Oracle's grammar is authoritative in both directions, because a PL/SQL unit's `IS` and `AS` bodies open no fold
+    /// frame of their own: when it ends the unit, whatever the fold still holds open ends with it.
     private mutating func consumeSemicolon() {
-        if frames.last?.kind == .statement {
+        let endsStatement = boundaries.observeSemicolon()
+        if endsStatement {
+            boundaries.reset()
+            if dialect == .oracle {
+                closeFramesThroughStatement(end: index)
+            }
+        }
+        if endsStatement, frames.last?.kind == .statement {
             popFrame(.statement, end: index)
         }
         index += 1
     }
 
-    private mutating func consumeKeyword() {
-        let word = SqlBlockStructure.readKeyword(text, at: index, length: length)
+    private mutating func closeFramesThroughStatement(end: Int, endLine: Int? = nil) {
+        guard frames.contains(where: { $0.kind == .statement }) else { return }
+        while let frame = frames.last, frame.kind != .statement {
+            frames.removeLast()
+            complete(frame, end: end, endLine: endLine ?? line)
+        }
+    }
+
+    private mutating func consumeKeyword(_ character: UInt16) {
+        let word = SqlBlockStructure.readKeyword(text, at: index, length: length, dialect: dialect)
         guard !word.text.isEmpty else {
+            if !SqlLexer.isWhitespace(character) {
+                boundaries.observeSymbol(character)
+            }
             index += 1
             return
         }
 
+        boundaries.observeWord(word.text)
         switch SqlBlockStructure.effect(
             of: word.text,
             endingAt: word.end,
@@ -174,12 +209,13 @@ private struct Scan {
         ) {
         case .opensBlock:
             pushFrame(.keywordBlock, openingToken: word.end, startLine: line)
-        case .closesBlock:
+            index = word.end
+        case let .closesBlock(resumeAt):
             popFrame(.keywordBlock, end: index)
+            index = max(word.end, resumeAt)
         case .none:
-            break
+            index = word.end
         }
-        index = word.end
     }
 
     // MARK: - Trivia
@@ -214,12 +250,52 @@ private struct Scan {
 
     private mutating func consumeQuotedString(_ character: UInt16) -> Bool {
         guard SqlLexer.isQuote(character) else { return false }
+        boundaries.observeOpaqueToken()
         let span = SqlLexer.skipQuotedString(text, from: index, quote: character, length: length, dialect: dialect)
         line += span.newlines
         index = span.next
         return true
     }
 
+    /// An Oracle `q'[...]'` literal, which only starts where a word could, so `xq'` stays an identifier and a string.
+    private mutating func consumeAlternativeQuotedString() -> Bool {
+        guard dialect.supportsAlternativeQuoting,
+              index == 0 || !SqlBlockStructure.continuesWord(text.character(at: index - 1), dialect: dialect),
+              let span = SqlLexer.skipAlternativeQuotedString(text, at: index, length: length)
+        else {
+            return false
+        }
+        boundaries.observeOpaqueToken()
+        line += span.newlines
+        index = span.next
+        return true
+    }
+
+    /// A `/` alone on its line ends whatever statement is open, as SQL*Plus reads it. The statement ends where its own
+    /// text does, on a line above the slash, so a one-line statement stays unfoldable.
+    private mutating func consumeSlashLine(_ character: UInt16) -> Bool {
+        guard dialect.endsStatementsAtSlashLines, character == SqlLexer.slash,
+              SQLStatementScanner.isSlashLine(text, at: index, length: length)
+        else {
+            return false
+        }
+        var end = index
+        var endLine = line
+        while end > 0, SqlLexer.isWhitespace(text.character(at: end - 1)) {
+            end -= 1
+            if text.character(at: end) == SqlLexer.newline {
+                endLine -= 1
+            }
+        }
+        closeFramesThroughStatement(end: end, endLine: endLine)
+        if frames.last?.kind == .statement {
+            popFrame(.statement, end: end, endLine: endLine)
+        }
+        boundaries.reset()
+        index += 1
+        return true
+    }
+
     /// A dollar quoted body is one opaque region, so nothing inside it is read as structure. The statement around it
     /// opens first, because the body is part of that statement.
     private mutating func consumeDollarQuotedBody(_ character: UInt16) -> Bool {
@@ -233,6 +309,7 @@ private struct Scan {
         }
 
         openStatementIfNeeded()
+        boundaries.observeOpaqueToken()
         let start = SqlLexer.endOfLine(text, from: index, length: length)
         let startLine = line
         let result = SqlLexer.skipDollarQuotedBody(text, from: index + openerLength, tag: tag, length: length)
diff --git a/TablePro/Core/Utilities/SQL/PLSQLUnitTracker.swift b/TablePro/Core/Utilities/SQL/PLSQLUnitTracker.swift
new file mode 100644
index 0000000000..b97d0d91f5
--- /dev/null
+++ b/TablePro/Core/Utilities/SQL/PLSQLUnitTracker.swift
@@ -0,0 +1,380 @@
+//
+//  PLSQLUnitTracker.swift
+//  TablePro
+//
+
+import Foundation
+
+/// Statement boundaries in Oracle's language, where a `;` inside a PL/SQL unit separates the unit's own statements.
+///
+/// A statement's first words say what it is, the way SQL*Plus decides whether to enter PL/SQL mode:
+///
+/// - `DECLARE`, `BEGIN` and a labelled block are anonymous PL/SQL blocks.
+/// - `CREATE [OR REPLACE] [EDITIONABLE | NONEDITIONABLE]` followed by `PROCEDURE`, `FUNCTION`, `PACKAGE [BODY]`,
+///   `TYPE [BODY]`, `TRIGGER` or `LIBRARY` is a stored unit.
+/// - `WITH FUNCTION` or `WITH PROCEDURE` is SQL whose `WITH` clause declares PL/SQL, so each declaration's `END;` is
+///   inside the statement and only the query after them ends it.
+/// - `CREATE JAVA` and `CREATE MLE MODULE` carry source in another language after `AS`, which only a `/` line or the
+///   end of the script can end. So does a unit whose body is `WRAPPED`.
+/// - Everything else is SQL, and its first `;` ends it.
+///
+/// Inside a unit the tracker counts the constructs that one bare `END` closes: a block, a subprogram or package body,
+/// a compound trigger and a `CASE`. A `BEGIN` continues the innermost construct when that construct is still in its
+/// declaration section, because `DECLARE ... BEGIN ... END` and `PROCEDURE p IS ... BEGIN ... END` each end once.
+/// `END IF` and `END LOOP` close constructs that never opened one, and a word after `.` is a member name, never a
+/// keyword. A `;` ends the unit only once every construct has closed.
+///
+/// The final `;` of a unit belongs to it, except after a trigger whose body is a `CALL`: measured on Oracle 23ai,
+/// `CREATE TRIGGER ... CALL p(:NEW.a);` is stored INVALID and the same text without the `;` compiles.
+/// `scripts/check-oracle-plsql-terminators.sh` re-measures both rules against a live server.
+struct PLSQLUnitTracker: SQLStatementBoundaryTracking {
+    private enum Lead {
+        case start
+        case afterCreate
+        case afterCreateType
+        case afterWith
+        case decided
+    }
+
+    private enum Kind {
+        case sql
+        case anonymousBlock
+        case storedUnit
+        case inlineDeclarations
+        case embeddedSourceHeader
+        case opaque
+    }
+
+    private enum Header {
+        case subprogram
+        case unitBody
+        case trigger
+        case embeddedSource
+    }
+
+    private static let lessThan = UInt16(UnicodeScalar("<").value)
+    private static let greaterThan = UInt16(UnicodeScalar(">").value)
+    private static let period = UInt16(UnicodeScalar(".").value)
+
+    private static let createModifiers: Set<String> = [
+        "OR", "REPLACE", "EDITIONABLE", "NONEDITIONABLE", "AND", "RESOLVE", "COMPILE", "NOFORCE",
+    ]
+
+    private var lead = Lead.start
+    private var kind = Kind.sql
+    private var header: Header?
+
+    /// One entry per construct a bare `END` will close, true while that construct still waits for its `BEGIN`.
+    private var constructs: [Bool] = []
+    private var parenDepth = 0
+    private var pendingEnd = false
+    private var pendingBodyKeyword = false
+    private var followsPeriod = false
+    private var previousSymbol: UInt16?
+    private var inLabel = false
+    private var callsRoutine = false
+    private var expectsDeclaration = false
+    private var inlineQueryStarted = false
+
+    var needsWords: Bool {
+        lead != .decided || tracksConstructs
+    }
+
+    var terminator: SQLStatementTerminator {
+        switch kind {
+        case .anonymousBlock, .opaque:
+            return .partOfStatement
+        case .storedUnit:
+            return callsRoutine ? .separator : .partOfStatement
+        case .sql, .inlineDeclarations, .embeddedSourceHeader:
+            return .separator
+        }
+    }
+
+    var acceptsBindParameters: Bool {
+        switch kind {
+        case .storedUnit, .embeddedSourceHeader, .opaque:
+            return false
+        case .sql, .anonymousBlock, .inlineDeclarations:
+            return true
+        }
+    }
+
+    mutating func observeWord(_ word: String) {
+        previousSymbol = nil
+        guard !inLabel else { return }
+        let isMember = followsPeriod
+        followsPeriod = false
+
+        switch lead {
+        case .start:
+            decideLead(word)
+            return
+        case .afterCreate:
+            continueCreate(word)
+            return
+        case .afterCreateType:
+            lead = .decided
+            header = word == "BODY" ? .unitBody : nil
+            return
+        case .afterWith:
+            lead = .decided
+            if word == "FUNCTION" || word == "PROCEDURE" {
+                kind = .inlineDeclarations
+                header = .subprogram
+            }
+            return
+        case .decided:
+            break
+        }
+
+        guard tracksConstructs, !isMember, !word.hasPrefix("$") else { return }
+        if pendingEnd {
+            pendingEnd = false
+            if closeEnd(followedBy: word) { return }
+        }
+        if pendingBodyKeyword {
+            pendingBodyKeyword = false
+            header = nil
+            if word == "LANGUAGE" || word == "EXTERNAL" { return }
+            constructs.append(true)
+        }
+        if expectsDeclaration {
+            expectsDeclaration = false
+            guard word == "FUNCTION" || word == "PROCEDURE" else {
+                inlineQueryStarted = true
+                return
+            }
+        }
+        if let header {
+            if parenDepth == 0 {
+                observeHeaderWord(word, in: header)
+            }
+            return
+        }
+        observeBodyWord(word)
+    }
+
+    mutating func observeSymbol(_ symbol: UInt16) {
+        if symbol == Self.lessThan, previousSymbol == Self.lessThan {
+            inLabel = true
+            previousSymbol = nil
+            return
+        }
+        if symbol == Self.greaterThan, previousSymbol == Self.greaterThan, inLabel {
+            inLabel = false
+            previousSymbol = nil
+            return
+        }
+        previousSymbol = symbol
+        guard !inLabel, tracksConstructs else { return }
+        settlePendingBeforeNonWord()
+        switch symbol {
+        case SqlLexer.openParen:
+            parenDepth += 1
+        case SqlLexer.closeParen:
+            parenDepth = max(0, parenDepth - 1)
+        default:
+            break
+        }
+        followsPeriod = symbol == Self.period
+    }
+
+    mutating func observeOpaqueToken() {
+        previousSymbol = nil
+        followsPeriod = false
+        guard tracksConstructs else { return }
+        settlePendingBeforeNonWord()
+    }
+
+    mutating func observeSemicolon() -> Bool {
+        previousSymbol = nil
+        followsPeriod = false
+        guard lead == .decided else { return true }
+
+        switch kind {
+        case .sql, .embeddedSourceHeader:
+            return true
+        case .opaque:
+            return false
+        case .anonymousBlock, .storedUnit:
+            settlePendingBeforeNonWord()
+            endForwardDeclaration()
+            return constructs.isEmpty
+        case .inlineDeclarations:
+            guard !inlineQueryStarted else { return true }
+            settlePendingBeforeNonWord()
+            endForwardDeclaration()
+            if constructs.isEmpty {
+                expectsDeclaration = true
+            }
+            return false
+        }
+    }
+
+    mutating func reset() {
+        self = PLSQLUnitTracker()
+    }
+
+    // MARK: - Private
+
+    private var tracksConstructs: Bool {
+        guard lead == .decided else { return false }
+        switch kind {
+        case .anonymousBlock, .storedUnit, .embeddedSourceHeader:
+            return true
+        case .inlineDeclarations:
+            return !inlineQueryStarted
+        case .sql, .opaque:
+            return false
+        }
+    }
+
+    private mutating func decideLead(_ word: String) {
+        switch word {
+        case "DECLARE":
+            lead = .decided
+            kind = .anonymousBlock
+            constructs.append(true)
+        case "BEGIN":
+            lead = .decided
+            kind = .anonymousBlock
+            constructs.append(false)
+        case "CREATE":
+            lead = .afterCreate
+        case "WITH":
+            lead = .afterWith
+        default:
+            lead = .decided
+        }
+    }
+
+    private mutating func continueCreate(_ word: String) {
+        guard !Self.createModifiers.contains(word) else { return }
+        lead = .decided
+        switch word {
+        case "PROCEDURE", "FUNCTION":
+            kind = .storedUnit
+            header = .subprogram
+        case "PACKAGE":
+            kind = .storedUnit
+            header = .unitBody
+        case "TRIGGER":
+            kind = .storedUnit
+            header = .trigger
+        case "TYPE":
+            kind = .storedUnit
+            lead = .afterCreateType
+        case "LIBRARY":
+            kind = .storedUnit
+        case "JAVA", "MLE":
+            kind = .embeddedSourceHeader
+            header = .embeddedSource
+        default:
+            break
+        }
+    }
+
+    private mutating func observeHeaderWord(_ word: String, in header: Header) {
+        if word == "WRAPPED", header != .embeddedSource {
+            kind = .opaque
+            self.header = nil
+            return
+        }
+        switch header {
+        case .subprogram:
+            if word == "IS" || word == "AS" {
+                pendingBodyKeyword = true
+            }
+        case .unitBody:
+            if word == "IS" || word == "AS" {
+                self.header = nil
+                constructs.append(true)
+            }
+        case .trigger:
+            observeTriggerHeaderWord(word)
+        case .embeddedSource:
+            if word == "AS" {
+                kind = .opaque
+                self.header = nil
+            }
+        }
+    }
+
+    private mutating func observeTriggerHeaderWord(_ word: String) {
+        switch word {
+        case "DECLARE":
+            header = nil
+            constructs.append(true)
+        case "BEGIN", "COMPOUND":
+            header = nil
+            constructs.append(false)
+        case "CALL":
+            header = nil
+            callsRoutine = true
+        default:
+            break
+        }
+    }
+
+    private mutating func observeBodyWord(_ word: String) {
+        switch word {
+        case "BEGIN":
+            if constructs.last == true {
+                constructs[constructs.count - 1] = false
+            } else {
+                constructs.append(false)
+            }
+        case "DECLARE":
+            constructs.append(true)
+        case "CASE":
+            constructs.append(false)
+        case "END":
+            pendingEnd = true
+        case "PROCEDURE", "FUNCTION":
+            if parenDepth == 0 {
+                header = .subprogram
+            }
+        default:
+            break
+        }
+    }
+
+    /// Returns whether `word` was consumed by the `END` before it.
+    private mutating func closeEnd(followedBy word: String) -> Bool {
+        switch SqlBlockStructure.endingFollowedBy(word) {
+        case .closesControlFlow:
+            return true
+        case .closesCaseStatement:
+            closeConstruct()
+            return true
+        case .closesBlock:
+            closeConstruct()
+            return false
+        }
+    }
+
+    private mutating func settlePendingBeforeNonWord() {
+        if pendingEnd {
+            pendingEnd = false
+            closeConstruct()
+        }
+        if pendingBodyKeyword {
+            pendingBodyKeyword = false
+            header = nil
+            constructs.append(true)
+        }
+    }
+
+    /// A subprogram header ended by `;` rather than `IS` or `AS` is a forward declaration or a package
+    /// specification entry, and opened nothing.
+    private mutating func endForwardDeclaration() {
+        guard header == .subprogram, parenDepth == 0 else { return }
+        header = nil
+    }
+
+    private mutating func closeConstruct() {
+        guard !constructs.isEmpty else { return }
+        constructs.removeLast()
+    }
+}
diff --git a/TablePro/Core/Utilities/SQL/QueryClassifier+PLSQL.swift b/TablePro/Core/Utilities/SQL/QueryClassifier+PLSQL.swift
new file mode 100644
index 0000000000..89b2242f97
--- /dev/null
+++ b/TablePro/Core/Utilities/SQL/QueryClassifier+PLSQL.swift
@@ -0,0 +1,165 @@
+//
+//  QueryClassifier+PLSQL.swift
+//  TablePro
+//
+
+import Foundation
+import TableProPluginKit
+
+/// Tiering Oracle statements that run PL/SQL by what they run rather than by their first word.
+///
+/// Once the editor keeps a unit whole, its leading keyword is all a keyword classifier would see: a `DROP` inside
+/// `EXECUTE IMMEDIATE` would pass as a plain write in a block, and as a safe read in a query whose `WITH` clause
+/// declares a function. Both run server-side code the moment they are sent, exactly as PostgreSQL's `DO` does, so both
+/// carry the same flag that keeps them away from external clients, and their tier is the worst of the statements they
+/// spell out and never below a write. Dynamic SQL built from variables cannot be read, which leaves it where a `CALL`
+/// of a stored procedure is: a write whose effect the text does not show.
+extension QueryClassifier {
+    static func runsPLSQL(_ sql: String, databaseType: DatabaseType) -> Bool {
+        guard SqlDialect.from(databaseTypeId: databaseType.rawValue) == .oracle else { return false }
+        return startsPLSQL(sql)
+    }
+
+    /// An anonymous block opens with `DECLARE` or `BEGIN`, after any number of `<<label>>` prefixes and comments. A
+    /// query runs PL/SQL when its `WITH` clause opens with a `FUNCTION` or `PROCEDURE` declaration.
+    static func startsPLSQL(_ sql: String) -> Bool {
+        var head = strippingLeadingComments(sql)
+        while head.hasPrefix("<<") {
+            guard let close = head.range(of: ">>") else { return false }
+            head = strippingLeadingComments(String(head[close.upperBound...]))
+        }
+        let keyword = leadingWord(of: head)
+        if keyword == "DECLARE" || keyword == "BEGIN" { return true }
+        guard keyword == "WITH" else { return false }
+        let declaration = leadingWord(of: strippingLeadingComments(String(head.dropFirst(keyword.count))))
+        return declaration == "FUNCTION" || declaration == "PROCEDURE"
+    }
+
+    private static func leadingWord(of text: String) -> String {
+        text.prefix { $0.isLetter || $0.isNumber || $0 == "_" }.uppercased()
+    }
+
+    static func plsqlBlockClassification(_ trimmed: String, databaseType: DatabaseType) -> QueryClassification {
+        let body = oracleCode(of: trimmed)
+        var tier: QueryTier = containsKeyword(body, plsqlDestructiveWordRegex) ? .destructive : .write
+        for statement in dynamicStatements(in: trimmed) {
+            tier = QueryClassification.worse(tier, classifyTier(statement, databaseType: databaseType))
+        }
+        return QueryClassification(tier: tier, reachesFilesystemOrExecutesCode: true)
+    }
+
+    /// Whether the block deletes without a `WHERE`, in its own text or in a statement it builds from a literal.
+    static func plsqlBlockDeletesEverything(_ trimmed: String) -> Bool {
+        let body = oracleCode(of: trimmed)
+        let spelledOut = body.split(separator: ";").contains { segment in
+            deletesWithoutWhere(String(segment))
+        }
+        guard !spelledOut else { return true }
+        return dynamicStatements(in: trimmed).contains { statement in
+            deletesWithoutWhere(oracleCode(of: statement))
+        }
+    }
+
+    // MARK: - Private
+
+    private static let plsqlDestructiveWordRegex = try? NSRegularExpression(pattern: #"\b(DROP|TRUNCATE)\b"#)
+    private static let whereWordRegex = try? NSRegularExpression(pattern: #"\sWHERE\s"#)
+    private static let oracleRules = SQLLexicalRules(dialect: .oracle)
+
+    /// The block's code with every literal and comment blanked, read by Oracle's own rules: a backslash never escapes
+    /// a quote, and `q'[...]'` is one literal. The generic stripper would let `'C:\temp\'` run on past its closing
+    /// quote and hide whatever statement follows it.
+    private static func oracleCode(of sql: String) -> String {
+        let text = sql as NSString
+        let length = text.length
+        var code = ""
+        var index = 0
+        var runStart = 0
+        while index < length {
+            guard let end = SQLNonCodeSpan.end(at: index, in: text, rules: oracleRules) else {
+                index += 1
+                continue
+            }
+            code += text.substring(with: NSRange(location: runStart, length: index - runStart)) + " "
+            index = max(end, index + 1)
+            runStart = index
+        }
+        code += text.substring(from: min(runStart, length))
+        return code.uppercased()
+    }
+
+    /// Whether `regex` matches a keyword rather than a member name: `v_list.DELETE` is a collection method, not a
+    /// statement.
+    private static func containsKeyword(_ code: String, _ regex: NSRegularExpression?) -> Bool {
+        firstKeyword(in: code, regex) != nil
+    }
+
+    private static func firstKeyword(in code: String, _ regex: NSRegularExpression?) -> NSRange? {
+        guard let regex else { return nil }
+        let text = code as NSString
+        return regex.matches(in: code, range: NSRange(location: 0, length: text.length)).first { match in
+            var before = match.range.location - 1
+            while before >= 0, StatementBlank.blankLength(in: text, at: before) > 0 {
+                before -= 1
+            }
+            return before < 0 || text.character(at: before) != UInt16(UnicodeScalar(".").value)
+        }?.range
+    }
+
+    /// The documented entry points that run a statement built at run time. The statement is read only when it is
+    /// written out as a literal, which is the only form the text can show.
+    private static let dynamicStatementOpeners: [NSRegularExpression] = [
+        #"\bEXECUTE\s+IMMEDIATE\s+"#,
+        #"\bEXEC_DDL_STATEMENT\s*\(\s*"#,
+        #"\bDBMS_SQL\s*\.\s*PARSE\s*\([^,;]*,\s*"#,
+    ].compactMap { try? NSRegularExpression(pattern: $0, options: [.caseInsensitive]) }
+
+    private static let deleteWordRegex = try? NSRegularExpression(pattern: #"\bDELETE\b"#, options: [])
+
+    private static func dynamicStatements(in sql: String) -> [String] {
+        let text = sql as NSString
+        let whole = NSRange(location: 0, length: text.length)
+        return dynamicStatementOpeners.flatMap { opener in
+            opener.matches(in: sql, range: whole).compactMap { match in
+                literal(in: text, at: match.range.location + match.range.length)
+            }
+        }
+    }
+
+    /// The body of the string literal starting at `offset`, either `'...'` with doubled quotes folded or Oracle's
+    /// `q'[...]'`.
+    private static func literal(in text: NSString, at offset: Int) -> String? {
+        let length = text.length
+        guard offset < length else { return nil }
+        if text.character(at: offset) == SqlLexer.singleQuote {
+            return quotedBody(in: text, from: offset + 1)
+        }
+        guard let span = SqlLexer.skipAlternativeQuotedString(text, at: offset, length: length) else { return nil }
+        let prefixLength = text.character(at: offset) == SqlLexer.smallQ
+            || text.character(at: offset) == SqlLexer.capitalQ ? 3 : 4
+        let bodyStart = offset + prefixLength
+        let bodyEnd = max(bodyStart, span.next - 2)
+        return text.substring(with: NSRange(location: bodyStart, length: bodyEnd - bodyStart))
+    }
+
+    private static func quotedBody(in text: NSString, from start: Int) -> String {
+        let length = text.length
+        var cursor = start
+        while cursor < length {
+            if text.character(at: cursor) == SqlLexer.singleQuote {
+                guard cursor + 1 < length, text.character(at: cursor + 1) == SqlLexer.singleQuote else { break }
+                cursor += 2
+                continue
+            }
+            cursor += 1
+        }
+        return text.substring(with: NSRange(location: start, length: cursor - start))
+            .replacingOccurrences(of: "''", with: "'")
+    }
+
+    private static func deletesWithoutWhere(_ segment: String) -> Bool {
+        guard let keyword = firstKeyword(in: segment, deleteWordRegex) else { return false }
+        let tail = " \((segment as NSString).substring(from: keyword.location)) "
+        return whereWordRegex?.firstMatch(in: tail, range: NSRange(location: 0, length: (tail as NSString).length)) == nil
+    }
+}
diff --git a/TablePro/Core/Utilities/SQL/QueryClassifier.swift b/TablePro/Core/Utilities/SQL/QueryClassifier.swift
index 76d634cd3b..38c6860a21 100644
--- a/TablePro/Core/Utilities/SQL/QueryClassifier.swift
+++ b/TablePro/Core/Utilities/SQL/QueryClassifier.swift
@@ -53,6 +53,9 @@ enum QueryClassifier {
         if let redis = redisClassification(trimmed, databaseType: databaseType) { return redis }
         if let ledger = beancountClassification(trimmed, databaseType: databaseType) { return ledger }
         if let document = documentStoreClassification(trimmed, databaseType: databaseType) { return document }
+        if runsPLSQL(trimmed, databaseType: databaseType) {
+            return plsqlBlockClassification(trimmed, databaseType: databaseType)
+        }
         return sqlClassification(trimmed)
     }
 
@@ -65,6 +68,9 @@ enum QueryClassifier {
         if classification.tier == .destructive { return true }
         guard databaseType != .redis else { return false }
         let trimmed = StatementBlank.trimming(strippingLeadingComments(sql))
+        if runsPLSQL(trimmed, databaseType: databaseType) {
+            return plsqlBlockDeletesEverything(trimmed)
+        }
         guard leadingKeyword(of: trimmed) == "DELETE" else { return false }
         return !hasWhereClause(trimmed)
     }
diff --git a/TablePro/Core/Utilities/SQL/SQLFileParser.swift b/TablePro/Core/Utilities/SQL/SQLFileParser.swift
index c7f9befbad..37a98c5b8a 100644
--- a/TablePro/Core/Utilities/SQL/SQLFileParser.swift
+++ b/TablePro/Core/Utilities/SQL/SQLFileParser.swift
@@ -18,6 +18,7 @@ final class SQLFileParser: Sendable {
         case inDoubleQuotedString
         case inBacktickQuotedString
         case inDollarQuote
+        case inAlternativeQuote
     }
 
     private static let kSemicolon: unichar = 0x3B
@@ -49,6 +50,9 @@ final class SQLFileParser: Sendable {
         case .normal:
             var result = char == kDash || char == kSlash || char == kBackslash || char == kStar
                 || char == kSingleQuote || char == kDoubleQuote || char == kBacktick
+            if dialect == .oracle && char == kDollar {
+                result = true
+            }
             if dialect.supportsDollarQuotes && char == kDollar {
                 result = true
             }
@@ -71,6 +75,8 @@ final class SQLFileParser: Sendable {
             return false
         case .inDollarQuote:
             return char == kDollar
+        case .inAlternativeQuote:
+            return false
         }
     }
 
@@ -125,6 +131,26 @@ final class SQLFileParser: Sendable {
         var dollarTag: String = ""
         var backslashEscapesActive = false
         var collected: [(statement: String, lineNumber: Int)] = []
+
+        /// Oracle's statement grammar, so a PL/SQL unit arrives whole with its own `;`. Every other dialect has
+        /// always split an import at each `;` and relies on `DELIMITER` or dollar quoting for a routine body, and
+        /// keeps doing so.
+        var boundaries: PLSQLUnitTracker?
+        var word: [unichar] = []
+        var alternativeQuoteCloser: unichar = 0
+        var lineHasCode = false
+        var pendingSlashLine = false
+        var pendingSlashTrailing: [unichar] = []
+
+        /// Set for the last pass over the buffer, once the file has nothing more to give. A character held back for
+        /// the one after it is settled with nothing after it, instead of being left in the buffer and dropped.
+        var atEndOfInput = false
+
+        init(dialect: SqlDialect, currentStatement: NSMutableString?) {
+            self.dialect = dialect
+            self.currentStatement = currentStatement
+            self.boundaries = dialect == .oracle ? PLSQLUnitTracker() : nil
+        }
     }
 
     private static func trimmedStatement(_ ctx: ParserContext) -> String {
@@ -135,6 +161,112 @@ final class SQLFileParser: Sendable {
     private static func resetStatement(_ ctx: inout ParserContext) {
         ctx.currentStatement?.setString("")
         ctx.hasStatementContent = false
+        ctx.boundaries?.reset()
+        ctx.word.removeAll(keepingCapacity: true)
+    }
+
+    private static func isLineBlank(_ char: unichar) -> Bool {
+        char == kSpace || char == kTab || char == kCarriageReturn
+    }
+
+    /// Hands the word that just ended to the tracker. A word is only assembled while the tracker still reads words,
+    /// so a statement it has already classified as plain SQL costs nothing per character.
+    private static func flushWord(_ ctx: inout ParserContext) {
+        guard !ctx.word.isEmpty else { return }
+        let word = String(utf16CodeUnits: ctx.word, count: ctx.word.count).uppercased()
+        ctx.word.removeAll(keepingCapacity: true)
+        ctx.boundaries?.observeWord(word)
+    }
+
+    /// Tracks the word `char` belongs to and returns whether `char` starts an Oracle `q'...'` literal, which it does
+    /// only at the start of a word.
+    private static func observeWordCharacter(
+        _ ctx: inout ParserContext,
+        char: unichar,
+        i: Int,
+        nsBuffer: NSString,
+        bufLen: Int
+    ) -> WordStep {
+        guard ctx.boundaries != nil else { return .none }
+        if !ctx.word.isEmpty {
+            if SqlBlockStructure.continuesWord(char, dialect: ctx.dialect) {
+                ctx.word.append(char)
+                return .continues
+            }
+            flushWord(&ctx)
+        }
+        guard SqlBlockStructure.startsWord(nsBuffer, at: i, length: bufLen, dialect: ctx.dialect) else { return .none }
+        if let quoteLength = alternativeQuotePrefixLength(nsBuffer, at: i, bufLen: bufLen) {
+            if quoteLength > 0 {
+                return .opensAlternativeQuote(prefixLength: quoteLength)
+            }
+            guard ctx.atEndOfInput else { return .needsMoreData }
+        }
+        if ctx.boundaries?.needsWords == true {
+            ctx.word.append(char)
+        }
+        return .continues
+    }
+
+    private enum WordStep {
+        case none
+        case continues
+        case needsMoreData
+        case opensAlternativeQuote(prefixLength: Int)
+    }
+
+    /// The length of `q'<delim>` or `nq'<delim>` at `i`, zero when the buffer ends before the delimiter, or nil
+    /// when `i` does not start one.
+    private static func alternativeQuotePrefixLength(_ buffer: NSString, at i: Int, bufLen: Int) -> Int? {
+        var cursor = i
+        let first = buffer.character(at: cursor)
+        if first == SqlLexer.smallN || first == SqlLexer.capitalN {
+            cursor += 1
+        }
+        guard cursor < bufLen else { return 0 }
+        let prefix = buffer.character(at: cursor)
+        guard prefix == SqlLexer.smallQ || prefix == SqlLexer.capitalQ else { return nil }
+        guard cursor + 1 < bufLen else { return 0 }
+        guard buffer.character(at: cursor + 1) == kSingleQuote else { return nil }
+        guard cursor + 2 < bufLen else { return 0 }
+        guard !isWhitespace(buffer.character(at: cursor + 2)) else { return nil }
+        return cursor + 3 - i
+    }
+
+    private static func alternativeQuoteCloser(for opener: unichar) -> unichar {
+        switch opener {
+        case 0x5B: return 0x5D
+        case 0x28: return 0x29
+        case 0x7B: return 0x7D
+        case 0x3C: return 0x3E
+        default: return opener
+        }
+    }
+
+    /// Settles a `/` held back at the start of a line once the line's end shows whether it stood alone.
+    ///
+    /// Returns true when `char` was consumed as trailing whitespace on the `/` line.
+    private static func settlePendingSlashLine(_ ctx: inout ParserContext, char: unichar) -> Bool {
+        guard ctx.pendingSlashLine else { return false }
+        if isLineBlank(char) {
+            ctx.pendingSlashTrailing.append(char)
+            return true
+        }
+        ctx.pendingSlashLine = false
+        if char == kNewline {
+            ctx.pendingSlashTrailing.removeAll()
+            yieldAndReset(&ctx)
+            return false
+        }
+        (ctx.hasStatementContent, ctx.statementStartLine) = markContent(
+            ctx.hasStatementContent, ctx.statementStartLine, ctx.currentLine)
+        appendChar(kSlash, to: ctx.currentStatement)
+        for trailing in ctx.pendingSlashTrailing {
+            appendChar(trailing, to: ctx.currentStatement)
+        }
+        ctx.pendingSlashTrailing.removeAll()
+        ctx.boundaries?.observeSymbol(kSlash)
+        return false
     }
 
     private static func processDelimiterChange(_ ctx: inout ParserContext, char: unichar) {
@@ -162,6 +294,31 @@ final class SQLFileParser: Sendable {
         nsBuffer: NSString,
         bufLen: Int
     ) -> StepResult {
+        if settlePendingSlashLine(&ctx, char: char) {
+            return StepResult(advanced: false, deferred: false)
+        }
+
+        switch observeWordCharacter(&ctx, char: char, i: i, nsBuffer: nsBuffer, bufLen: bufLen) {
+        case .continues:
+            (ctx.hasStatementContent, ctx.statementStartLine) = markContent(
+                ctx.hasStatementContent, ctx.statementStartLine, ctx.currentLine)
+            appendChar(char, to: ctx.currentStatement)
+            return StepResult(advanced: false, deferred: false)
+        case .needsMoreData:
+            return StepResult(advanced: false, deferred: true)
+        case let .opensAlternativeQuote(prefixLength):
+            (ctx.hasStatementContent, ctx.statementStartLine) = markContent(
+                ctx.hasStatementContent, ctx.statementStartLine, ctx.currentLine)
+            appendRange(&ctx, from: i, to: i + prefixLength, in: nsBuffer)
+            ctx.alternativeQuoteCloser = alternativeQuoteCloser(for: nsBuffer.character(at: i + prefixLength - 1))
+            ctx.state = .inAlternativeQuote
+            ctx.boundaries?.observeOpaqueToken()
+            i += prefixLength
+            return StepResult(advanced: true, deferred: false)
+        case .none:
+            break
+        }
+
         processDelimiterChange(&ctx, char: char)
 
         if char == kDash && nextChar == kDash {
@@ -215,20 +372,26 @@ final class SQLFileParser: Sendable {
                 ctx.dollarTag = tag
                 i += length
                 return StepResult(advanced: true, deferred: false)
-            case .needsMoreData:
+            case .needsMoreData where !ctx.atEndOfInput:
                 return StepResult(advanced: false, deferred: true)
-            case .notOpener:
+            case .needsMoreData, .notOpener:
                 break
             }
         }
 
         if let advanced = processQuoteOpen(&ctx, char: char, nextChar: nextChar) {
+            ctx.boundaries?.observeOpaqueToken()
             if advanced { i += 2 }
             return StepResult(advanced: advanced, deferred: false)
         }
 
         if ctx.isSingleCharDelimiter && char == kSemicolon {
-            yieldAndReset(&ctx)
+            processSemicolon(&ctx)
+            return StepResult(advanced: false, deferred: false)
+        }
+
+        if ctx.dialect.endsStatementsAtSlashLines && char == kSlash && !ctx.lineHasCode {
+            ctx.pendingSlashLine = true
             return StepResult(advanced: false, deferred: false)
         }
 
@@ -243,10 +406,70 @@ final class SQLFileParser: Sendable {
             ctx.statementStartLine = ctx.currentLine
             ctx.hasStatementContent = true
         }
+        if !isWhitespace(char) {
+            ctx.boundaries?.observeSymbol(char)
+        }
         appendChar(char, to: ctx.currentStatement)
         return StepResult(advanced: false, deferred: false)
     }
 
+    /// A `;` ends the statement unless Oracle's grammar holds it inside a PL/SQL unit, and a unit keeps the `;` that
+    /// ends it.
+    private static func processSemicolon(_ ctx: inout ParserContext) {
+        guard ctx.boundaries != nil else {
+            yieldAndReset(&ctx)
+            return
+        }
+        flushWord(&ctx)
+        let endsStatement = ctx.boundaries?.observeSemicolon() ?? true
+        guard endsStatement else {
+            appendChar(kSemicolon, to: ctx.currentStatement)
+            return
+        }
+        if ctx.boundaries?.terminator == .partOfStatement, ctx.hasStatementContent {
+            appendChar(kSemicolon, to: ctx.currentStatement)
+        }
+        yieldAndReset(&ctx)
+    }
+
+    private static func processAlternativeQuote(
+        _ ctx: inout ParserContext,
+        i: inout Int,
+        nsBuffer: NSString,
+        bufLen: Int
+    ) -> StepResult {
+        let start = i
+        var pos = i
+        while pos < bufLen {
+            let ch = nsBuffer.character(at: pos)
+            if pos > start && ch == kNewline {
+                ctx.currentLine += 1
+            }
+            if ch == ctx.alternativeQuoteCloser {
+                if pos + 1 >= bufLen {
+                    if ctx.atEndOfInput {
+                        pos += 1
+                        continue
+                    }
+                    appendRange(&ctx, from: start, to: pos, in: nsBuffer)
+                    i = pos
+                    return StepResult(advanced: true, deferred: true)
+                }
+                if nsBuffer.character(at: pos + 1) == kSingleQuote {
+                    pos += 2
+                    ctx.state = .normal
+                    appendRange(&ctx, from: start, to: pos, in: nsBuffer)
+                    i = pos
+                    return StepResult(advanced: true, deferred: false)
+                }
+            }
+            pos += 1
+        }
+        appendRange(&ctx, from: start, to: pos, in: nsBuffer)
+        i = pos
+        return StepResult(advanced: true, deferred: false)
+    }
+
     private static func processQuoteOpen(
         _ ctx: inout ParserContext,
         char: unichar,
@@ -341,6 +564,10 @@ final class SQLFileParser: Sendable {
 
             if escapesActive && ch == kBackslash {
                 if pos + 1 >= bufLen {
+                    if ctx.atEndOfInput {
+                        pos += 1
+                        continue
+                    }
                     appendRange(&ctx, from: start, to: pos, in: nsBuffer)
                     i = pos
                     return StepResult(advanced: true, deferred: true)
@@ -352,12 +579,12 @@ final class SQLFileParser: Sendable {
             }
 
             if ch == quoteChar {
-                if pos + 1 >= bufLen {
+                if pos + 1 >= bufLen && !ctx.atEndOfInput {
                     appendRange(&ctx, from: start, to: pos, in: nsBuffer)
                     i = pos
                     return StepResult(advanced: true, deferred: true)
                 }
-                let next = nsBuffer.character(at: pos + 1)
+                let next: unichar? = pos + 1 < bufLen ? nsBuffer.character(at: pos + 1) : nil
                 if next == quoteChar {
                     pos += 2
                     continue
@@ -396,6 +623,10 @@ final class SQLFileParser: Sendable {
 
             if ch == kDollar {
                 if pos + closeLen > bufLen {
+                    if ctx.atEndOfInput {
+                        pos += 1
+                        continue
+                    }
                     appendRange(&ctx, from: start, to: pos, in: nsBuffer)
                     i = pos
                     return StepResult(advanced: true, deferred: true)
@@ -492,6 +723,8 @@ final class SQLFileParser: Sendable {
             let rawData = handle.readData(ofLength: chunkSize)
 
             if rawData.isEmpty && !decoder.hasPendingBytes {
+                ctx.atEndOfInput = true
+                processBuffer()
                 emitTrailingStatement()
                 finished = true
                 closeFile()
@@ -523,7 +756,7 @@ final class SQLFileParser: Sendable {
                 let char = nsBuffer.character(at: i)
                 let nextChar: unichar? = (i + 1 < bufLen) ? nsBuffer.character(at: i + 1) : nil
 
-                if nextChar == nil && SQLFileParser.needsLookahead(
+                if nextChar == nil && !ctx.atEndOfInput && SQLFileParser.needsLookahead(
                     char,
                     state: ctx.state,
                     dialect: dialect,
@@ -581,9 +814,21 @@ final class SQLFileParser: Sendable {
                         nsBuffer: nsBuffer, bufLen: bufLen)
                     didManuallyAdvance = result.advanced
                     shouldDefer = result.deferred
+
+                case .inAlternativeQuote:
+                    let result = SQLFileParser.processAlternativeQuote(
+                        &ctx, i: &i,
+                        nsBuffer: nsBuffer, bufLen: bufLen)
+                    didManuallyAdvance = result.advanced
+                    shouldDefer = result.deferred
                 }
 
                 if shouldDefer { break }
+                if char == SQLFileParser.kNewline {
+                    ctx.lineHasCode = false
+                } else if !SQLFileParser.isLineBlank(char) && !ctx.pendingSlashLine {
+                    ctx.lineHasCode = true
+                }
                 if !didManuallyAdvance { i += 1 }
             }
 
@@ -595,6 +840,8 @@ final class SQLFileParser: Sendable {
         }
 
         private func emitTrailingStatement() {
+            ctx.pendingSlashLine = false
+            ctx.pendingSlashTrailing.removeAll()
             guard ctx.hasStatementContent else { return }
             let text = SQLFileParser.trimmedStatement(ctx)
             if SQLFileParser.extractDelimiterChange(text) == nil {
diff --git a/TablePro/Core/Utilities/SQL/SQLNonCodeSpan.swift b/TablePro/Core/Utilities/SQL/SQLNonCodeSpan.swift
index e73007889c..0cb61774b7 100644
--- a/TablePro/Core/Utilities/SQL/SQLNonCodeSpan.swift
+++ b/TablePro/Core/Utilities/SQL/SQLNonCodeSpan.swift
@@ -36,6 +36,9 @@ enum SQLNonCodeSpan {
         if let end = endOfEscapeString(at: index, in: text, rules: rules) {
             return end
         }
+        if let end = endOfAlternativeQuotedString(at: index, in: text, rules: rules) {
+            return end
+        }
         if rules.bracketsDelimitIdentifiers, character == openBracket {
             return endOfBracketedIdentifier(at: index, in: text)
         }
@@ -81,6 +84,15 @@ enum SQLNonCodeSpan {
         ).next
     }
 
+    private static func endOfAlternativeQuotedString(at index: Int, in text: NSString, rules: SQLLexicalRules) -> Int? {
+        guard rules.dialect.supportsAlternativeQuoting,
+              index == 0 || !isWordUnit(text.character(at: index - 1))
+        else {
+            return nil
+        }
+        return SqlLexer.skipAlternativeQuotedString(text, at: index, length: text.length)?.next
+    }
+
     private static func endOfBracketedIdentifier(at index: Int, in text: NSString) -> Int {
         let length = text.length
         var cursor = index + 1
diff --git a/TablePro/Core/Utilities/SQL/SQLParameterExtractor.swift b/TablePro/Core/Utilities/SQL/SQLParameterExtractor.swift
index 8a133d4671..65ebdb2704 100644
--- a/TablePro/Core/Utilities/SQL/SQLParameterExtractor.swift
+++ b/TablePro/Core/Utilities/SQL/SQLParameterExtractor.swift
@@ -7,6 +7,14 @@ import Foundation
 import TableProPluginKit
 
 enum SQLParameterExtractor {
+    /// The text the parameter panel reads names from: every statement that can bind one, joined.
+    ///
+    /// A definition is left out, because its `:name` is never a bind parameter: `:NEW` in a trigger body is a
+    /// pseudo-record, and rewriting it into a placeholder stores a broken trigger.
+    static func parameterSource(of statements: [SQLStatementScanner.ExecutableStatement]) -> String {
+        statements.filter(\.acceptsBindParameters).map(\.sql).joined(separator: "; ")
+    }
+
     static func extractParameters(from sql: String) -> [String] {
         var result: [String] = []
         var seen = Set<String>()
diff --git a/TablePro/Core/Utilities/SQL/SQLRoutineBodyTracker.swift b/TablePro/Core/Utilities/SQL/SQLRoutineBodyTracker.swift
new file mode 100644
index 0000000000..3e4bd64684
--- /dev/null
+++ b/TablePro/Core/Utilities/SQL/SQLRoutineBodyTracker.swift
@@ -0,0 +1,112 @@
+//
+//  SQLRoutineBodyTracker.swift
+//  TablePro
+//
+
+import Foundation
+
+/// Statement boundaries for the dialects whose only `;`-holding construct is a routine body written `BEGIN ... END`.
+///
+/// A `BEGIN` opens a body only inside a statement that defines a routine, for the safety reason recorded on
+/// ``SqlBlockStructure/opensRoutineDefinition(_:)``. The `;` never belongs to the statement: every one of these
+/// engines accepts a statement without it.
+struct SQLRoutineBodyTracker: SQLStatementBoundaryTracking {
+    private var sawStatementKeyword = false
+    private var definesRoutine = false
+    private var depth = 0
+    private var pendingBegin = false
+    private var pendingEnd = false
+
+    var needsWords: Bool {
+        !sawStatementKeyword || definesRoutine
+    }
+
+    var terminator: SQLStatementTerminator {
+        .separator
+    }
+
+    var acceptsBindParameters: Bool {
+        true
+    }
+
+    mutating func observeWord(_ word: String) {
+        if settlePending(before: word) { return }
+        if !sawStatementKeyword {
+            sawStatementKeyword = true
+            definesRoutine = SqlBlockStructure.opensRoutineDefinition(word)
+        }
+        guard definesRoutine else { return }
+        switch word {
+        case "BEGIN":
+            pendingBegin = true
+        case "CASE":
+            depth += 1
+        case "END":
+            pendingEnd = true
+        default:
+            break
+        }
+    }
+
+    mutating func observeSymbol(_ symbol: UInt16) {
+        settlePendingBeforeNonWord()
+    }
+
+    mutating func observeOpaqueToken() {
+        settlePendingBeforeNonWord()
+    }
+
+    mutating func observeSemicolon() -> Bool {
+        pendingBegin = false
+        if pendingEnd {
+            pendingEnd = false
+            closeBlock()
+        }
+        return depth == 0
+    }
+
+    mutating func reset() {
+        self = SQLRoutineBodyTracker()
+    }
+
+    // MARK: - Private
+
+    /// Returns whether `word` was consumed by the keyword before it, as `IF` is in `END IF`.
+    private mutating func settlePending(before word: String) -> Bool {
+        if pendingBegin {
+            pendingBegin = false
+            if !SqlBlockStructure.beginStartsTransaction(followedBy: word) {
+                depth += 1
+            }
+        }
+        guard pendingEnd else { return false }
+        pendingEnd = false
+        switch SqlBlockStructure.endingFollowedBy(word) {
+        case .closesControlFlow:
+            return true
+        case .closesCaseStatement:
+            closeBlock()
+            return true
+        case .closesBlock:
+            closeBlock()
+            return false
+        }
+    }
+
+    /// A `BEGIN` followed by anything but a word opens a block, and an `END` followed by anything but a word closes
+    /// one, which is what the lookahead these rules replaced decided for the same input.
+    private mutating func settlePendingBeforeNonWord() {
+        if pendingBegin {
+            pendingBegin = false
+            depth += 1
+        }
+        if pendingEnd {
+            pendingEnd = false
+            closeBlock()
+        }
+    }
+
+    private mutating func closeBlock() {
+        depth = max(0, depth - 1)
+    }
+}
diff --git a/TablePro/Core/Utilities/SQL/SQLStatementBoundaryTracking.swift b/TablePro/Core/Utilities/SQL/SQLStatementBoundaryTracking.swift
new file mode 100644
index 0000000000..2a1d90e49a
--- /dev/null
+++ b/TablePro/Core/Utilities/SQL/SQLStatementBoundaryTracking.swift
@@ -0,0 +1,60 @@
+//
+//  SQLStatementBoundaryTracking.swift
+//  TablePro
+//
+
+import Foundation
+import TableProPluginKit
+
+/// What the `;` that ends a statement is to that statement.
+enum SQLStatementTerminator: Equatable, Sendable {
+    /// It separates the statement from the next one, and the driver never sees it.
+    case separator
+
+    /// It belongs to the statement's own grammar. A PL/SQL unit ends in `END;`, and measured on Oracle 23ai a block
+    /// sent without that `;` fails with PLS-00103 while a `CREATE PROCEDURE` sent without it is stored INVALID.
+    case partOfStatement
+}
+
+/// Decides where a statement ends, one token at a time.
+///
+/// Every reader that divides a script into statements feeds the same tracker, so the editor, folding and SQL import
+/// cannot disagree about where a statement stops or what reaches the driver. The API is forward only: a token that
+/// depends on the one after it, such as a `BEGIN` that may start a transaction or an `END` that may close an `IF`, is
+/// settled when that next token arrives. That is what lets the streaming import parser feed it across chunk
+/// boundaries without looking ahead.
+///
+/// Words arrive uppercased. Comments and whitespace never arrive; a string literal, a quoted identifier or a
+/// dollar-quoted body arrives as ``observeOpaqueToken()``.
+protocol SQLStatementBoundaryTracking {
+    /// Whether words still bear on where this statement ends. A reader that has to assemble words itself can stop
+    /// doing so once this is false, which keeps a plain `INSERT` dump free of the cost.
+    var needsWords: Bool { get }
+
+    var terminator: SQLStatementTerminator { get }
+
+    /// Whether a `:name` in this statement can be a bind parameter. It cannot in a definition: Oracle refuses bind
+    /// variables in DDL, and inside a trigger body `:NEW` and `:OLD` are pseudo-records.
+    var acceptsBindParameters: Bool { get }
+
+    mutating func observeWord(_ word: String)
+    mutating func observeSymbol(_ symbol: UInt16)
+    mutating func observeOpaqueToken()
+
+    /// Returns whether this `;` ends the statement.
+    mutating func observeSemicolon() -> Bool
+
+    mutating func reset()
+}
+
+enum SQLStatementBoundaries {
+    /// The one place a dialect is matched to its grammar, so no reader can pick a different one.
+    static func makeTracker(for dialect: SqlDialect) -> any SQLStatementBoundaryTracking {
+        switch dialect {
+        case .oracle:
+            return PLSQLUnitTracker()
+        default:
+            return SQLRoutineBodyTracker()
+        }
+    }
+}
diff --git a/TablePro/Core/Utilities/SQL/SQLStatementScanner.swift b/TablePro/Core/Utilities/SQL/SQLStatementScanner.swift
index 580dd685cf..e9514286d5 100644
--- a/TablePro/Core/Utilities/SQL/SQLStatementScanner.swift
+++ b/TablePro/Core/Utilities/SQL/SQLStatementScanner.swift
@@ -11,11 +11,21 @@ enum SQLStatementScanner {
         let sql: String
         let offset: Int
         let hasContent: Bool
-
-        init(sql: String, offset: Int, hasContent: Bool = true) {
+        let terminator: SQLStatementTerminator
+        let acceptsBindParameters: Bool
+
+        init(
+            sql: String,
+            offset: Int,
+            hasContent: Bool = true,
+            terminator: SQLStatementTerminator = .separator,
+            acceptsBindParameters: Bool = true
+        ) {
             self.sql = sql
             self.offset = offset
             self.hasContent = hasContent
+            self.terminator = terminator
+            self.acceptsBindParameters = acceptsBindParameters
         }
 
         /// The statement's whole span in the document, in UTF-16 units.
@@ -36,8 +46,9 @@ enum SQLStatementScanner {
 
     /// One statement as the driver will receive it, with the span of the text it was taken from.
     ///
-    /// `sql` is the semicolon-stripped, trimmed form; `range` covers exactly those characters, so a caller that keeps
-    /// the range can find its way back to the statement it ran.
+    /// `sql` is the trimmed form, with the terminating `;` stripped unless it belongs to the statement, as it does
+    /// after a PL/SQL unit's `END`; `range` covers exactly those characters, so a caller that keeps the range can find
+    /// its way back to the statement it ran.
     ///
     /// The range is relative to the text the scan was given. A run started from a selection or from a single
     /// statement scans a fragment, so those callers shift the range onto the tab's whole query with ``offset(by:)``
@@ -46,11 +57,22 @@ enum SQLStatementScanner {
         let sql: String
         let range: NSRange
 
+        /// False for a definition, whose `:name` is never a bind parameter; see
+        /// ``SQLStatementBoundaryTracking/acceptsBindParameters``.
+        let acceptsBindParameters: Bool
+
+        init(sql: String, range: NSRange, acceptsBindParameters: Bool = true) {
+            self.sql = sql
+            self.range = range
+            self.acceptsBindParameters = acceptsBindParameters
+        }
+
         func offset(by delta: Int) -> ExecutableStatement {
             guard delta != 0 else { return self }
             return ExecutableStatement(
                 sql: sql,
-                range: NSRange(location: range.location + delta, length: range.length)
+                range: NSRange(location: range.location + delta, length: range.length),
+                acceptsBindParameters: acceptsBindParameters
             )
         }
     }
@@ -62,8 +84,8 @@ enum SQLStatementScanner {
     /// segment that carries nothing from one that was never scanned.
     static func locatedStatements(in sql: String, dialect: SqlDialect = .generic) -> [LocatedStatement] {
         var results: [LocatedStatement] = []
-        scan(sql: sql, cursorPosition: nil, dialect: dialect) { rawSQL, offset, hasStatementContent in
-            results.append(LocatedStatement(sql: rawSQL, offset: offset, hasContent: hasStatementContent))
+        scan(sql: sql, cursorPosition: nil, dialect: dialect) { statement in
+            results.append(statement)
             return true
         }
         return results
@@ -93,8 +115,7 @@ enum SQLStatementScanner {
         dialect: SqlDialect = .generic
     ) -> Int? {
         var found: Int?
-        scan(sql: sql, cursorPosition: nil, dialect: dialect) { rawSQL, statementOffset, hasStatementContent in
-            let statement = LocatedStatement(sql: rawSQL, offset: statementOffset, hasContent: hasStatementContent)
+        scan(sql: sql, cursorPosition: nil, dialect: dialect) { statement in
             guard statement.hasContent, statement.contentRange.length > 0 else { return true }
             guard statement.contentRange.location > offset else { return true }
             found = statement.contentRange.location
@@ -129,8 +150,7 @@ enum SQLStatementScanner {
         dialect: SqlDialect = .generic
     ) -> Int? {
         var found: Int?
-        scan(sql: sql, cursorPosition: nil, dialect: dialect) { rawSQL, statementOffset, hasStatementContent in
-            let statement = LocatedStatement(sql: rawSQL, offset: statementOffset, hasContent: hasStatementContent)
+        scan(sql: sql, cursorPosition: nil, dialect: dialect) { statement in
             guard statement.hasContent, statement.contentRange.length > 0 else { return true }
             guard statement.contentRange.location < offset else { return false }
             found = statement.contentRange.location
@@ -139,7 +159,7 @@ enum SQLStatementScanner {
         return found
     }
 
-    /// Returns statements with trailing semicolons stripped, for driver execution.
+    /// Returns statements as the driver receives them, for driver execution.
     static func allStatements(in sql: String, dialect: SqlDialect = .generic) -> [String] {
         executableStatements(in: sql, dialect: dialect).map(\.sql)
     }
@@ -151,35 +171,54 @@ enum SQLStatementScanner {
     /// semicolon, while execution strips one, so pointing execution at it would change which text reaches the driver.
     static func executableStatements(in sql: String, dialect: SqlDialect = .generic) -> [ExecutableStatement] {
         var results: [ExecutableStatement] = []
-        scan(sql: sql, cursorPosition: nil, dialect: dialect) { rawSQL, offset, hasStatementContent in
-            guard hasStatementContent,
-                  let statement = executableStatement(rawSQL: rawSQL, offset: offset) else { return true }
+        scan(sql: sql, cursorPosition: nil, dialect: dialect) { located in
+            guard located.hasContent, let statement = executableStatement(from: located) else { return true }
             results.append(statement)
             return true
         }
         return results
     }
 
-    private static func executableStatement(rawSQL: String, offset: Int) -> ExecutableStatement? {
+    /// `text` as a driver receives it when it is sent whole: trimmed, and ending where its last statement's executable
+    /// form ends, so a trailing separator comes off and a terminator that belongs to the statement stays. Empty when
+    /// nothing but separators, comments or blanks is left.
+    static func executableText(of text: String, dialect: SqlDialect) -> String {
+        let trimmed = StatementBlank.trimming(text)
+        guard let last = executableStatements(in: trimmed, dialect: dialect).last else { return "" }
+        let end = last.range.location + last.range.length
+        return StatementBlank.trimming((trimmed as NSString).substring(to: end))
+    }
+
+    /// The text the driver receives for `located`, or nil when nothing but a separator is left.
+    ///
+    /// A `;` that belongs to the statement stays, but only when there is something before it: a unit reduced to its
+    /// terminator is as empty as any other.
+    static func executableStatement(from located: LocatedStatement) -> ExecutableStatement? {
+        let rawSQL = located.sql
         var content = StatementBlank.trimming(rawSQL[...])
         if content.last == ";" {
-            content = StatementBlank.trimming(content.dropLast())
+            let body = StatementBlank.trimming(content.dropLast())
+            guard !body.isEmpty else { return nil }
+            if located.terminator == .separator {
+                content = body
+            }
         }
         guard !content.isEmpty else { return nil }
 
         let range = NSRange(content.startIndex..<content.endIndex, in: rawSQL)
         return ExecutableStatement(
             sql: String(content),
-            range: NSRange(location: offset + range.location, length: range.length)
+            range: NSRange(location: located.offset + range.location, length: range.length),
+            acceptsBindParameters: located.acceptsBindParameters
         )
     }
 
     /// Returns statements preserving trailing semicolons, for display/history/favorites.
     static func allStatementsPreservingSemicolons(in sql: String) -> [String] {
         var results: [String] = []
-        scan(sql: sql, cursorPosition: nil) { rawSQL, _, hasStatementContent in
-            guard hasStatementContent else { return true }
-            let trimmed = StatementBlank.trimming(rawSQL)
+        scan(sql: sql, cursorPosition: nil) { statement in
+            guard statement.hasContent else { return true }
+            let trimmed = StatementBlank.trimming(statement.sql)
             let withoutSemicolon = trimmed.hasSuffix(";")
                 ? StatementBlank.trimming(String(trimmed.dropLast()))
                 : trimmed
@@ -192,19 +231,14 @@ enum SQLStatementScanner {
     }
 
     static func statementAtCursor(in sql: String, cursorPosition: Int, dialect: SqlDialect = .generic) -> String {
-        var result = StatementBlank.trimming(
-            locatedStatementAtCursor(in: sql, cursorPosition: cursorPosition, dialect: dialect).sql
-        )
-        if result.hasSuffix(";") {
-            result = StatementBlank.trimming(String(result.dropLast()))
-        }
-        return result
+        let located = locatedStatementAtCursor(in: sql, cursorPosition: cursorPosition, dialect: dialect)
+        return executableStatement(from: located)?.sql ?? ""
     }
 
     static func locatedStatementAtCursor(in sql: String, cursorPosition: Int, dialect: SqlDialect = .generic) -> LocatedStatement {
         var result = LocatedStatement(sql: "", offset: 0, hasContent: false)
-        scan(sql: sql, cursorPosition: cursorPosition, dialect: dialect) { rawSQL, offset, hasStatementContent in
-            result = LocatedStatement(sql: rawSQL, offset: offset, hasContent: hasStatementContent)
+        scan(sql: sql, cursorPosition: cursorPosition, dialect: dialect) { statement in
+            result = statement
             return false
         }
         return result
@@ -212,11 +246,17 @@ enum SQLStatementScanner {
 
     // MARK: - Private
 
+    /// Walks the document once and hands each segment to `onStatement`, which returns false to stop.
+    ///
+    /// Segments tile the document: a statement runs from the end of the previous one to its terminator, so it carries
+    /// the whitespace before it. With a `cursorPosition`, only the segment holding it is reported, or the last one
+    /// when the cursor sits past every terminator. Where a statement ends is the tracker's decision; this loop only
+    /// lexes, so a `;` inside a string, a comment or a quoted body never reaches it.
     private static func scan(
         sql: String,
         cursorPosition: Int?,
         dialect: SqlDialect = .generic,
-        onStatement: (_ rawSQL: String, _ offset: Int, _ hasStatementContent: Bool) -> Bool
+        onStatement: (LocatedStatement) -> Bool
     ) {
         let nsQuery = sql as NSString
         let length = nsQuery.length
@@ -224,165 +264,228 @@ enum SQLStatementScanner {
 
         let safePosition = cursorPosition.map { min(max(0, $0), length) }
 
+        var tracker = SQLStatementBoundaries.makeTracker(for: dialect)
+        var nonCode = NonCodeSpan(backslashEscapes: dialect != .oracle)
         var currentStart = 0
-        var inString = false
-        var stringCharVal: UInt16 = 0
-        var inLineComment = false
-        var inBlockComment = false
-        var inDollarQuote = false
-        var dollarTag = ""
         var hasStatementContent = false
-        var opensRoutineDefinition = false
-        var sawStatementKeyword = false
-        var blockDepth = 0
         let dollarQuotesEnabled = dialect.supportsDollarQuotes
         let hashCommentsEnabled = dialect.supportsHashLineComments
         var i = 0
 
-        while i < length {
-            let ch = nsQuery.character(at: i)
+        var lastStatementWithContent: LocatedStatement?
 
-            if inLineComment {
-                if ch == SqlLexer.newline { inLineComment = false }
-                i += 1
-                continue
+        /// Reports the segment ending at `end` and starts the next one there. Returns false when the scan is done.
+        ///
+        /// A caret on a SQL*Plus `/` line stands for the statement the slash ends, which is where a reader who has
+        /// just typed the slash expects `Cmd+Enter` to act.
+        func finishSegment(at end: Int, hasContent: Bool, endsWithSlash: Bool = false) -> Bool {
+            let statement = LocatedStatement(
+                sql: nsQuery.substring(with: NSRange(location: currentStart, length: end - currentStart)),
+                offset: currentStart,
+                hasContent: hasContent,
+                terminator: tracker.terminator,
+                acceptsBindParameters: tracker.acceptsBindParameters
+            )
+            if hasContent {
+                lastStatementWithContent = statement
             }
-
-            if inBlockComment {
-                if ch == SqlLexer.star && i + 1 < length && nsQuery.character(at: i + 1) == SqlLexer.slash {
-                    inBlockComment = false
-                    i += 2
-                    continue
+            if let cursor = safePosition {
+                guard cursor >= currentStart, cursor <= end else {
+                    currentStart = end
+                    return true
                 }
-                i += 1
-                continue
+                _ = onStatement(endsWithSlash ? lastStatementWithContent ?? statement : statement)
+                return false
             }
+            currentStart = end
+            return onStatement(statement)
+        }
 
-            if inDollarQuote {
-                if ch == SqlDollarQuote.dollar,
-                   SqlDollarQuote.matchesClose(at: i, tag: dollarTag, in: nsQuery, bufLen: length) {
-                    inDollarQuote = false
-                    i += (dollarTag as NSString).length + 2
-                    dollarTag = ""
-                    continue
-                }
-                i += 1
+        while i < length {
+            let ch = nsQuery.character(at: i)
+
+            if nonCode.isOpen {
+                i = nonCode.advance(from: i, in: nsQuery, length: length)
                 continue
             }
 
-            if !inString && SqlLexer.startsLineComment(nsQuery, at: i, length: length) {
-                inLineComment = true
+            if SqlLexer.startsLineComment(nsQuery, at: i, length: length) {
+                nonCode.state = .lineComment
                 i += 2
                 continue
             }
 
-            if !inString && hashCommentsEnabled && ch == SqlLexer.hash {
-                inLineComment = true
+            if hashCommentsEnabled && ch == SqlLexer.hash {
+                nonCode.state = .lineComment
                 i += 1
                 continue
             }
 
-            if !inString && SqlLexer.startsBlockComment(nsQuery, at: i, length: length) {
+            if SqlLexer.startsBlockComment(nsQuery, at: i, length: length) {
                 if SqlLexer.startsConditionalComment(nsQuery, at: i, length: length) {
                     hasStatementContent = true
                 }
-                inBlockComment = true
-                i += 2
-                continue
-            }
-
-            if inString && ch == SqlLexer.backslash && i + 1 < length {
+                nonCode.state = .blockComment
                 i += 2
                 continue
             }
 
             if SqlLexer.isQuote(ch) {
-                if !inString {
-                    inString = true
-                    stringCharVal = ch
-                } else if ch == stringCharVal {
-                    if i + 1 < length && nsQuery.character(at: i + 1) == stringCharVal {
-                        i += 1
-                    } else {
-                        inString = false
-                    }
-                }
+                nonCode.state = .string(quote: ch)
+                hasStatementContent = true
+                tracker.observeOpaqueToken()
+                i += 1
+                continue
             }
 
-            if dollarQuotesEnabled, !inString, ch == SqlDollarQuote.dollar,
+            if dollarQuotesEnabled, ch == SqlDollarQuote.dollar,
                case .opener(let openerLength, let tag) = SqlDollarQuote.scanOpener(at: i, in: nsQuery, bufLen: length) {
-                inDollarQuote = true
-                dollarTag = tag
+                nonCode.state = .dollarQuote(tag: tag)
                 hasStatementContent = true
+                tracker.observeOpaqueToken()
                 i += openerLength
                 continue
             }
 
-            if !inString, SqlDollarQuote.isIdentifierStart(ch) {
-                let word = SqlBlockStructure.readKeyword(nsQuery, at: i, length: length)
-                if !sawStatementKeyword {
-                    sawStatementKeyword = true
-                    opensRoutineDefinition = SqlBlockStructure.opensRoutineDefinition(word.text)
-                }
+            if SqlBlockStructure.startsWord(nsQuery, at: i, length: length, dialect: dialect) {
                 hasStatementContent = true
-                switch SqlBlockStructure.effect(
-                    of: word.text,
-                    endingAt: word.end,
-                    in: nsQuery,
-                    length: length,
-                    allowsBlock: opensRoutineDefinition
-                ) {
-                case .opensBlock:
-                    blockDepth += 1
-                case .closesBlock:
-                    blockDepth = max(0, blockDepth - 1)
-                case .none:
-                    break
+                if dialect.supportsAlternativeQuoting,
+                   let literal = SqlLexer.skipAlternativeQuotedString(nsQuery, at: i, length: length) {
+                    tracker.observeOpaqueToken()
+                    i = literal.next
+                    continue
+                }
+                if tracker.needsWords {
+                    let word = SqlBlockStructure.readKeyword(nsQuery, at: i, length: length, dialect: dialect)
+                    tracker.observeWord(word.text)
+                    i = word.end
+                } else {
+                    i += 1
+                    while i < length, SqlBlockStructure.continuesWord(nsQuery.character(at: i), dialect: dialect) {
+                        i += 1
+                    }
                 }
-                i = word.end
                 continue
             }
 
-            if ch == SqlLexer.semicolon && !inString && blockDepth > 0 {
-                hasStatementContent = true
+            if ch == SqlLexer.semicolon {
+                guard tracker.observeSemicolon() else {
+                    hasStatementContent = true
+                    i += 1
+                    continue
+                }
+                guard finishSegment(at: i + 1, hasContent: hasStatementContent) else { return }
+                tracker.reset()
+                hasStatementContent = false
                 i += 1
                 continue
             }
 
-            if ch == SqlLexer.semicolon && !inString {
-                let stmtEnd = i + 1
-
-                if let cursor = safePosition {
-                    if cursor >= currentStart && cursor <= stmtEnd {
-                        let stmtRange = NSRange(location: currentStart, length: stmtEnd - currentStart)
-                        _ = onStatement(nsQuery.substring(with: stmtRange), currentStart, hasStatementContent)
-                        return
-                    }
-                } else {
-                    let stmtRange = NSRange(location: currentStart, length: stmtEnd - currentStart)
-                    if !onStatement(nsQuery.substring(with: stmtRange), currentStart, hasStatementContent) { return }
+            if dialect.endsStatementsAtSlashLines, ch == SqlLexer.slash, isSlashLine(nsQuery, at: i, length: length) {
+                if hasStatementContent {
+                    guard finishSegment(at: i, hasContent: true) else { return }
                 }
-
-                currentStart = stmtEnd
+                guard finishSegment(at: i + 1, hasContent: false, endsWithSlash: true) else { return }
+                tracker.reset()
                 hasStatementContent = false
-                sawStatementKeyword = false
-                opensRoutineDefinition = false
-                blockDepth = 0
-            } else if !hasStatementContent {
-                let blankLength = StatementBlank.blankLength(in: nsQuery, at: i)
-                guard blankLength == 0 else {
-                    i += blankLength
-                    continue
-                }
-                hasStatementContent = true
+                i += 1
+                continue
             }
 
+            let blankLength = StatementBlank.blankLength(in: nsQuery, at: i)
+            if blankLength > 0 {
+                i += blankLength
+                continue
+            }
+            hasStatementContent = true
+            tracker.observeSymbol(ch)
             i += 1
         }
 
         if currentStart < length {
-            let stmtRange = NSRange(location: currentStart, length: length - currentStart)
-            _ = onStatement(nsQuery.substring(with: stmtRange), currentStart, hasStatementContent)
+            let statement = LocatedStatement(
+                sql: nsQuery.substring(with: NSRange(location: currentStart, length: length - currentStart)),
+                offset: currentStart,
+                hasContent: hasStatementContent,
+                terminator: tracker.terminator,
+                acceptsBindParameters: tracker.acceptsBindParameters
+            )
+            _ = onStatement(statement)
+        }
+    }
+
+    /// The literal or comment the scan is inside, where nothing is a token and no `;` ends anything.
+    private struct NonCodeSpan {
+        enum State: Equatable {
+            case code
+            case lineComment
+            case blockComment
+            case string(quote: UInt16)
+            case dollarQuote(tag: String)
         }
+
+        var state = State.code
+
+        /// Whether a backslash keeps a string open. Every dialect but Oracle is scanned as if it did, which only ever
+        /// merges two statements; Oracle never escapes with one.
+        let backslashEscapes: Bool
+
+        var isOpen: Bool {
+            state != .code
+        }
+
+        /// Steps past one unit of the open span, closing it where it ends, and returns the next offset.
+        mutating func advance(from i: Int, in text: NSString, length: Int) -> Int {
+            let ch = text.character(at: i)
+            switch state {
+            case .code:
+                return i + 1
+            case .lineComment:
+                if ch == SqlLexer.newline { state = .code }
+                return i + 1
+            case .blockComment:
+                guard ch == SqlLexer.star, i + 1 < length, text.character(at: i + 1) == SqlLexer.slash else {
+                    return i + 1
+                }
+                state = .code
+                return i + 2
+            case let .dollarQuote(tag):
+                guard ch == SqlDollarQuote.dollar,
+                      SqlDollarQuote.matchesClose(at: i, tag: tag, in: text, bufLen: length) else {
+                    return i + 1
+                }
+                state = .code
+                return i + (tag as NSString).length + 2
+            case let .string(quote):
+                if backslashEscapes, ch == SqlLexer.backslash, i + 1 < length {
+                    return i + 2
+                }
+                guard ch == quote else { return i + 1 }
+                if i + 1 < length, text.character(at: i + 1) == quote {
+                    return i + 2
+                }
+                state = .code
+                return i + 1
+            }
+        }
+    }
+
+    /// Whether the `/` at `offset` stands alone on its line, which is what makes it SQL*Plus's terminator rather than
+    /// a division.
+    static func isSlashLine(_ text: NSString, at offset: Int, length: Int) -> Bool {
+        var before = offset - 1
+        while before >= 0, isLineBlank(text.character(at: before)) {
+            before -= 1
+        }
+        guard before < 0 || text.character(at: before) == SqlLexer.newline else { return false }
+        var after = offset + 1
+        while after < length, isLineBlank(text.character(at: after)) {
+            after += 1
+        }
+        return after == length || text.character(at: after) == SqlLexer.newline
+    }
+
+    private static func isLineBlank(_ character: UInt16) -> Bool {
+        character == SqlLexer.space || character == SqlLexer.tab || character == SqlLexer.carriageReturn
     }
 }
diff --git a/TablePro/Core/Utilities/SQL/SQLTokenCursor.swift b/TablePro/Core/Utilities/SQL/SQLTokenCursor.swift
index 675b3d4d79..abdbe6b372 100644
--- a/TablePro/Core/Utilities/SQL/SQLTokenCursor.swift
+++ b/TablePro/Core/Utilities/SQL/SQLTokenCursor.swift
@@ -152,6 +152,11 @@ internal struct SQLTokenCursor {
 
     private func startsLiteralSpan(at offset: Int) -> Bool {
         let character = text.character(at: offset)
+        if rules.dialect.supportsAlternativeQuoting,
+           offset == 0 || !SQLNonCodeSpan.isWordUnit(text.character(at: offset - 1)),
+           SqlLexer.skipAlternativeQuotedString(text, at: offset, length: length) != nil {
+            return true
+        }
         if rules.dialect.supportsEscapeStringPrefix,
            character == Self.capitalE || character == Self.smallE,
            offset + 1 < length, text.character(at: offset + 1) == SqlLexer.singleQuote,
diff --git a/TablePro/Core/Utilities/SQL/SqlBlockStructure.swift b/TablePro/Core/Utilities/SQL/SqlBlockStructure.swift
index ae3355c706..6ab1c0f5d3 100644
--- a/TablePro/Core/Utilities/SQL/SqlBlockStructure.swift
+++ b/TablePro/Core/Utilities/SQL/SqlBlockStructure.swift
@@ -4,6 +4,7 @@
 //
 
 import Foundation
+import TableProPluginKit
 
 /// The word level rules for the blocks a semicolon does not end.
 ///
@@ -18,12 +19,24 @@ import Foundation
 /// This sits beside ``SqlLexer`` rather than inside it because these rules are about words, not characters.
 enum SqlBlockStructure {
     /// What a keyword does to the block nesting around it.
-    enum Effect {
+    enum Effect: Equatable {
         case opensBlock
-        case closesBlock
+        /// Closes a block and swallows the keyword that follows up to `resumeAt`, which is how `END CASE` reads: the
+        /// `CASE` names what is closing rather than opening another.
+        case closesBlock(resumeAt: Int)
         case none
     }
 
+    /// What an `END` means, given the word after it.
+    enum EndFollower: Equatable {
+        /// `END IF`, `END LOOP` and their kin close a construct that never opened a block, and the word is theirs.
+        case closesControlFlow
+        /// `END CASE` closes the `CASE` that opened a block, and the word is theirs.
+        case closesCaseStatement
+        /// Anything else closes a block and leaves the word to be read on its own, as the name in `END proc_name` is.
+        case closesBlock
+    }
+
     /// The keywords that follow `BEGIN` when it starts a transaction rather than a block.
     ///
     /// `BEGIN;` and `BEGIN TRANSACTION;` are statements in their own right on PostgreSQL, MySQL and SQLite, and
@@ -36,16 +49,19 @@ enum SqlBlockStructure {
 
     /// The keywords that follow `END` when it closes a construct nothing here opened.
     ///
-    /// `END CASE` is absent on purpose: `CASE` opens a block, so its `END` has to close one.
+    /// `END CASE` is absent on purpose: `CASE` opens a block, so its `END` has to close one, and ``endingFollowedBy(_:)``
+    /// gives it its own answer so the `CASE` after it is not read as a second opener.
     private static let controlFlowFollowers: Set<String> = ["IF", "LOOP", "WHILE", "FOR", "REPEAT"]
 
     /// The keywords a statement has to open with before a `BEGIN` inside it is read as a routine body.
     ///
-    /// Only ``SQLStatementScanner`` consults this, and the reason is safety rather than grammar. An anonymous
-    /// `BEGIN ... END` block is real SQL, and folding one is right. Splitting on one is not: a `BEGIN` that swallowed
-    /// the statements after it would hand the execution gate a single statement whose first word is `BEGIN`, and
-    /// `QueryClassifier` tiers a statement by its leading keyword, so a swallowed `DROP` would be classified safe and
-    /// run under Read-Only with no confirmation. Folding cannot execute anything, so it takes every block.
+    /// Only ``SQLRoutineBodyTracker`` consults this, and the reason is safety rather than grammar. An anonymous
+    /// `BEGIN ... END` block is real SQL on some engines, and folding one is right. Splitting on one is not where the
+    /// engine has no such block: a `BEGIN` that swallowed the statements after it would hand the execution gate a
+    /// single statement whose first word is `BEGIN`, and `QueryClassifier` tiers a statement by its leading keyword,
+    /// so a swallowed `DROP` would be tiered a plain write and skip the destructive confirmation. Folding cannot
+    /// execute anything, so it takes every block. Oracle, whose anonymous blocks are the everyday form, has its own
+    /// grammar in ``PLSQLUnitTracker`` and a classifier that reads the whole block.
     private static let routineDefinitionOpeners: Set<String> = ["CREATE", "ALTER", "REPLACE", "DECLARE"]
 
     /// Whether a statement opening with `keyword` can carry a `BEGIN ... END` body.
@@ -58,23 +74,50 @@ enum SqlBlockStructure {
         return transactionFollowers.contains(keyword)
     }
 
+    static func endingFollowedBy(_ keyword: String) -> EndFollower {
+        if keyword == "CASE" { return .closesCaseStatement }
+        return controlFlowFollowers.contains(keyword) ? .closesControlFlow : .closesBlock
+    }
+
     /// The keyword at `offset`, uppercased, and the offset just past it.
     ///
     /// Returns an empty string when `offset` does not start an identifier, along with the next offset, so a caller can
     /// advance one character and carry on without a second bounds check.
     static func readKeyword(_ text: NSString, at offset: Int, length: Int) -> (text: String, end: Int) {
-        guard offset < length, SqlDollarQuote.isIdentifierStart(text.character(at: offset)) else {
+        readKeyword(text, at: offset, length: length, dialect: .generic)
+    }
+
+    /// The keyword at `offset` as `dialect` spells identifiers.
+    ///
+    /// Oracle continues an identifier with `$` and `#`, so `V$SESSION` is one word, and starts a conditional
+    /// compilation directive with `$`, so `$END` is one word that ``PLSQLUnitTracker`` can tell apart from `END`.
+    static func readKeyword(
+        _ text: NSString,
+        at offset: Int,
+        length: Int,
+        dialect: SqlDialect
+    ) -> (text: String, end: Int) {
+        guard offset < length, startsWord(text, at: offset, length: length, dialect: dialect) else {
             return ("", offset + 1)
         }
-        var cursor = offset
-        var scalars = String.UnicodeScalarView()
-        while cursor < length, SqlDollarQuote.isIdentifierPart(text.character(at: cursor)) {
-            if let scalar = UnicodeScalar(text.character(at: cursor)) {
-                scalars.append(scalar)
-            }
+        var cursor = offset + 1
+        while cursor < length, continuesWord(text.character(at: cursor), dialect: dialect) {
             cursor += 1
         }
-        return (String(scalars).uppercased(), cursor)
+        let word = text.substring(with: NSRange(location: offset, length: cursor - offset))
+        return (word.uppercased(), cursor)
+    }
+
+    static func startsWord(_ text: NSString, at offset: Int, length: Int, dialect: SqlDialect) -> Bool {
+        let character = text.character(at: offset)
+        if SqlDollarQuote.isIdentifierStart(character) { return true }
+        guard dialect == .oracle, character == SqlDollarQuote.dollar, offset + 1 < length else { return false }
+        return SqlDollarQuote.isIdentifierStart(text.character(at: offset + 1))
+    }
+
+    static func continuesWord(_ character: UInt16, dialect: SqlDialect) -> Bool {
+        if SqlDollarQuote.isIdentifierPart(character) { return true }
+        return dialect == .oracle && (character == SqlDollarQuote.dollar || character == SqlLexer.hash)
     }
 
     /// What `keyword`, which ends at `wordEnd`, does to the block nesting.
@@ -97,7 +140,7 @@ enum SqlBlockStructure {
         case "CASE":
             return .opensBlock
         case "END":
-            return closesControlFlow(after: wordEnd, in: text, length: length) ? .none : .closesBlock
+            return endEffect(after: wordEnd, in: text, length: length)
         default:
             return .none
         }
@@ -112,10 +155,18 @@ enum SqlBlockStructure {
         return beginStartsTransaction(followedBy: readKeyword(text, at: cursor, length: length).text)
     }
 
-    private static func closesControlFlow(after offset: Int, in text: NSString, length: Int) -> Bool {
+    private static func endEffect(after offset: Int, in text: NSString, length: Int) -> Effect {
         let cursor = skipTrivia(from: offset, in: text, length: length)
-        guard cursor < length else { return false }
-        return controlFlowFollowers.contains(readKeyword(text, at: cursor, length: length).text)
+        guard cursor < length else { return .closesBlock(resumeAt: offset) }
+        let follower = readKeyword(text, at: cursor, length: length)
+        switch endingFollowedBy(follower.text) {
+        case .closesControlFlow:
+            return .none
+        case .closesCaseStatement:
+            return .closesBlock(resumeAt: follower.end)
+        case .closesBlock:
+            return .closesBlock(resumeAt: offset)
+        }
     }
 
     private static func skipTrivia(from offset: Int, in text: NSString, length: Int) -> Int {
diff --git a/TablePro/Core/Utilities/SQL/SqlLexer.swift b/TablePro/Core/Utilities/SQL/SqlLexer.swift
index 12e2a31212..d8d612b8c9 100644
--- a/TablePro/Core/Utilities/SQL/SqlLexer.swift
+++ b/TablePro/Core/Utilities/SQL/SqlLexer.swift
@@ -14,7 +14,8 @@ import TableProPluginKit
 ///
 /// ``skipQuotedString`` gates backslash escapes on the dialect, which is what PostgreSQL requires.
 /// `SQLStatementScanner` deliberately keeps its own ungated handling, because splitting a script for execution is
-/// safer when a backslash never ends a string early; `SQLStatementScannerTests` pins that behaviour.
+/// safer when a backslash never ends a string early; `SQLStatementScannerTests` pins that behaviour. Oracle is the
+/// exception there: a backslash is never an escape in Oracle, and scripts written for it routinely quote Windows paths.
 enum SqlLexer {
     static let space = UInt16(UnicodeScalar(" ").value)
     static let tab = UInt16(UnicodeScalar("\t").value)
@@ -32,6 +33,16 @@ enum SqlLexer {
     static let openParen = UInt16(UnicodeScalar("(").value)
     static let closeParen = UInt16(UnicodeScalar(")").value)
     static let exclamationMark = UInt16(UnicodeScalar("!").value)
+    static let smallQ = UInt16(UnicodeScalar("q").value)
+    static let capitalQ = UInt16(UnicodeScalar("Q").value)
+    static let smallN = UInt16(UnicodeScalar("n").value)
+    static let capitalN = UInt16(UnicodeScalar("N").value)
+    private static let openBracket = UInt16(UnicodeScalar("[").value)
+    private static let closeBracket = UInt16(UnicodeScalar("]").value)
+    private static let openBrace = UInt16(UnicodeScalar("{").value)
+    private static let closeBrace = UInt16(UnicodeScalar("}").value)
+    private static let lessThan = UInt16(UnicodeScalar("<").value)
+    private static let greaterThan = UInt16(UnicodeScalar(">").value)
 
     /// How far a scan ran, and how many lines it crossed. A caller that does not track lines ignores `newlines`.
     struct Span {
@@ -163,6 +174,49 @@ enum SqlLexer {
         return Span(next: length, newlines: newlines)
     }
 
+    /// Runs past an Oracle `q'<delim>...<delim>'` literal, or its national form `nq'...'`, when one starts at
+    /// `offset`.
+    ///
+    /// The body ends at the closing delimiter followed by a quote, so `q'[it's]'` is one literal although a plain scan
+    /// would end it at `it'`. Bracket-like delimiters close with their partner. Returns nil when `offset` does not
+    /// start one; a caller must only ask at the start of a word, because `xq'` is an identifier followed by a string.
+    static func skipAlternativeQuotedString(_ text: NSString, at offset: Int, length: Int) -> Span? {
+        var cursor = offset
+        let first = text.character(at: cursor)
+        if first == smallN || first == capitalN {
+            cursor += 1
+        }
+        guard cursor + 2 < length else { return nil }
+        let prefix = text.character(at: cursor)
+        guard prefix == smallQ || prefix == capitalQ, text.character(at: cursor + 1) == singleQuote else { return nil }
+        let opener = text.character(at: cursor + 2)
+        guard !isWhitespace(opener) else { return nil }
+        let closer = alternativeQuoteCloser(for: opener)
+        cursor += 3
+        var newlines = 0
+        while cursor < length {
+            let character = text.character(at: cursor)
+            if character == newline {
+                newlines += 1
+            }
+            if character == closer, cursor + 1 < length, text.character(at: cursor + 1) == singleQuote {
+                return Span(next: cursor + 2, newlines: newlines)
+            }
+            cursor += 1
+        }
+        return Span(next: length, newlines: newlines)
+    }
+
+    private static func alternativeQuoteCloser(for opener: UInt16) -> UInt16 {
+        switch opener {
+        case openBracket: return closeBracket
+        case openParen: return closeParen
+        case openBrace: return closeBrace
+        case lessThan: return greaterThan
+        default: return opener
+        }
+    }
+
     /// Runs to the closing `$tag$`. `bodyEnd` is where the body stops, `next` is past the closing tag.
     static func skipDollarQuotedBody(
         _ text: NSString,
diff --git a/TablePro/Views/Main/MainContentCoordinator.swift b/TablePro/Views/Main/MainContentCoordinator.swift
index ee7cc27645..d64456d187 100644
--- a/TablePro/Views/Main/MainContentCoordinator.swift
+++ b/TablePro/Views/Main/MainContentCoordinator.swift
@@ -1133,7 +1133,7 @@ final class MainContentCoordinator: ObservableObject {
                 QueryStatementScanner.executableStatements(in: sql, model: statementModel, dialect: sqlDialect)
             )
             guard !paramStatements.isEmpty else { return false }
-            let combinedSQL = paramStatements.map(\.sql).joined(separator: "; ")
+            let combinedSQL = SQLParameterExtractor.parameterSource(of: paramStatements)
             let detectedNames = SQLParameterExtractor.extractParameters(from: combinedSQL)
 
             if !detectedNames.isEmpty {
diff --git a/TableProTests/Core/Compare/CompareSyncExecutorTests.swift b/TableProTests/Core/Compare/CompareSyncExecutorTests.swift
index 7e0335dfcb..a1d84c4b67 100644
--- a/TableProTests/Core/Compare/CompareSyncExecutorTests.swift
+++ b/TableProTests/Core/Compare/CompareSyncExecutorTests.swift
@@ -53,11 +53,11 @@ private final class RecordingDriver: PluginDatabaseDriver, @unchecked Sendable {
 }
 
 final class CompareSyncExecutorTests: XCTestCase {
-    private func endpoint() -> DatabaseEndpoint {
+    private func endpoint(databaseType: DatabaseType = .mysql) -> DatabaseEndpoint {
         DatabaseEndpoint(
             scope: DatabaseScope(connectionId: UUID(), database: "app", schema: nil),
             connectionName: "staging",
-            databaseType: .mysql,
+            databaseType: databaseType,
             safeModeLevel: .silent,
             color: .blue
         )
@@ -78,18 +78,42 @@ final class CompareSyncExecutorTests: XCTestCase {
         statements: [SyncStatement],
         settings: CompareSyncExecutionSettings = CompareSyncExecutionSettings(),
         driver: RecordingDriver,
-        gate: any ExecutionGate = AlwaysAllowGate()
+        gate: any ExecutionGate = AlwaysAllowGate(),
+        databaseType: DatabaseType = .mysql
     ) async throws -> CompareSyncRunResult {
         try await CompareSyncExecutor(gate: gate).apply(
             statements: statements,
             mode: .structure,
             settings: settings,
-            target: endpoint(),
+            target: endpoint(databaseType: databaseType),
             driver: driver,
             progress: Progress()
         )
     }
 
+    // MARK: - Oracle terminators
+
+    /// The script shows every statement ending in `;`, and Oracle stores a CALL-bodied trigger sent with that `;` as
+    /// INVALID while a PL/SQL unit sent without its own is INVALID too.
+    func testOracleStatementsGoOutAsTheEditorSendsThem() async throws {
+        let driver = RecordingDriver()
+        _ = try await run(
+            statements: [
+                statement("CREATE OR REPLACE PROCEDURE p IS BEGIN NULL; END;"),
+                statement("CREATE OR REPLACE TRIGGER t BEFORE INSERT ON x FOR EACH ROW CALL p(:NEW.a);"),
+                statement("CREATE OR REPLACE VIEW v AS SELECT 1 AS a FROM dual;"),
+            ],
+            driver: driver,
+            databaseType: .oracle
+        )
+
+        XCTAssertEqual(driver.executed, [
+            "CREATE OR REPLACE PROCEDURE p IS BEGIN NULL; END;",
+            "CREATE OR REPLACE TRIGGER t BEFORE INSERT ON x FOR EACH ROW CALL p(:NEW.a)",
+            "CREATE OR REPLACE VIEW v AS SELECT 1 AS a FROM dual",
+        ])
+    }
+
     // MARK: - Held back statements
 
     func testRefusedStatementIsNotExecutedUnlessAllowed() async throws {
diff --git a/TableProTests/Core/Database/DatabaseAccessBridgeStatementTests.swift b/TableProTests/Core/Database/DatabaseAccessBridgeStatementTests.swift
index 5ccf62b46d..8ea4caa1fe 100644
--- a/TableProTests/Core/Database/DatabaseAccessBridgeStatementTests.swift
+++ b/TableProTests/Core/Database/DatabaseAccessBridgeStatementTests.swift
@@ -15,12 +15,12 @@ struct DatabaseAccessBridgeStatementTests {
         arguments: ["\u{FEFF}\u{0008}SELECT 1;\u{00A0};\u{200B}", "\u{3000}SELECT 1\u{2028}", " SELECT 1 ; "]
     )
     func trimsInvisibleCharacters(sql: String) {
-        #expect(DatabaseAccessBridge.stripTrailingSemicolons(sql) == "SELECT 1")
+        #expect(DatabaseAccessBridge.statementText(sql, dialect: .generic) == "SELECT 1")
     }
 
     @Test("A statement of nothing but invisible characters is empty")
     func invisibleOnlyStatementIsEmpty() {
-        #expect(DatabaseAccessBridge.stripTrailingSemicolons("\u{FEFF}\u{0008};\u{200B}").isEmpty)
+        #expect(DatabaseAccessBridge.statementText("\u{FEFF}\u{0008};\u{200B}", dialect: .generic).isEmpty)
     }
 
     @Test(
@@ -42,7 +42,7 @@ struct DatabaseAccessBridgeStatementTests {
 
     @Test("The text an external client sends is the text that was classified")
     func sentTextMatchesClassifiedText() {
-        let sent = DatabaseAccessBridge.stripTrailingSemicolons("\u{0008}SELECT 1;")
+        let sent = DatabaseAccessBridge.statementText("\u{0008}SELECT 1;", dialect: .postgres)
         #expect(sent == "SELECT 1")
         #expect(QueryClassifier.classifyTier(sent, databaseType: .postgresql) == .safe)
     }
diff --git a/TableProTests/Core/Utilities/SQL/PLSQLScriptCorpus.swift b/TableProTests/Core/Utilities/SQL/PLSQLScriptCorpus.swift
new file mode 100644
index 0000000000..2268485cbf
--- /dev/null
+++ b/TableProTests/Core/Utilities/SQL/PLSQLScriptCorpus.swift
@@ -0,0 +1,377 @@
+//
+//  PLSQLScriptCorpus.swift
+//  TableProTests
+//
+//  Oracle scripts and the exact text each statement reaches the driver as. Every unit here was sent to Oracle 23ai
+//  in that form and compiled VALID or ran, which is what makes the expected text the right answer rather than a
+//  transcription of what the scanner happens to do. scripts/check-oracle-plsql-terminators.sh re-measures the rules
+//  the corpus rests on.
+//
+
+import Foundation
+import Testing
+
+struct PLSQLScriptCase: Sendable, CustomTestStringConvertible {
+    let name: String
+    let script: String
+    let statements: [String]
+
+    var testDescription: String { name }
+}
+
+enum PLSQLScriptCorpus {
+    static let cases: [PLSQLScriptCase] = [
+        PLSQLScriptCase(
+            name: "anonymous block from the issue, then a query",
+            script: """
+            BEGIN
+              DBMS_OUTPUT.PUT_LINE('Hello from PL/SQL');
+            END;
+            SELECT 1 FROM dual;
+            """,
+            statements: [
+                "BEGIN\n  DBMS_OUTPUT.PUT_LINE('Hello from PL/SQL');\nEND;",
+                "SELECT 1 FROM dual",
+            ]
+        ),
+        PLSQLScriptCase(
+            name: "declare block with semicolons and colons in literals",
+            script: """
+            DECLARE
+              v VARCHAR2(20) := 'a:b; c';
+            BEGIN
+              v := v || q'[it's; :x]';
+            END;
+            """,
+            statements: ["DECLARE\n  v VARCHAR2(20) := 'a:b; c';\nBEGIN\n  v := v || q'[it's; :x]';\nEND;"]
+        ),
+        PLSQLScriptCase(
+            name: "procedure with a declaration section",
+            script: """
+            CREATE OR REPLACE PROCEDURE probe_p IS
+              v NUMBER;
+            BEGIN
+              v := 1;
+            END;
+            SELECT object_name FROM user_objects;
+            """,
+            statements: [
+                "CREATE OR REPLACE PROCEDURE probe_p IS\n  v NUMBER;\nBEGIN\n  v := 1;\nEND;",
+                "SELECT object_name FROM user_objects",
+            ]
+        ),
+        PLSQLScriptCase(
+            name: "package specification with no BEGIN",
+            script: """
+            CREATE OR REPLACE PACKAGE probe_pkg AS
+              PROCEDURE a;
+              FUNCTION b RETURN NUMBER;
+            END probe_pkg;
+            SELECT 1 FROM dual;
+            """,
+            statements: [
+                "CREATE OR REPLACE PACKAGE probe_pkg AS\n  PROCEDURE a;\n  FUNCTION b RETURN NUMBER;\nEND probe_pkg;",
+                "SELECT 1 FROM dual",
+            ]
+        ),
+        PLSQLScriptCase(
+            name: "package body with an initialisation section and control flow",
+            script: """
+            CREATE OR REPLACE PACKAGE BODY probe_pkg AS
+              g NUMBER;
+              PROCEDURE a IS
+                v NUMBER;
+              BEGIN
+                CASE g WHEN 1 THEN v := 1; ELSE v := 2; END CASE;
+                IF v = 1 THEN NULL; END IF;
+                FOR i IN 1..2 LOOP NULL; END LOOP;
+              END a;
+              FUNCTION b RETURN NUMBER IS BEGIN RETURN CASE WHEN g > 0 THEN 1 ELSE 0 END; END b;
+            BEGIN
+              g := 1;
+            END probe_pkg;
+            SELECT 2 FROM dual;
+            """,
+            statements: [
+                """
+                CREATE OR REPLACE PACKAGE BODY probe_pkg AS
+                  g NUMBER;
+                  PROCEDURE a IS
+                    v NUMBER;
+                  BEGIN
+                    CASE g WHEN 1 THEN v := 1; ELSE v := 2; END CASE;
+                    IF v = 1 THEN NULL; END IF;
+                    FOR i IN 1..2 LOOP NULL; END LOOP;
+                  END a;
+                  FUNCTION b RETURN NUMBER IS BEGIN RETURN CASE WHEN g > 0 THEN 1 ELSE 0 END; END b;
+                BEGIN
+                  g := 1;
+                END probe_pkg;
+                """,
+                "SELECT 2 FROM dual",
+            ]
+        ),
+        PLSQLScriptCase(
+            name: "object type specification and body",
+            script: """
+            CREATE OR REPLACE TYPE probe_obj AS OBJECT (
+              a NUMBER,
+              MEMBER FUNCTION twice RETURN NUMBER,
+              CONSTRUCTOR FUNCTION probe_obj RETURN SELF AS RESULT
+            );
+            CREATE OR REPLACE TYPE BODY probe_obj AS
+              MEMBER FUNCTION twice RETURN NUMBER IS BEGIN RETURN a * 2; END;
+              CONSTRUCTOR FUNCTION probe_obj RETURN SELF AS RESULT IS
+              BEGIN
+                a := 0;
+                RETURN;
+              END;
+            END;
+            """,
+            statements: [
+                """
+                CREATE OR REPLACE TYPE probe_obj AS OBJECT (
+                  a NUMBER,
+                  MEMBER FUNCTION twice RETURN NUMBER,
+                  CONSTRUCTOR FUNCTION probe_obj RETURN SELF AS RESULT
+                );
+                """,
+                """
+                CREATE OR REPLACE TYPE BODY probe_obj AS
+                  MEMBER FUNCTION twice RETURN NUMBER IS BEGIN RETURN a * 2; END;
+                  CONSTRUCTOR FUNCTION probe_obj RETURN SELF AS RESULT IS
+                  BEGIN
+                    a := 0;
+                    RETURN;
+                  END;
+                END;
+                """,
+            ]
+        ),
+        PLSQLScriptCase(
+            name: "row trigger using pseudo-records",
+            script: """
+            CREATE OR REPLACE TRIGGER probe_trg BEFORE INSERT ON probe_tab
+            REFERENCING NEW AS n FOR EACH ROW
+            BEGIN
+              :n.a := 1;
+            END;
+            INSERT INTO probe_tab (a) VALUES (2);
+            """,
+            statements: [
+                "CREATE OR REPLACE TRIGGER probe_trg BEFORE INSERT ON probe_tab\nREFERENCING NEW AS n FOR EACH ROW\nBEGIN\n  :n.a := 1;\nEND;",
+                "INSERT INTO probe_tab (a) VALUES (2)",
+            ]
+        ),
+        PLSQLScriptCase(
+            name: "trigger whose body is a CALL drops its semicolon",
+            script: """
+            CREATE OR REPLACE TRIGGER probe_call_trg BEFORE INSERT ON probe_tab FOR EACH ROW
+            CALL probe_log(:NEW.a);
+            SELECT 1 FROM dual;
+            """,
+            statements: [
+                "CREATE OR REPLACE TRIGGER probe_call_trg BEFORE INSERT ON probe_tab FOR EACH ROW\nCALL probe_log(:NEW.a)",
+                "SELECT 1 FROM dual",
+            ]
+        ),
+        PLSQLScriptCase(
+            name: "compound trigger with timing point sections",
+            script: """
+            CREATE OR REPLACE TRIGGER probe_cmp_trg FOR INSERT ON probe_tab COMPOUND TRIGGER
+              n NUMBER := 0;
+              PROCEDURE bump IS BEGIN n := n + 1; END bump;
+              BEFORE STATEMENT IS
+              BEGIN
+                n := 0;
+              END BEFORE STATEMENT;
+              AFTER EACH ROW IS
+              BEGIN
+                bump;
+              END AFTER EACH ROW;
+            END probe_cmp_trg;
+            SELECT 3 FROM dual;
+            """,
+            statements: [
+                """
+                CREATE OR REPLACE TRIGGER probe_cmp_trg FOR INSERT ON probe_tab COMPOUND TRIGGER
+                  n NUMBER := 0;
+                  PROCEDURE bump IS BEGIN n := n + 1; END bump;
+                  BEFORE STATEMENT IS
+                  BEGIN
+                    n := 0;
+                  END BEFORE STATEMENT;
+                  AFTER EACH ROW IS
+                  BEGIN
+                    bump;
+                  END AFTER EACH ROW;
+                END probe_cmp_trg;
+                """,
+                "SELECT 3 FROM dual",
+            ]
+        ),
+        PLSQLScriptCase(
+            name: "conditional compilation directives are not END",
+            script: """
+            BEGIN
+              $IF DBMS_DB_VERSION.VER_LE_11 $THEN
+                NULL;
+              $ELSE
+                NULL;
+              $END
+            END;
+            SELECT 4 FROM dual;
+            """,
+            statements: [
+                "BEGIN\n  $IF DBMS_DB_VERSION.VER_LE_11 $THEN\n    NULL;\n  $ELSE\n    NULL;\n  $END\nEND;",
+                "SELECT 4 FROM dual",
+            ]
+        ),
+        PLSQLScriptCase(
+            name: "labels, nested blocks, local subprograms and forward declarations",
+            script: """
+            <<outer>>
+            DECLARE
+              x NUMBER := 1;
+              PROCEDURE inner_p IS BEGIN x := x + 1; END;
+              FUNCTION ext RETURN NUMBER;
+              FUNCTION ext RETURN NUMBER IS BEGIN RETURN 7; END;
+            BEGIN
+              DECLARE y NUMBER; BEGIN y := x; END;
+              <<l1>> LOOP EXIT; END LOOP l1;
+              inner_p;
+            EXCEPTION WHEN OTHERS THEN NULL;
+            END outer;
+            SELECT 5 FROM dual;
+            """,
+            statements: [
+                """
+                <<outer>>
+                DECLARE
+                  x NUMBER := 1;
+                  PROCEDURE inner_p IS BEGIN x := x + 1; END;
+                  FUNCTION ext RETURN NUMBER;
+                  FUNCTION ext RETURN NUMBER IS BEGIN RETURN 7; END;
+                BEGIN
+                  DECLARE y NUMBER; BEGIN y := x; END;
+                  <<l1>> LOOP EXIT; END LOOP l1;
+                  inner_p;
+                EXCEPTION WHEN OTHERS THEN NULL;
+                END outer;
+                """,
+                "SELECT 5 FROM dual",
+            ]
+        ),
+        PLSQLScriptCase(
+            name: "keywords used as member names and inside quoted identifiers",
+            script: """
+            DECLARE
+              TYPE r IS RECORD ("END" NUMBER, begin_at NUMBER);
+              v r;
+            BEGIN
+              v."END" := 1;
+              v.begin_at := v."END";
+            END;
+            SELECT 6 FROM dual;
+            """,
+            statements: [
+                """
+                DECLARE
+                  TYPE r IS RECORD ("END" NUMBER, begin_at NUMBER);
+                  v r;
+                BEGIN
+                  v."END" := 1;
+                  v.begin_at := v."END";
+                END;
+                """,
+                "SELECT 6 FROM dual",
+            ]
+        ),
+        PLSQLScriptCase(
+            name: "call specification opens no body",
+            script: """
+            CREATE OR REPLACE PACKAGE BODY probe_ext AS
+              FUNCTION f RETURN VARCHAR2 AS LANGUAGE JAVA NAME 'java.lang.System.getProperty(java.lang.String) return java.lang.String';
+            END;
+            SELECT 7 FROM dual;
+            """,
+            statements: [
+                """
+                CREATE OR REPLACE PACKAGE BODY probe_ext AS
+                  FUNCTION f RETURN VARCHAR2 AS LANGUAGE JAVA NAME 'java.lang.System.getProperty(java.lang.String) return java.lang.String';
+                END;
+                """,
+                "SELECT 7 FROM dual",
+            ]
+        ),
+        PLSQLScriptCase(
+            name: "query declaring an inline function keeps the function whole",
+            script: """
+            WITH FUNCTION f RETURN NUMBER IS BEGIN RETURN 42; END;
+            SELECT f AS v FROM dual;
+            SELECT 8 FROM dual;
+            """,
+            statements: [
+                "WITH FUNCTION f RETURN NUMBER IS BEGIN RETURN 42; END;\nSELECT f AS v FROM dual",
+                "SELECT 8 FROM dual",
+            ]
+        ),
+        PLSQLScriptCase(
+            name: "SQL*Plus slash lines end units and plain statements",
+            script: """
+            CREATE OR REPLACE PROCEDURE probe_p IS
+            BEGIN
+              NULL;
+            END;
+            /
+            SELECT 9 FROM dual
+            /
+            BEGIN NULL; END;
+            /
+            """,
+            statements: [
+                "CREATE OR REPLACE PROCEDURE probe_p IS\nBEGIN\n  NULL;\nEND;",
+                "SELECT 9 FROM dual",
+                "BEGIN NULL; END;",
+            ]
+        ),
+        PLSQLScriptCase(
+            name: "Java source runs to the slash line",
+            script: """
+            CREATE OR REPLACE AND COMPILE JAVA SOURCE NAMED "Hello" AS
+            public class Hello { public static String hi() { return "hi"; } }
+            /
+            SELECT 10 FROM dual;
+            """,
+            statements: [
+                "CREATE OR REPLACE AND COMPILE JAVA SOURCE NAMED \"Hello\" AS\npublic class Hello { public static String hi() { return \"hi\"; } }",
+                "SELECT 10 FROM dual",
+            ]
+        ),
+        PLSQLScriptCase(
+            name: "a backslash does not escape a quote",
+            script: "SELECT 'C:\\' AS p FROM dual;\nSELECT 11 FROM dual;",
+            statements: ["SELECT 'C:\\' AS p FROM dual", "SELECT 11 FROM dual"]
+        ),
+        PLSQLScriptCase(
+            name: "a slash inside a literal or a comment is not a terminator",
+            script: "SELECT '\n/\n' AS s FROM dual;\n/*\n/\n*/\nSELECT 12 FROM dual;",
+            statements: ["SELECT '\n/\n' AS s FROM dual", "/*\n/\n*/\nSELECT 12 FROM dual"]
+        ),
+        PLSQLScriptCase(
+            name: "consecutive blocks without a slash",
+            script: "BEGIN NULL; END;\nBEGIN NULL; END; -- done\n",
+            statements: ["BEGIN NULL; END;", "BEGIN NULL; END;"]
+        ),
+        PLSQLScriptCase(
+            name: "a variable named like a transaction keyword",
+            script: "DECLARE work NUMBER; BEGIN work := 1; COMMIT; END;",
+            statements: ["DECLARE work NUMBER; BEGIN work := 1; COMMIT; END;"]
+        ),
+        PLSQLScriptCase(
+            name: "CRLF line endings around a slash line",
+            script: "BEGIN\r\n  NULL;\r\nEND;\r\n/\r\nSELECT 13 FROM dual;\r\n",
+            statements: ["BEGIN\r\n  NULL;\r\nEND;", "SELECT 13 FROM dual"]
+        ),
+    ]
+}
diff --git a/TableProTests/Core/Utilities/SQL/QueryClassifierPLSQLTests.swift b/TableProTests/Core/Utilities/SQL/QueryClassifierPLSQLTests.swift
new file mode 100644
index 0000000000..5125adad6a
--- /dev/null
+++ b/TableProTests/Core/Utilities/SQL/QueryClassifierPLSQLTests.swift
@@ -0,0 +1,194 @@
+//
+//  QueryClassifierPLSQLTests.swift
+//  TableProTests
+//
+//  Keeping an Oracle block whole hands the execution gate one statement whose first word is BEGIN or DECLARE. The
+//  gate must still see what the block runs: a DROP inside it asks for the destructive confirmation, and a block is
+//  server-side code that external clients cannot send, the same as PostgreSQL's DO.
+//
+
+import Foundation
+@testable import TablePro
+import TableProPluginKit
+import Testing
+
+@Suite("Query classifier - Oracle PL/SQL blocks")
+struct QueryClassifierPLSQLTests {
+    @Test("A block runs server-side code and is at least a write", arguments: [
+        "BEGIN DBMS_OUTPUT.PUT_LINE('x'); END;",
+        "DECLARE v NUMBER; BEGIN v := 1; END;",
+        "-- note\n<<outer>> BEGIN NULL; END outer;",
+    ])
+    func blockIsCodeExecution(sql: String) {
+        let classification = QueryClassifier.classify(sql, databaseType: .oracle)
+        #expect(classification.tier == .write)
+        #expect(classification.reachesFilesystemOrExecutesCode)
+    }
+
+    @Test("A drop the block spells out is destructive", arguments: [
+        "BEGIN EXECUTE IMMEDIATE 'DROP TABLE users'; END;",
+        "BEGIN EXECUTE IMMEDIATE q'[DROP TABLE users]'; END;",
+        "BEGIN execute immediate 'truncate table users'; END;",
+        "BEGIN DBMS_UTILITY.EXEC_DDL_STATEMENT('DROP TABLE users'); END;",
+        "DECLARE c INTEGER := DBMS_SQL.OPEN_CURSOR; BEGIN DBMS_SQL.PARSE(c, 'DROP TABLE users', DBMS_SQL.NATIVE); END;",
+    ])
+    func dynamicDropIsDestructive(sql: String) {
+        #expect(QueryClassifier.classifyTier(sql, databaseType: .oracle) == .destructive)
+        #expect(QueryClassifier.isDangerousQuery(sql, databaseType: .oracle))
+    }
+
+    @Test("A literal that only mentions a drop does not make the block destructive")
+    func quotedDropIsNotDynamicSQL() {
+        let sql = "BEGIN DBMS_OUTPUT.PUT_LINE('please drop by'); END;"
+        #expect(QueryClassifier.classifyTier(sql, databaseType: .oracle) == .write)
+    }
+
+    @Test("A delete without a WHERE inside a block is dangerous", arguments: [
+        "BEGIN DELETE FROM orders; END;",
+        "BEGIN IF 1 = 1 THEN DELETE FROM orders; END IF; END;",
+        "BEGIN EXECUTE IMMEDIATE 'DELETE FROM orders'; END;",
+    ])
+    func unfilteredDeleteIsDangerous(sql: String) {
+        #expect(QueryClassifier.isDangerousQuery(sql, databaseType: .oracle))
+    }
+
+    @Test("A filtered delete inside a block is not dangerous")
+    func filteredDeleteIsNotDangerous() {
+        let sql = "BEGIN DELETE FROM orders WHERE id = 1; COMMIT; END;"
+        #expect(!QueryClassifier.isDangerousQuery(sql, databaseType: .oracle))
+    }
+
+    @Test("Defining a unit runs nothing, so a drop in its body stays a write")
+    func definitionIsAWrite() {
+        let sql = "CREATE OR REPLACE PROCEDURE p IS BEGIN EXECUTE IMMEDIATE 'DROP TABLE users'; END;"
+        let classification = QueryClassifier.classify(sql, databaseType: .oracle)
+        #expect(classification.tier == .write)
+        #expect(!classification.reachesFilesystemOrExecutesCode)
+    }
+
+    @Test("A BEGIN on another engine is classified as before")
+    func otherEnginesAreUnchanged() {
+        let classification = QueryClassifier.classify("BEGIN", databaseType: .postgresql)
+        #expect(classification.tier == .write)
+        #expect(!classification.reachesFilesystemOrExecutesCode)
+    }
+
+    @Test("An external client cannot send a block")
+    func externalGateRefusesBlocks() {
+        let statement = ExternalStatementGate.Statement(
+            sql: "BEGIN NULL; END;",
+            connectionId: UUID(),
+            databaseType: .oracle,
+            externalAccess: .readWrite,
+            allowsDestructive: false
+        )
+        #expect(throws: ExternalStatementGateError.self) {
+            try ExternalStatementGate.classify(statement)
+        }
+    }
+
+    @Test("A block refreshes the sidebar whichever keyword opens it", arguments: [
+        "DECLARE n NUMBER := 1; BEGIN staging_pkg.create_tables(n); END;",
+        "BEGIN staging_pkg.create_tables(1); END;",
+        "<<l>> BEGIN NULL; END l;",
+    ])
+    func blockRefreshesTheCatalog(sql: String) {
+        #expect(CatalogChangeClassifier.effect(of: sql, databaseType: .oracle).kinds == .everything)
+    }
+
+    @Test("A PostgreSQL cursor declaration still leaves the catalog alone")
+    func postgresDeclareIsQuiet() {
+        let effect = CatalogChangeClassifier.effect(of: "DECLARE c CURSOR FOR SELECT 1", databaseType: .postgresql)
+        #expect(effect.kinds.isEmpty)
+    }
+
+    @Test("A block whose first word looks like a transaction keyword is not a transaction")
+    func oracleBeginIsNeverATransaction() {
+        let plan = BatchTransactionPolicy.plan(
+            for: ["BEGIN work := 1; END;", "SELECT 1 FROM dual"],
+            databaseType: .oracle,
+            rules: SQLLexicalRules(databaseType: .oracle, descriptor: nil)
+        )
+        #expect(plan != .scriptTransaction)
+    }
+
+    @Test("An external statement keeps the terminator a unit needs")
+    func externalStatementText() {
+        let cases: [(sql: String, expected: String)] = [
+            ("BEGIN NULL; END;", "BEGIN NULL; END;"),
+            ("BEGIN NULL; END;\n/\n", "BEGIN NULL; END;"),
+            ("SELECT 1 FROM dual;", "SELECT 1 FROM dual"),
+            ("CREATE OR REPLACE PROCEDURE p IS BEGIN NULL; END; ;", "CREATE OR REPLACE PROCEDURE p IS BEGIN NULL; END;"),
+        ]
+        for example in cases {
+            #expect(DatabaseAccessBridge.statementText(example.sql, dialect: .oracle) == example.expected, "\(example.sql)")
+        }
+    }
+
+    @Test("A literal read by Oracle's rules cannot hide the statement after it", arguments: [
+        "BEGIN v := 'C:\\temp\\'; DELETE FROM emp; END;",
+        "BEGIN v := q'[it's]'; DELETE FROM emp; END;",
+    ])
+    func oracleLiteralsDoNotHideADelete(sql: String) {
+        #expect(QueryClassifier.isDangerousQuery(sql, databaseType: .oracle))
+    }
+
+    @Test("A drop after a Windows path is still destructive")
+    func dropAfterABackslashPathIsDestructive() {
+        let sql = "BEGIN v := 'C:\\'; EXECUTE IMMEDIATE 'DROP TABLE t'; END;"
+        #expect(QueryClassifier.classifyTier(sql, databaseType: .oracle) == .destructive)
+    }
+
+    @Test("A collection's DELETE method deletes no rows", arguments: [
+        "DECLARE TYPE t IS TABLE OF NUMBER; v t := t(1); BEGIN v.DELETE; END;",
+        "DECLARE TYPE t IS TABLE OF NUMBER; v t := t(1); BEGIN v . delete(1); END;",
+    ])
+    func collectionDeleteIsNotDangerous(sql: String) {
+        #expect(!QueryClassifier.isDangerousQuery(sql, databaseType: .oracle))
+    }
+
+    /// A query whose `WITH` clause declares a function runs that function's PL/SQL on the server. Kept whole, its
+    /// leading `WITH` would otherwise tier it a safe read, and a read-only external client could run a `DROP` inside it.
+    @Test("A query declaring PL/SQL runs server-side code", arguments: [
+        "WITH FUNCTION f RETURN NUMBER IS BEGIN RETURN 1; END;\nSELECT f FROM dual",
+        "-- note\nwith procedure p IS BEGIN NULL; END;\nFUNCTION f RETURN NUMBER IS BEGIN p; RETURN 1; END;\nSELECT f FROM dual",
+    ])
+    func inlinePLSQLIsCodeExecution(sql: String) {
+        let classification = QueryClassifier.classify(sql, databaseType: .oracle)
+        #expect(classification.tier == .write)
+        #expect(classification.reachesFilesystemOrExecutesCode)
+    }
+
+    @Test("A drop inside an inline function is destructive")
+    func inlineFunctionDropIsDestructive() {
+        let sql = """
+        WITH FUNCTION f RETURN NUMBER IS
+          PRAGMA AUTONOMOUS_TRANSACTION;
+        BEGIN
+          EXECUTE IMMEDIATE 'DROP TABLE victims';
+          COMMIT;
+          RETURN 1;
+        END;
+        SELECT f FROM dual
+        """
+        #expect(QueryClassifier.classifyTier(sql, databaseType: .oracle) == .destructive)
+        let statement = ExternalStatementGate.Statement(
+            sql: sql,
+            connectionId: UUID(),
+            databaseType: .oracle,
+            externalAccess: .readOnly,
+            allowsDestructive: false
+        )
+        #expect(throws: ExternalStatementGateError.self) {
+            try ExternalStatementGate.classify(statement)
+        }
+    }
+
+    @Test("A plain common table expression on Oracle stays a read")
+    func plainCommonTableExpressionIsARead() {
+        let sql = "WITH recent AS (SELECT 1 AS a FROM dual) SELECT a FROM recent"
+        let classification = QueryClassifier.classify(sql, databaseType: .oracle)
+        #expect(classification.tier == .safe)
+        #expect(!classification.reachesFilesystemOrExecutesCode)
+    }
+}
diff --git a/TableProTests/Core/Utilities/SQL/SQLFileParserPLSQLTests.swift b/TableProTests/Core/Utilities/SQL/SQLFileParserPLSQLTests.swift
new file mode 100644
index 0000000000..dcb80b5d04
--- /dev/null
+++ b/TableProTests/Core/Utilities/SQL/SQLFileParserPLSQLTests.swift
@@ -0,0 +1,94 @@
+//
+//  SQLFileParserPLSQLTests.swift
+//  TableProTests
+//
+//  An Oracle script imported from a file reaches the driver the way the same script run in the editor does. The
+//  import parser streams the file in 64 KiB chunks, so a word, a quoted literal or a slash line can be cut in two by a
+//  chunk boundary, and the split must not depend on where that boundary falls.
+//
+
+import Foundation
+@testable import TablePro
+import TableProPluginKit
+import Testing
+
+@Suite("SQLFileParser - Oracle PL/SQL units")
+struct SQLFileParserPLSQLTests {
+    private static let chunkSize = 65_536
+
+    private static func parse(_ sql: String, dialect: SqlDialect) async throws -> [String] {
+        let url = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString + ".sql")
+        try sql.write(to: url, atomically: true, encoding: .utf8)
+        defer { try? FileManager.default.removeItem(at: url) }
+
+        var statements: [String] = []
+        for try await (statement, _) in SQLFileParser().parseFile(url: url, encoding: .utf8, dialect: dialect) {
+            statements.append(statement)
+        }
+        return statements
+    }
+
+    /// The import parser drops comments, which the editor keeps inside a statement, so the cases compared here are
+    /// the ones whose text has none.
+    private static let commentFreeCases = PLSQLScriptCorpus.cases.filter { example in
+        !example.script.contains("--") && !example.script.contains("/*")
+    }
+
+    @Test("An imported script splits like the same script in the editor", arguments: commentFreeCases)
+    func importMatchesTheEditor(example: PLSQLScriptCase) async throws {
+        #expect(try await Self.parse(example.script, dialect: .oracle) == example.statements)
+    }
+
+    @Test("A chunk boundary anywhere in a unit changes nothing")
+    func chunkBoundaryAnywhere() async throws {
+        let script = """
+        DECLARE
+          v VARCHAR2(9) := q'[a;b]';
+        BEGIN
+          $IF TRUE $THEN NULL; $END
+        END;
+        /
+        SELECT 1 FROM dual;
+        """
+        let expected = [
+            "DECLARE\n  v VARCHAR2(9) := q'[a;b]';\nBEGIN\n  $IF TRUE $THEN NULL; $END\nEND;",
+            "SELECT 1 FROM dual",
+        ]
+        for boundary in 0..<(script as NSString).length {
+            let padding = "--" + String(repeating: "x", count: Self.chunkSize - boundary - 3) + "\n"
+            let statements = try await Self.parse(padding + script, dialect: .oracle)
+            #expect(statements == expected, "boundary at \(boundary)")
+        }
+    }
+
+    @Test("A slash line at the end of the file ends the statement before it")
+    func slashLineAtEndOfFile() async throws {
+        #expect(try await Self.parse("SELECT 1 FROM dual\n/", dialect: .oracle) == ["SELECT 1 FROM dual"])
+    }
+
+    @Test("A slash that shares its line with code is division")
+    func slashWithCodeIsDivision() async throws {
+        #expect(try await Self.parse("SELECT 4\n/ 2 AS v FROM dual;", dialect: .oracle) == ["SELECT 4\n/ 2 AS v FROM dual"])
+    }
+
+    @Test("Other dialects still split an import at every semicolon", arguments: [SqlDialect.mysql, .postgres, .generic])
+    func otherDialectsAreUnchanged(dialect: SqlDialect) async throws {
+        let statements = try await Self.parse("BEGIN NULL; END;", dialect: dialect)
+        #expect(statements == ["BEGIN NULL", "END"])
+    }
+
+    /// The parser holds a character back while it waits for the one after it, and the end of the file used to leave
+    /// it held: a file ending `ORDER BY created_on` imported as `created_o`.
+    @Test("A file's last character survives when nothing follows it")
+    func lastCharacterSurvives() async throws {
+        let cases: [(dialect: SqlDialect, sql: String)] = [
+            (.oracle, "SELECT a FROM t ORDER BY created_on"),
+            (.oracle, "SELECT q FROM t"),
+            (.generic, "SELECT 'abc'"),
+            (.mysql, "SELECT 1 - 1"),
+        ]
+        for example in cases {
+            #expect(try await Self.parse(example.sql, dialect: example.dialect) == [example.sql], "\(example.sql)")
+        }
+    }
+}
diff --git a/TableProTests/Core/Utilities/SQL/SQLFileParserTests.swift b/TableProTests/Core/Utilities/SQL/SQLFileParserTests.swift
index 538228ec41..6a96cfdded 100644
--- a/TableProTests/Core/Utilities/SQL/SQLFileParserTests.swift
+++ b/TableProTests/Core/Utilities/SQL/SQLFileParserTests.swift
@@ -277,7 +277,8 @@ struct SQLFileParserTests {
         #expect(SqlDialect.from(databaseTypeId: "SQLite") == .sqlite)
         #expect(SqlDialect.from(databaseTypeId: "DuckDB") == .sqlite)
         #expect(SqlDialect.from(databaseTypeId: "Cloudflare D1") == .sqlite)
-        #expect(SqlDialect.from(databaseTypeId: "Oracle") == .generic)
+        #expect(SqlDialect.from(databaseTypeId: "Oracle") == .oracle)
+        #expect(SqlDialect.from(databaseTypeId: "Dameng") == .generic)
         #expect(SqlDialect.from(databaseTypeId: "Unknown Whatever") == .generic)
     }
 
diff --git a/TableProTests/Core/Utilities/SQL/SQLFoldScannerTests.swift b/TableProTests/Core/Utilities/SQL/SQLFoldScannerTests.swift
index 54ab190656..694e15fab5 100644
--- a/TableProTests/Core/Utilities/SQL/SQLFoldScannerTests.swift
+++ b/TableProTests/Core/Utilities/SQL/SQLFoldScannerTests.swift
@@ -286,6 +286,36 @@ struct SQLFoldScannerTests {
     func unterminatedDollarQuote() {
         _ = regions("SELECT $$abc\ndef", dialect: .postgres)
     }
+
+    // MARK: - Oracle PL/SQL units
+
+    /// A fold never reaches past the unit the run control beside it would send, and never stops inside one.
+    @Test("Every Oracle statement fold lies inside the unit the scanner sends", arguments: PLSQLScriptCorpus.cases)
+    func oracleFoldsAgreeWithStatements(example: PLSQLScriptCase) {
+        let statements = SQLStatementScanner.navigableStatements(in: example.script, dialect: .oracle)
+        for region in regions(example.script, dialect: .oracle) where region.kind == .statement {
+            let contained = statements.contains { statement in
+                region.range.lowerBound >= statement.contentRange.location
+                    && region.range.upperBound <= statement.contentRange.location + statement.contentRange.length
+            }
+            #expect(contained, "fold \(region.range) in \(example.name)")
+        }
+    }
+
+    @Test("A declaration section does not end an Oracle statement fold")
+    func oracleDeclarationSectionStaysInsideTheFold() throws {
+        let sql = "DECLARE\n  v NUMBER;\nBEGIN\n  v := 1;\nEND;\nSELECT 1 FROM dual;"
+        let statement = try #require(regions(sql, dialect: .oracle).first { $0.kind == .statement })
+        #expect(statement.startLine == 0)
+        #expect(statement.endLine == 4)
+    }
+
+    @Test("END CASE closes the CASE fold and opens nothing")
+    func endCaseClosesItsFold() {
+        let sql = "BEGIN\n  CASE x\n    WHEN 1 THEN NULL;\n  END CASE;\n  y := 2;\nEND;"
+        let blocks = regions(sql, dialect: .oracle).filter { $0.kind == .keywordBlock }
+        #expect(blocks.map(\.endLine).sorted() == [3, 5])
+    }
 }
 
 @Suite("SQL fold event ordering")
diff --git a/TableProTests/Core/Utilities/SQL/SQLNonCodeSpanTests.swift b/TableProTests/Core/Utilities/SQL/SQLNonCodeSpanTests.swift
index ea6067be97..708fb53c3a 100644
--- a/TableProTests/Core/Utilities/SQL/SQLNonCodeSpanTests.swift
+++ b/TableProTests/Core/Utilities/SQL/SQLNonCodeSpanTests.swift
@@ -62,4 +62,12 @@ struct SQLNonCodeSpanTests {
         #expect(end("$$a b$$ x", rules: SQLLexicalRules(dialect: .postgres)) == 7)
         #expect(end("$$a b$$ x") == nil)
     }
+
+    @Test("An Oracle q-quote is one literal on Oracle only")
+    func alternativeQuoteIsOracleOnly() {
+        let oracle = SQLLexicalRules(dialect: .oracle)
+        #expect(end("q'[it's]' x", rules: oracle) == 9)
+        #expect(end("xq'[a]'", at: 1, rules: oracle) == nil)
+        #expect(end("q'[it's]' x", rules: SQLLexicalRules(dialect: .generic)) == nil)
+    }
 }
diff --git a/TableProTests/Core/Utilities/SQL/SQLStatementBlockSplittingTests.swift b/TableProTests/Core/Utilities/SQL/SQLStatementBlockSplittingTests.swift
index 25e1da57fe..3cc7edcbd5 100644
--- a/TableProTests/Core/Utilities/SQL/SQLStatementBlockSplittingTests.swift
+++ b/TableProTests/Core/Utilities/SQL/SQLStatementBlockSplittingTests.swift
@@ -155,6 +155,23 @@ struct SQLStatementBlockSplittingTests {
         #expect(statements.last == "SELECT 3")
     }
 
+    /// `END CASE` closes the `CASE` that opened a block. Reading its `CASE` as a second opener left the routine one
+    /// level deep for good, so it swallowed every statement after it.
+    @Test("END CASE closes the CASE statement and nothing else")
+    func endCaseClosesTheCaseStatement() {
+        let sql = """
+        CREATE PROCEDURE p(x INT)
+        BEGIN
+          CASE x WHEN 1 THEN SELECT 1; ELSE SELECT 2; END CASE;
+          SELECT 3;
+        END;
+        SELECT 4;
+        """
+        let statements = SQLStatementScanner.allStatements(in: sql, dialect: .mysql)
+        #expect(statements.count == 2, "got \(statements)")
+        #expect(statements.last == "SELECT 4")
+    }
+
     /// The routine flag is per statement. Leaking it forward lets a later statement whose first content is
     /// punctuation inherit permission to open a block, which is the swallow this file exists to prevent.
     @Test("The routine flag does not leak into the next statement")
diff --git a/TableProTests/Core/Utilities/SQL/SQLStatementPLSQLSplittingTests.swift b/TableProTests/Core/Utilities/SQL/SQLStatementPLSQLSplittingTests.swift
new file mode 100644
index 0000000000..ce0eea609b
--- /dev/null
+++ b/TableProTests/Core/Utilities/SQL/SQLStatementPLSQLSplittingTests.swift
@@ -0,0 +1,108 @@
+//
+//  SQLStatementPLSQLSplittingTests.swift
+//  TableProTests
+//
+//  Oracle's statements end where its own grammar says, and a PL/SQL unit keeps the `;` after its `END`. The editor
+//  used to cut `BEGIN ...; END;` at the inner `;` and strip the final one from every unit, which sent Oracle a fragment
+//  and stored every procedure created from the editor INVALID (#2984).
+//
+
+import Foundation
+@testable import TablePro
+import TableProPluginKit
+import Testing
+
+@Suite("SQL statement scanner - Oracle PL/SQL units")
+struct SQLStatementPLSQLSplittingTests {
+    @Test("Each statement reaches the driver as Oracle accepts it", arguments: PLSQLScriptCorpus.cases)
+    func corpusSplitsAsMeasured(example: PLSQLScriptCase) {
+        #expect(SQLStatementScanner.allStatements(in: example.script, dialect: .oracle) == example.statements)
+    }
+
+    @Test("The reported block runs as one statement at every caret position inside it")
+    func caretAnywhereInTheBlockRunsTheBlock() {
+        let script = PLSQLScriptCorpus.cases[0].script
+        let block = "BEGIN\n  DBMS_OUTPUT.PUT_LINE('Hello from PL/SQL');\nEND;"
+        let blockLength = (block as NSString).length
+        for caret in 0...blockLength {
+            let statement = SQLStatementScanner.statementAtCursor(in: script, cursorPosition: caret, dialect: .oracle)
+            #expect(statement == block, "caret \(caret)")
+        }
+    }
+
+    @Test("The gutter offers each unit once and never a slash line")
+    func navigableStatementsSkipSlashLines() {
+        let script = "BEGIN NULL; END;\n/\nSELECT 1 FROM dual\n/\n"
+        let navigable = SQLStatementScanner.navigableStatements(in: script, dialect: .oracle)
+        let texts = navigable.map { (script as NSString).substring(with: $0.contentRange) }
+        #expect(texts == ["BEGIN NULL; END;", "SELECT 1 FROM dual"])
+    }
+
+    @Test("Located segments still tile the whole document")
+    func segmentsTileTheDocument() {
+        for example in PLSQLScriptCorpus.cases {
+            let located = SQLStatementScanner.locatedStatements(in: example.script, dialect: .oracle)
+            #expect(located.map(\.sql).joined() == example.script, "\(example.name)")
+        }
+    }
+
+    @Test("A unit keeps its terminator and a query does not")
+    func terminatorPolicy() {
+        let located = SQLStatementScanner.locatedStatements(
+            in: "BEGIN NULL; END;\nSELECT 1 FROM dual;",
+            dialect: .oracle
+        ).filter(\.hasContent)
+        #expect(located.map(\.terminator) == [.partOfStatement, .separator])
+    }
+
+    @Test("A definition takes no bind parameters and a block or a query does")
+    func bindParametersFollowTheStatementKind() {
+        let script = """
+        CREATE OR REPLACE TRIGGER t BEFORE INSERT ON x FOR EACH ROW BEGIN :NEW.a := 1; END;
+        BEGIN p(:id); END;
+        SELECT * FROM x WHERE a = :a;
+        """
+        let statements = SQLStatementScanner.executableStatements(in: script, dialect: .oracle)
+        #expect(statements.map(\.acceptsBindParameters) == [false, true, true])
+        let source = SQLParameterExtractor.parameterSource(of: statements)
+        #expect(SQLParameterExtractor.extractParameters(from: source) == ["id", "a"])
+    }
+
+    @Test("Other dialects keep splitting a bare BEGIN at every semicolon", arguments: [
+        SqlDialect.postgres, .mysql, .sqlite, .generic,
+    ])
+    func otherDialectsAreUnchanged(dialect: SqlDialect) {
+        let statements = SQLStatementScanner.allStatements(in: "BEGIN\nDROP TABLE users;\nSELECT 1;", dialect: dialect)
+        #expect(statements == ["BEGIN\nDROP TABLE users", "SELECT 1"])
+    }
+
+    @Test("A slash line is only a terminator on Oracle")
+    func slashLineIsOracleOnly() {
+        let script = "SELECT 10\n/\n2 AS v FROM dual;"
+        #expect(SQLStatementScanner.allStatements(in: script, dialect: .oracle) == ["SELECT 10", "2 AS v FROM dual"])
+        #expect(SQLStatementScanner.allStatements(in: script, dialect: .generic) == ["SELECT 10\n/\n2 AS v FROM dual"])
+    }
+
+    @Test("An unterminated block takes the rest of the script with it")
+    func unterminatedBlockTakesTheRest() {
+        let statements = SQLStatementScanner.allStatements(in: "BEGIN\n  NULL;\nSELECT 1 FROM dual;", dialect: .oracle)
+        #expect(statements == ["BEGIN\n  NULL;\nSELECT 1 FROM dual;"])
+    }
+
+    @Test("A script sent whole keeps the terminator its last unit needs")
+    func executableTextKeepsTheUnitTerminator() {
+        #expect(SQLStatementScanner.executableText(of: "BEGIN NULL; END;\n/\n", dialect: .oracle) == "BEGIN NULL; END;")
+        #expect(SQLStatementScanner.executableText(of: "SELECT 1 FROM dual; ;", dialect: .oracle) == "SELECT 1 FROM dual")
+        #expect(SQLStatementScanner.executableText(of: "/\n", dialect: .oracle).isEmpty)
+    }
+
+    @Test("A caret on a slash line runs the statement the slash ends")
+    func caretOnSlashLineRunsTheStatementAbove() {
+        let script = "BEGIN NULL; END;\n/\nSELECT 1 FROM dual\n/\n"
+        let slashes = (0..<(script as NSString).length).filter { (script as NSString).character(at: $0) == 0x2F }
+        #expect(slashes.count == 2)
+        let afterSlashes = slashes.map { $0 + 1 }
+        #expect(afterSlashes.map { SQLStatementScanner.statementAtCursor(in: script, cursorPosition: $0, dialect: .oracle) }
+            == ["BEGIN NULL; END;", "SELECT 1 FROM dual"])
+    }
+}
diff --git a/TableProTests/Core/Utilities/SQL/SQLTokenCursorTests.swift b/TableProTests/Core/Utilities/SQL/SQLTokenCursorTests.swift
index 2760eff419..af3883a3d0 100644
--- a/TableProTests/Core/Utilities/SQL/SQLTokenCursorTests.swift
+++ b/TableProTests/Core/Utilities/SQL/SQLTokenCursorTests.swift
@@ -130,4 +130,10 @@ struct SQLTokenCursorTests {
         #expect(cursor.peek()?.word == "TRANSACTION")
         #expect(cursor.next()?.word == "TRANSACTION")
     }
+
+    @Test("An Oracle q-quote reads as one literal")
+    func alternativeQuoteIsOneLiteral() {
+        let tokens = Self.tokens("SELECT q'[it's; ok]' FROM dual", rules: SQLLexicalRules(dialect: .oracle))
+        #expect(tokens == [.word("SELECT"), .literal, .word("FROM"), .word("DUAL")])
+    }
 }
diff --git a/TableProTests/Core/Utilities/SQL/SqlLexerTests.swift b/TableProTests/Core/Utilities/SQL/SqlLexerTests.swift
index 7baadafd7a..5ea59edd9d 100644
--- a/TableProTests/Core/Utilities/SQL/SqlLexerTests.swift
+++ b/TableProTests/Core/Utilities/SQL/SqlLexerTests.swift
@@ -151,4 +151,20 @@ struct SqlLexerTests {
         #expect(SqlLexer.isQuote(SqlLexer.backtick))
         #expect(!SqlLexer.isQuote(SqlLexer.dash))
     }
+
+    @Test("An Oracle q-quote runs to its delimiter followed by a quote")
+    func alternativeQuotedString() {
+        let text = "q'[it's; x]' tail" as NSString
+        #expect(SqlLexer.skipAlternativeQuotedString(text, at: 0, length: text.length)?.next == 12)
+        let national = "NQ'{a'b}' tail" as NSString
+        #expect(SqlLexer.skipAlternativeQuotedString(national, at: 0, length: national.length)?.next == 9)
+        let sameDelimiter = "q'!a'b!' tail" as NSString
+        #expect(SqlLexer.skipAlternativeQuotedString(sameDelimiter, at: 0, length: sameDelimiter.length)?.next == 8)
+    }
+
+    @Test("A word that only starts with q is not a q-quote")
+    func notAnAlternativeQuote() {
+        let text = "qty = 'x'" as NSString
+        #expect(SqlLexer.skipAlternativeQuotedString(text, at: 0, length: text.length) == nil)
+    }
 }
diff --git a/docs/databases/oracle.mdx b/docs/databases/oracle.mdx
index 2379dd88a6..9295c37172 100644
--- a/docs/databases/oracle.mdx
+++ b/docs/databases/oracle.mdx
@@ -73,10 +73,33 @@ The database has to accept TLS without mutual TLS: set **Mutual TLS (mTLS) authe
 
 Table info carries columns, types, nullability, primary keys, indexes, foreign keys, and CREATE TABLE DDL. The structure editor writes `ALTER TABLE` with double-quoted identifiers for case-sensitive names: ADD, RENAME COLUMN, MODIFY, DROP, and CREATE INDEX.
 
-The editor runs SQL and anonymous PL/SQL blocks, and grid paging is written as `OFFSET … ROWS FETCH NEXT … ROWS ONLY`. Import and export work as they do elsewhere, and a remote server reaches through an [SSH tunnel](/connections/ssh-tunneling).
+The editor runs SQL and PL/SQL, and grid paging is written as `OFFSET … ROWS FETCH NEXT … ROWS ONLY`. Import and export work as they do elsewhere, and a remote server reaches through an [SSH tunnel](/connections/ssh-tunneling).
 
 A partitioned table shows its partition count and lists the partitions under it, each with its position. `ALL_TAB_PARTITIONS.HIGH_VALUE` is a `LONG` column the driver cannot decode, so an Oracle partition row carries the position rather than the bound. Subpartitions nest under their partition. An interval-partitioned table reports no count: the server's figure there is the range it will extend into, not the partitions that exist. Query one with `SELECT * FROM orders PARTITION (p2024)`.
 
+## PL/SQL
+
+A block or a stored unit is one statement, however many semicolons are inside it. Put the cursor anywhere in it and press `Cmd+Enter`, or click its run button in the gutter.
+
+```sql
+DECLARE
+  total NUMBER;
+BEGIN
+  SELECT COUNT(*) INTO total FROM orders;
+  DBMS_OUTPUT.PUT_LINE(total);
+END;
+```
+
+The semicolon after a unit's last `END` is sent with it. A plain SQL statement is sent without its semicolon.
+
+Scripts written for SQL*Plus or SQL Developer run unchanged: a line holding only `/` ends the statement above it and is never sent. Between units the slash is optional, except after `CREATE JAVA SOURCE`, `CREATE MLE MODULE` and a `WRAPPED` unit, which each run to the next `/` line or to the end of the script.
+
+A `CREATE` whose unit does not compile fails with Oracle's own errors, one per line with its position, instead of reporting success. The unit stays in the schema as INVALID until a version that compiles replaces it.
+
+In a trigger body, `:NEW` and `:OLD` are left as written. In an anonymous block, `:name` is a [query parameter](/features/query-parameters) filled from the panel.
+
+An anonymous block, or a query whose `WITH` clause declares a function, runs code on the server. One that drops or truncates, including through `EXECUTE IMMEDIATE '…'`, raises the [dangerous query warning](/features/safe-mode) before it runs, and a Read-Only connection refuses it like any write. [MCP clients](/external-api/mcp-tools) and the AI assistant cannot send either.
+
 ## Column type support
 
 | Oracle type | Display |
@@ -109,11 +132,14 @@ The Oracle driver is compiled into TablePro Mobile, with no plugin to install. B
 
 - No OS auth, wallets, Kerberos, or LDAP. Create a database user with a password and connect as that.
 - BFILE columns show the locator, never the file. There is no path to the contents from the app.
-- PL/SQL runs as anonymous blocks. Create a procedure or package with a `CREATE OR REPLACE` statement in the editor.
+- SQL*Plus commands such as `SET SERVEROUTPUT ON`, `SHOW ERRORS` and `EXEC` are not SQL and fail when sent. Delete them, and write `EXEC p` as `BEGIN p; END;`.
+- `DBMS_OUTPUT` lines are not shown. Return the value from a query instead, or write it to a table.
 - No Users & Roles pane. Manage accounts with `CREATE USER` and `GRANT` in the editor.
 
 ## Troubleshooting
 
+**PROCEDURE … was created with compilation errors**: the unit is stored but does not compile. Each line after the first gives the line and column in the unit's source and the `PLS-` error there. Fix the source and run the `CREATE OR REPLACE` again.
+
 **Connection refused**: check the listener is up with `lsnrctl status`, that port 1521 is open, and, on Docker, that the container is running (`docker start oracle-xe`).
 
 **Invalid service name**: the listener does not answer for that name. List what it does answer for with `lsnrctl services`.
diff --git a/docs/features/sql-editor.mdx b/docs/features/sql-editor.mdx
index 2e6a83e3a4..fdd9acf8d4 100644
--- a/docs/features/sql-editor.mdx
+++ b/docs/features/sql-editor.mdx
@@ -90,7 +90,7 @@ The editor marks which statement it is about to send.
 - Move the pointer over the gutter and a run button appears beside every statement. Click one to run that statement while the cursor is elsewhere. Their column is reserved at all times, so revealing them never shifts the text.
 - A run button takes the same [safe mode](/features/safe-mode) checks and [parameter](/features/query-parameters) prompts as any other run, and dims while a query is running.
 - VoiceOver reads each button as a button naming the line its statement starts on.
-- A `BEGIN … END` body counts as one statement, so a trigger or stored procedure gets one button rather than one per line inside it. `BEGIN;` and `BEGIN TRANSACTION;` are statements of their own.
+- A `BEGIN … END` body counts as one statement, so a trigger or stored procedure gets one button rather than one per line inside it. `BEGIN;` and `BEGIN TRANSACTION;` are statements of their own. On Oracle, a whole [PL/SQL block or unit](/databases/oracle#pl%2Fsql) is one statement.
 
 Turn either marker off in **Settings > Editor** with **Highlight current statement** and **Run button beside each statement**.
 
diff --git a/scripts/check-oracle-plsql-terminators.sh b/scripts/check-oracle-plsql-terminators.sh
new file mode 100755
index 0000000000..2daff39056
--- /dev/null
+++ b/scripts/check-oracle-plsql-terminators.sh
@@ -0,0 +1,171 @@
+#!/usr/bin/env bash
+#
+# Check the terminator rules PLSQLUnitTracker hard-codes against a real Oracle server.
+#
+# The editor decides per statement whether the `;` that ends it is sent. The rule is written by
+# hand in TablePro/Core/Utilities/SQL/PLSQLUnitTracker.swift and pinned by PLSQLScriptCorpus, and
+# nothing else checks it against Oracle. Getting it wrong is silent in the worst way: a unit sent
+# without the `;` after its END is stored INVALID while the CREATE reports success, and a
+# CALL-bodied trigger sent with one is stored INVALID the same way. So this sends every shape both
+# ways, through the same OracleCoreConnection the plugin uses, and compares what Oracle stored
+# with what the tracker decides.
+#
+# Usage:
+#   scripts/check-oracle-plsql-terminators.sh [host] [port] [service] [user] [password]
+#
+# Defaults suit a throwaway Oracle Free container:
+#   docker run -d --name oracle-probe -p 1521:1521 -e ORACLE_PASSWORD=probe_pw \
+#     -e APP_USER=probe -e APP_USER_PASSWORD=probe_pw gvenzl/oracle-free:23-slim-faststart
+#
+# The user needs CREATE PROCEDURE, CREATE TRIGGER, CREATE TYPE and CREATE TABLE. Every object it
+# creates is prefixed TP_TERM_ and dropped again. Exits non-zero on a disagreement, 3 when a
+# prerequisite is missing.
+
+set -uo pipefail
+
+HOST="${1:-127.0.0.1}"
+PORT="${2:-1521}"
+SERVICE="${3:-FREEPDB1}"
+USER_NAME="${4:-probe}"
+PASSWORD="${5:-probe_pw}"
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+
+if [ -z "${DEVELOPER_DIR:-}" ]; then
+    for candidate in /Applications/Xcode-beta.app /Applications/Xcode.app; do
+        if [ -d "$candidate/Contents/Developer" ]; then
+            export DEVELOPER_DIR="$candidate/Contents/Developer"
+            break
+        fi
+    done
+fi
+command -v swift > /dev/null || {
+    echo "swift not found" >&2
+    exit 3
+}
+
+WORK="$(mktemp -d)"
+trap 'rm -rf "$WORK"' EXIT
+mkdir -p "$WORK/Sources/Probe"
+
+cat > "$WORK/Package.swift" <<EOF
+// swift-tools-version: 6.0
+import PackageDescription
+
+let package = Package(
+    name: "Probe",
+    platforms: [.macOS(.v14)],
+    dependencies: [.package(path: "$ROOT/Packages/TableProOracle")],
+    targets: [
+        .executableTarget(
+            name: "Probe",
+            dependencies: [.product(name: "TableProOracleCore", package: "TableProOracle")]
+        )
+    ]
+)
+EOF
+
+cat > "$WORK/Sources/Probe/main.swift" <<'EOF'
+import Foundation
+import TableProOracleCore
+
+struct Shape {
+    let name: String
+    let object: String?
+    let objectType: String
+    let body: String
+    let keepsTerminator: Bool
+}
+
+let arguments = CommandLine.arguments
+let connection = OracleCoreConnection(options: OracleConnectionOptions(
+    host: arguments[1], port: Int(arguments[2]) ?? 1_521, user: arguments[4], password: arguments[5],
+    identifierMode: .service, serviceName: arguments[3]
+))
+
+do {
+    try await connection.connect()
+} catch {
+    print("cannot connect: \(error)")
+    exit(3)
+}
+
+func run(_ sql: String) async -> String? {
+    do {
+        _ = try await connection.executeQuery(sql)
+        return nil
+    } catch {
+        return String(describing: error)
+    }
+}
+
+func status(of object: String, type: String) async -> String {
+    let sql = "SELECT STATUS FROM USER_OBJECTS WHERE OBJECT_NAME = '\(object)' AND OBJECT_TYPE = '\(type)'"
+    let rows = (try? await connection.executeQuery(sql).rows) ?? []
+    return rows.first?.first?.stringValue ?? "MISSING"
+}
+
+_ = await run("CREATE TABLE TP_TERM_TAB (A NUMBER)")
+_ = await run("CREATE OR REPLACE PROCEDURE TP_TERM_LOG(P NUMBER) IS BEGIN NULL; END;")
+
+let shapes = [
+    Shape(name: "procedure", object: "TP_TERM_P", objectType: "PROCEDURE",
+          body: "CREATE OR REPLACE PROCEDURE TP_TERM_P IS V NUMBER; BEGIN V := 1; END", keepsTerminator: true),
+    Shape(name: "function", object: "TP_TERM_F", objectType: "FUNCTION",
+          body: "CREATE OR REPLACE FUNCTION TP_TERM_F RETURN NUMBER IS BEGIN RETURN 1; END", keepsTerminator: true),
+    Shape(name: "package specification", object: "TP_TERM_PKG", objectType: "PACKAGE",
+          body: "CREATE OR REPLACE PACKAGE TP_TERM_PKG AS PROCEDURE A; END TP_TERM_PKG", keepsTerminator: true),
+    Shape(name: "package body", object: "TP_TERM_PKG", objectType: "PACKAGE BODY",
+          body: "CREATE OR REPLACE PACKAGE BODY TP_TERM_PKG AS PROCEDURE A IS BEGIN NULL; END A; END TP_TERM_PKG",
+          keepsTerminator: true),
+    Shape(name: "block-bodied trigger", object: "TP_TERM_TRG", objectType: "TRIGGER",
+          body: "CREATE OR REPLACE TRIGGER TP_TERM_TRG BEFORE INSERT ON TP_TERM_TAB FOR EACH ROW BEGIN :NEW.A := 1; END",
+          keepsTerminator: true),
+    Shape(name: "CALL-bodied trigger", object: "TP_TERM_CALL_TRG", objectType: "TRIGGER",
+          body: "CREATE OR REPLACE TRIGGER TP_TERM_CALL_TRG BEFORE INSERT ON TP_TERM_TAB FOR EACH ROW CALL TP_TERM_LOG(:NEW.A)",
+          keepsTerminator: false),
+    Shape(name: "anonymous block", object: nil, objectType: "",
+          body: "BEGIN NULL; END", keepsTerminator: true),
+    Shape(name: "declare block", object: nil, objectType: "",
+          body: "DECLARE V NUMBER; BEGIN V := 1; END", keepsTerminator: true),
+]
+
+var disagreements = 0
+for shape in shapes {
+    // The broken form goes first, so each unit is left VALID for the ones that depend on it: a package body
+    // compiled against a specification stored INVALID is INVALID whatever its own terminator.
+    for withTerminator in [false, true] {
+        let sql = withTerminator ? shape.body + ";" : shape.body
+        let failure = await run(sql)
+        var works = failure == nil
+        if works, let object = shape.object {
+            works = await status(of: object, type: shape.objectType) == "VALID"
+        }
+        let expected = withTerminator == shape.keepsTerminator
+        let form = withTerminator ? "with ';'" : "without ';'"
+        let mark = works == expected ? "ok  " : "FAIL"
+        print("\(mark) \(shape.name) \(form): \(works ? "works" : "broken")")
+        if works != expected { disagreements += 1 }
+    }
+}
+
+let slash = await run("BEGIN NULL; END;\n/")
+print("\(slash == nil ? "FAIL" : "ok  ") a '/' line sent to the server is refused")
+if slash == nil { disagreements += 1 }
+
+for drop in [
+    "DROP TRIGGER TP_TERM_TRG", "DROP TRIGGER TP_TERM_CALL_TRG", "DROP PACKAGE TP_TERM_PKG",
+    "DROP FUNCTION TP_TERM_F", "DROP PROCEDURE TP_TERM_P", "DROP PROCEDURE TP_TERM_LOG", "DROP TABLE TP_TERM_TAB",
+] {
+    _ = await run(drop)
+}
+
+print(disagreements == 0 ? "The terminator rules match this server." : "\(disagreements) disagreement(s).")
+exit(disagreements == 0 ? 0 : 1)
+EOF
+
+echo "Building the probe against Packages/TableProOracle (the first build takes a minute)"
+(cd "$WORK" && swift build -c debug > "$WORK/build.log" 2>&1) || {
+    grep -E "error:" "$WORK/build.log" | head -20 >&2
+    exit 3
+}
+"$WORK/.build/debug/Probe" "$HOST" "$PORT" "$SERVICE" "$USER_NAME" "$PASSWORD" 2> /dev/null