Skip to content

armgit / dbx

Public Imported from GitHub
0

25 MB lightweight cross-platform database client for 100+ databases, including MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, SQL Server, and Dameng. Built-in AI, MCP Server, CLI, desktop and Docker. | 轻量级跨平台数据库管理工具,支持 MySQL、PostgreSQL、SQLite、Redis、MongoDB、达梦等 100+ 数据库,提供桌面端、Docker、CLI、内置 AI 助手和 MCP。

323 KB
Raw Blame
use serde::{Deserialize, Serialize};
use sqlparser::dialect::OracleDialect;
use sqlparser::tokenizer::{Token, Tokenizer};

use crate::models::connection::DatabaseType;

pub const MIN_FUZZY_FILTER_CHARS: usize = 2;

pub fn fuzzy_filter_enabled(filter: &str) -> bool {
    filter.trim().chars().count() >= MIN_FUZZY_FILTER_CHARS
}

pub fn fuzzy_subsequence_match(text: &str, filter: &str) -> bool {
    let filter = filter.trim().to_lowercase();
    if filter.is_empty() {
        return true;
    }

    let text = text.to_lowercase();
    let mut chars = text.chars();
    for needle in filter.chars() {
        if !chars.any(|candidate| candidate == needle) {
            return false;
        }
    }
    true
}

pub fn contains_or_fuzzy_match(text: &str, filter: &str) -> bool {
    let filter = filter.trim().to_lowercase();
    if filter.is_empty() {
        return true;
    }

    let text = text.to_lowercase();
    text.contains(&filter) || (fuzzy_filter_enabled(&filter) && fuzzy_subsequence_match(&text, &filter))
}

pub fn fuzzy_like_pattern_with_escape(value: &str, mut escape: impl FnMut(&str) -> String) -> String {
    let value = value.trim();
    if value.is_empty() {
        return "%%".to_string();
    }

    let mut pattern = String::with_capacity(value.len() * 2 + 2);
    pattern.push('%');
    for ch in value.chars() {
        pattern.push_str(&escape(&ch.to_string()));
        pattern.push('%');
    }
    pattern
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SqlFileRequest {
    pub execution_id: String,
    pub connection_id: String,
    pub database: String,
    /// Optional schema/session namespace for databases where it is distinct
    /// from the database used to establish the connection.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub schema: Option<String>,
    pub file_path: String,
    pub continue_on_error: bool,
    /// Reuse a held manual transaction instead of committing through ordinary query execution.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub txn_session_id: Option<String>,
    #[serde(default)]
    pub selected_tables: Option<Vec<dbx_types::sql_file::SqlFileTable>>,
    #[serde(default)]
    pub part_cooldown_ms: u64,
    /// Temporarily disable relational constraint enforcement across the entire
    /// target database for this import, and restore it on completion, error,
    /// or cancellation. The mechanism is engine-specific: MySQL-compatible
    /// connections toggle session-scoped `FOREIGN_KEY_CHECKS`; PostgreSQL-family
    /// connections (Postgres, GaussDB, openGauss) run `ALTER TABLE ... DISABLE
    /// TRIGGER ALL` / `ENABLE TRIGGER ALL` for every table; SQL Server runs
    /// `ALTER TABLE ... NOCHECK CONSTRAINT ALL` / `WITH NOCHECK CHECK CONSTRAINT
    /// ALL` for every table. Has no effect on other connection types. This does
    /// not bypass unique/primary-key violations on any engine — only foreign-key
    /// and (on PostgreSQL) other trigger-enforced constraints.
    #[serde(default)]
    pub skip_relational_constraints: bool,
    /// Whether the backend writes a JSONL failure log for this execution
    /// (dbx#11619). Absent in requests from older frontends, which must keep
    /// logging enabled, so the serde default is `true`.
    #[serde(default = "sql_file_failure_log_enabled_by_default")]
    pub failure_log_enabled: bool,
    /// Text encoding used to decode SQL files. `auto` preserves the historical
    /// BOM/UTF-8/GBK detection behavior.
    #[serde(default)]
    pub encoding: SqlFileEncoding,
    /// Explicitly allow desktop scripts to include SQL below the entry file's directory.
    #[serde(default)]
    pub resolve_includes: bool,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
#[serde(rename_all = "camelCase")]
pub enum SqlFileEncoding {
    #[default]
    Auto,
    Utf8,
    Gbk,
    Utf16Le,
    Utf16Be,
}

impl SqlFileEncoding {
    pub fn to_encoding(self) -> Option<&'static encoding_rs::Encoding> {
        match self {
            Self::Auto => None,
            Self::Utf8 => Some(encoding_rs::UTF_8),
            Self::Gbk => Some(encoding_rs::GBK),
            Self::Utf16Le => Some(encoding_rs::UTF_16LE),
            Self::Utf16Be => Some(encoding_rs::UTF_16BE),
        }
    }
}

fn sql_file_failure_log_enabled_by_default() -> bool {
    true
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SqlFilePreview {
    pub file_name: String,
    pub file_path: String,
    pub size_bytes: u64,
    pub preview: String,
    pub can_execute_without_selected_database: bool,
    #[serde(default)]
    pub establishes_database_context: bool,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub package_file_paths: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub package_part_count: Option<usize>,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub enum SqlFileStatus {
    Started,
    Running,
    StatementDone,
    StatementFailed,
    Done,
    Error,
    Cancelled,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum SqlFileStatementAction {
    Execute(String),
    Skip,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum SqlFileImportStatementKind {
    Execute,
    Skip,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SqlFileImportStatement {
    pub kind: SqlFileImportStatementKind,
    pub sql: String,
    pub source_sqls: Vec<String>,
    pub source_statement_count: usize,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
struct SqlDialectProfile {
    supports_hash_line_comments: bool,
    supports_backtick_identifiers: bool,
    /// Whether `/* ... */` comments nest. PostgreSQL and SQL Server document
    /// nesting (`/* /* */ */` needs both closers, so commenting out a block that
    /// already contains a comment keeps the whole block commented); MySQL
    /// documents the opposite ("Nested comments are not supported, and are
    /// deprecated"). A non-nesting scan ends the comment at the inner `*/` and
    /// then hands the commented-out statements to the executor.
    supports_nested_block_comments: bool,
    /// Whether a backslash inside an ordinary `'...'` string escapes the next
    /// character, so `'it\'s'` stays one string.
    ///
    /// This defaults to the historical behaviour (escape) because several
    /// engines — MySQL and ClickHouse among them — do escape there, and the ones
    /// that do not are listed explicitly below. PostgreSQL and its forks are the
    /// engines this repository has evidence for: `standard_conforming_strings` is
    /// on by default, which is also why the generated PostgreSQL SQL writes
    /// newlines as `E'\n'` instead of `'\n'`.
    supports_backslash_escaped_quotes: bool,
    /// PostgreSQL escape string literals (`E'...'`), which keep backslash escapes
    /// even where ordinary `'...'` literals do not.
    supports_postgres_escape_strings: bool,
    /// Oracle alternative quoting: `q'[text]'`, `q'{text}'`, `q'(text)'`,
    /// `q'<text>'` or `q'XtextX'`. The literal exists so that an apostrophe does
    /// not end the string, so reading it as an ordinary `'...'` string ends the
    /// text early and splits the statement at a semicolon inside it.
    supports_oracle_q_quotes: bool,
    supports_oracle_plsql_blocks: bool,
    supports_oracle_style_routine_bodies: bool,
    supports_slash_line_block_delimiter: bool,
    supports_custom_delimiter_commands: bool,
    supports_mysql_routine_blocks: bool,
    supports_dollar_quoted_strings: bool,
    supports_postgres_dollar_quoted_routines: bool,
    supports_hana_script_blocks: bool,
    supports_firebird_routine_blocks: bool,
    supports_go_batch_separator: bool,
    keeps_sqlserver_module_batch_at_cursor: bool,
    /// Whether a top-level T-SQL control-flow batch (`IF`/`WHILE` with a block
    /// body or `ELSE`, or a top-level `BEGIN ... END` block) stays whole in the
    /// `;`-statement splitter. The SQL Server profile needs it because T-SQL
    /// does not end a block at a semicolon; the generic JDBC profile must not
    /// lose it, or the backend re-splits the TRY/CATCH batches the editor
    /// already kept together (#13514).
    keeps_sqlserver_control_flow_batches: bool,
    preserves_tdsql_leading_directives: bool,
    requires_whitespace_after_line_comment_dashes: bool,
    supports_psql_control_commands: bool,
}

impl Default for SqlDialectProfile {
    fn default() -> Self {
        Self {
            supports_hash_line_comments: false,
            supports_backtick_identifiers: true,
            supports_nested_block_comments: false,
            supports_oracle_q_quotes: false,
            supports_backslash_escaped_quotes: true,
            supports_postgres_escape_strings: false,
            supports_oracle_plsql_blocks: false,
            supports_oracle_style_routine_bodies: false,
            supports_slash_line_block_delimiter: false,
            supports_custom_delimiter_commands: true,
            supports_mysql_routine_blocks: false,
            supports_dollar_quoted_strings: true,
            supports_postgres_dollar_quoted_routines: false,
            supports_hana_script_blocks: false,
            supports_firebird_routine_blocks: false,
            supports_go_batch_separator: false,
            keeps_sqlserver_module_batch_at_cursor: false,
            keeps_sqlserver_control_flow_batches: false,
            preserves_tdsql_leading_directives: false,
            requires_whitespace_after_line_comment_dashes: false,
            supports_psql_control_commands: false,
        }
    }
}

impl SqlDialectProfile {
    fn for_database_type(db_type: DatabaseType) -> Self {
        if matches!(db_type, DatabaseType::Mysql) {
            return Self {
                preserves_tdsql_leading_directives: crate::tdsql_mysql::preserves_leading_directives_for_database_type(
                    db_type,
                ),
                ..Self::mysql_compatible()
            };
        }

        if matches!(db_type, DatabaseType::Gaussdb) {
            return Self::gaussdb();
        }

        if matches!(db_type, DatabaseType::Postgres | DatabaseType::OpenGauss) {
            return Self::postgres_family();
        }

        if matches!(db_type, DatabaseType::OceanbaseOracle) {
            return Self {
                supports_backtick_identifiers: false,
                supports_dollar_quoted_strings: false,
                supports_custom_delimiter_commands: false,
                ..Self::oracle_like()
            };
        }

        if Self::is_oracle_like_database(db_type) {
            return Self::oracle_like();
        }

        if matches!(db_type, DatabaseType::SqlServer) {
            return Self::sql_server();
        }

        if matches!(db_type, DatabaseType::Db2) {
            // DB2 block comments nest; cursor extraction must skip the complete
            // leading comment before handing the query to the Explain gate.
            return Self { supports_nested_block_comments: true, ..Self::default() };
        }

        if matches!(db_type, DatabaseType::ClickHouse) {
            // ClickHouse documents that C-style block comments nest.
            return Self { supports_nested_block_comments: true, ..Self::default() };
        }

        if Self::is_mysql_compatible_database(db_type) {
            return Self::mysql_compatible();
        }

        if matches!(db_type, DatabaseType::SapHana) {
            return Self::sap_hana();
        }

        if matches!(db_type, DatabaseType::Firebird) {
            return Self::firebird();
        }

        if matches!(db_type, DatabaseType::DuckDb) {
            return Self {
                supports_backslash_escaped_quotes: false,
                supports_postgres_escape_strings: true,
                ..Self::default()
            };
        }

        if Self::is_postgres_string_lexer_database(db_type) {
            return Self {
                supports_backslash_escaped_quotes: false,
                supports_nested_block_comments: true,
                supports_postgres_escape_strings: true,
                ..Self::default()
            };
        }

        if matches!(db_type, DatabaseType::Jdbc | DatabaseType::Hive) {
            return Self { supports_oracle_style_routine_bodies: true, ..Self::default() };
        }

        Self::default()
    }

    /// PostgreSQL and the forks that inherit its string literal rules without
    /// inheriting the routine/delimiter handling of [`Self::postgres_family`].
    ///
    /// Redshift is deliberately absent: it descends from PostgreSQL 8.0, which
    /// predates `standard_conforming_strings` defaulting to `on`, so it keeps the
    /// historical behaviour until its own evidence shows otherwise.
    fn is_postgres_string_lexer_database(db_type: DatabaseType) -> bool {
        matches!(
            db_type,
            DatabaseType::Vastbase
                | DatabaseType::Kingbase
                | DatabaseType::Highgo
                | DatabaseType::Uxdb
                | DatabaseType::Gbase8c
                | DatabaseType::Kwdb
        )
    }

    fn mysql_compatible() -> Self {
        Self {
            supports_hash_line_comments: true,
            supports_backslash_escaped_quotes: true,
            supports_mysql_routine_blocks: true,
            requires_whitespace_after_line_comment_dashes: true,
            ..Self::default()
        }
    }

    fn oracle_like() -> Self {
        Self {
            supports_backslash_escaped_quotes: false,
            supports_oracle_plsql_blocks: true,
            supports_oracle_q_quotes: true,
            supports_slash_line_block_delimiter: true,
            ..Self::default()
        }
    }

    /// PostgreSQL and openGauss, which are also the connection types users pick for a
    /// GaussDB/openGauss instance running in Oracle (A) compatibility mode. GaussDB PL/SQL
    /// bodies are Oracle-style (`CREATE PROCEDURE p AS DECLARE ... BEGIN ... END;`) and are
    /// terminated by a standalone `/` line, while the surrounding script syntax is still
    /// PostgreSQL, so the profile keeps those constructs whole without enabling the full
    /// Oracle PL/SQL dialect.
    fn postgres_family() -> Self {
        Self {
            supports_backslash_escaped_quotes: false,
            supports_nested_block_comments: true,
            supports_oracle_style_routine_bodies: true,
            supports_postgres_escape_strings: true,
            supports_slash_line_block_delimiter: true,
            supports_psql_control_commands: true,
            ..Self::default()
        }
    }

    fn gaussdb() -> Self {
        Self {
            supports_backslash_escaped_quotes: false,
            supports_nested_block_comments: true,
            supports_postgres_dollar_quoted_routines: true,
            supports_postgres_escape_strings: true,
            supports_psql_control_commands: true,
            ..Self::oracle_like()
        }
    }

    fn sql_server() -> Self {
        Self {
            supports_go_batch_separator: true,
            keeps_sqlserver_module_batch_at_cursor: true,
            keeps_sqlserver_control_flow_batches: true,
            supports_nested_block_comments: true,
            ..Self::default()
        }
    }

    fn sap_hana() -> Self {
        Self { supports_hana_script_blocks: true, ..Self::default() }
    }

    fn firebird() -> Self {
        Self { supports_backslash_escaped_quotes: false, supports_firebird_routine_blocks: true, ..Self::default() }
    }

    fn is_mysql_compatible_database(db_type: DatabaseType) -> bool {
        matches!(
            db_type,
            DatabaseType::Mysql
                | DatabaseType::Doris
                | DatabaseType::StarRocks
                | DatabaseType::ManticoreSearch
                | DatabaseType::Goldendb
        )
    }

    fn is_oracle_like_database(db_type: DatabaseType) -> bool {
        matches!(
            db_type,
            DatabaseType::Oracle
                | DatabaseType::Dameng
                | DatabaseType::Gaussdb
                | DatabaseType::Yashandb
                | DatabaseType::Oscar
                | DatabaseType::OceanbaseOracle
                | DatabaseType::Xugu
                // ArgoDB (Transwarp fork of Hive/Inceptor) ships a PL/SQL-compatible procedure
                // language: `CREATE [OR REPLACE] PROCEDURE ... IS BEGIN ... END;`. Treat it like
                // Oracle for statement splitting so semicolons inside the procedure body are not
                // misinterpreted as client-side statement terminators.
                | DatabaseType::Argo
                | DatabaseType::Transwarp
        )
    }
}

#[derive(Debug, Clone, Copy, Default)]
pub struct SqlParsingOptions {
    profile: SqlDialectProfile,
}

impl SqlParsingOptions {
    pub fn for_database_type(db_type: DatabaseType) -> Self {
        Self::from_profile(SqlDialectProfile::for_database_type(db_type))
    }

    pub fn for_database_type_and_compatibility(db_type: DatabaseType, compatibility_mode: Option<&str>) -> Self {
        if db_type == DatabaseType::Kingbase {
            let mode = compatibility_mode.unwrap_or_default().trim().to_ascii_lowercase();
            return Self::from_profile(match mode.as_str() {
                "mysql" => SqlDialectProfile::mysql_compatible(),
                "sqlserver" => SqlDialectProfile::sql_server(),
                "pg" | "postgres" | "postgresql" => SqlDialectProfile::postgres_family(),
                // Preserve PL/SQL blocks while mode detection is unavailable;
                // the GaussDB profile also preserves dollar-quoted routines.
                _ => SqlDialectProfile::gaussdb(),
            });
        }
        if db_type == DatabaseType::OpenGauss {
            return match compatibility_mode.map(str::trim) {
                // openGauss stores package specs/bodies as PL/SQL regardless of
                // mode, and A mode is the only mode where the catalog reports
                // them as packages. Any mode other than A keeps the PostgreSQL
                // statement splitter.
                Some(mode) if mode.eq_ignore_ascii_case("A") => Self::from_profile(SqlDialectProfile::gaussdb()),
                Some(_) => Self::for_database_type(db_type),
                // Unknown mode: the compatibility probe failed or the pool was
                // unavailable. Falling back to the plain PostgreSQL profile would
                // split an A-mode package body on its inner semicolons into
                // fragments that the caller may then execute individually, so the
                // conservative PL/SQL-capable profile is used instead.
                None => Self::from_profile(SqlDialectProfile::gaussdb()),
            };
        }
        Self::for_database_type(db_type)
    }

    pub fn mysql_compatible() -> Self {
        Self::from_profile(SqlDialectProfile::mysql_compatible())
    }

    fn from_profile(profile: SqlDialectProfile) -> Self {
        Self { profile }
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SqlFileProgress {
    pub execution_id: String,
    pub status: SqlFileStatus,
    pub statement_index: usize,
    pub success_count: usize,
    pub failure_count: usize,
    pub affected_rows: u64,
    pub elapsed_ms: u128,
    pub statement_summary: String,
    pub error: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub bytes_read: Option<u64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub total_bytes: Option<u64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub phase: Option<SqlFilePhase>,
    /// When processing multiple files, the 0-based index of the current file.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub file_index: Option<usize>,
    /// When processing multiple files, the name of the current file.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub file_name: Option<String>,
    /// Full source SQL behind a `StatementFailed` event, used by the backend to
    /// write the failure log. It is deliberately never serialized: the frontend
    /// only ever needs the 120-char summary, and shipping every failing statement
    /// over IPC would bloat the progress stream it already throttles.
    #[serde(skip)]
    #[serde(default)]
    pub failure_sql: Option<String>,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub enum SqlFilePhase {
    Preparing,
    Reading,
    Executing,
}

pub fn decode_sql_file_bytes(bytes: &[u8]) -> Result<String, String> {
    if bytes.starts_with(&[0xEF, 0xBB, 0xBF]) {
        return std::str::from_utf8(&bytes[3..]).map(|text| text.to_string()).map_err(|_| sql_file_encoding_error());
    }

    if bytes.starts_with(&[0xFF, 0xFE]) {
        return decode_sql_file_with_encoding(&bytes[2..], encoding_rs::UTF_16LE);
    }

    if bytes.starts_with(&[0xFE, 0xFF]) {
        return decode_sql_file_with_encoding(&bytes[2..], encoding_rs::UTF_16BE);
    }

    if let Ok(text) = std::str::from_utf8(bytes) {
        return Ok(text.strip_prefix('\u{feff}').unwrap_or(text).to_string());
    }

    decode_sql_file_with_encoding(bytes, encoding_rs::GBK)
}

/// Decode an SQL/text file using an explicit user-selected encoding.
pub fn decode_sql_file_bytes_with_encoding(bytes: &[u8], encoding: &str) -> Result<String, String> {
    match encoding {
        "utf8" => {
            decode_sql_file_with_encoding(bytes.strip_prefix(&[0xEF, 0xBB, 0xBF]).unwrap_or(bytes), encoding_rs::UTF_8)
        }
        "utf8Bom" => {
            let payload = bytes.strip_prefix(&[0xEF, 0xBB, 0xBF]).unwrap_or(bytes);
            decode_sql_file_with_encoding(payload, encoding_rs::UTF_8)
        }
        "utf16le" => {
            decode_sql_file_with_encoding(bytes.strip_prefix(&[0xFF, 0xFE]).unwrap_or(bytes), encoding_rs::UTF_16LE)
        }
        "utf16be" => {
            decode_sql_file_with_encoding(bytes.strip_prefix(&[0xFE, 0xFF]).unwrap_or(bytes), encoding_rs::UTF_16BE)
        }
        "gbk" => decode_sql_file_with_encoding(bytes, encoding_rs::GBK),
        "auto" | "" => decode_sql_file_bytes(bytes),
        _ => Err(format!("Unsupported SQL file encoding: {encoding}")),
    }
}

/// Encode editor text for an explicit file encoding. The returned bytes include
/// a BOM for UTF-8 BOM and UTF-16 variants.
pub fn encode_sql_file_text(content: &str, encoding: &str) -> Result<Vec<u8>, String> {
    if encoding == "utf16le" || encoding == "utf16be" {
        let mut bytes = if encoding == "utf16le" { vec![0xFF, 0xFE] } else { vec![0xFE, 0xFF] };
        for unit in content.encode_utf16() {
            bytes.extend_from_slice(&if encoding == "utf16le" { unit.to_le_bytes() } else { unit.to_be_bytes() });
        }
        return Ok(bytes);
    }
    let (encoded, _, had_errors) = match encoding {
        "utf8" | "auto" | "" => encoding_rs::UTF_8.encode(content),
        "utf8Bom" => encoding_rs::UTF_8.encode(content),
        "gbk" => encoding_rs::GBK.encode(content),
        _ => return Err(format!("Unsupported SQL file encoding: {encoding}")),
    };
    if had_errors {
        return Err(sql_file_encoding_error());
    }
    let mut bytes = encoded.into_owned();
    if encoding == "utf8Bom" {
        bytes.splice(0..0, [0xEF, 0xBB, 0xBF]);
    }
    Ok(bytes)
}

fn decode_sql_file_with_encoding(bytes: &[u8], encoding: &'static encoding_rs::Encoding) -> Result<String, String> {
    let (text, had_errors) = encoding.decode_without_bom_handling(bytes);
    if had_errors {
        return Err(sql_file_encoding_error());
    }
    Ok(text.into_owned())
}

fn sql_file_encoding_error() -> String {
    "Unsupported SQL file encoding. Save the file as UTF-8, UTF-8 with BOM, UTF-16 with BOM, or GBK, then try again."
        .to_string()
}

/// Whether a `--` sequence starts a line comment. MySQL (and MySQL-wire-compatible
/// dialects) requires the second dash to be followed by whitespace, a control character,
/// or end-of-input —
/// `5--1` is subtraction (`5 - -1`), not a comment. Other dialects (Postgres, Oracle/DM,
/// SQL Server, ...) treat `--` as a comment opener unconditionally.
fn dash_dash_starts_line_comment(profile: SqlDialectProfile, char_after_dashes: Option<char>) -> bool {
    if !profile.requires_whitespace_after_line_comment_dashes {
        return true;
    }
    char_after_dashes.is_none_or(|ch| ch.is_whitespace() || ch.is_control())
}

/// Whether the text ends with an XML/HTML character reference whose closing `;`
/// is about to be scanned. MyBatis XML writes comparison operators as `&gt;=`
/// / `&lt;=`, and that `;` must not be read as a statement terminator (#11699).
/// Only the five predefined XML names (`lt`, `gt`, `amp`, `quot`, `apos`) plus
/// numeric references (`&#39;`, `&#x27;`) are recognized, so a plain bitwise
/// `a&b;` still splits at its real terminator. Mirrors
/// `isXmlEntityReferenceSemicolon` in the editor splitter
/// (`apps/desktop/src/lib/sql/sqlStatementRanges.ts`); keep both in sync.
fn ends_with_xml_entity_reference(buffer: &str) -> bool {
    let bytes = buffer.as_bytes();
    let mut start = bytes.len();
    while start > 0 && bytes[start - 1].is_ascii_alphanumeric() {
        start -= 1;
    }
    if start > 0 && bytes[start - 1] == b'#' {
        start -= 1;
    }
    if start == 0 || bytes[start - 1] != b'&' {
        return false;
    }
    let name = &buffer[start..];
    if let Some(hex) = name.strip_prefix("#x").or_else(|| name.strip_prefix("#X")) {
        return !hex.is_empty() && hex.bytes().all(|byte| byte.is_ascii_hexdigit());
    }
    if let Some(digits) = name.strip_prefix('#') {
        return !digits.is_empty() && digits.bytes().all(|byte| byte.is_ascii_digit());
    }
    matches!(name, "lt" | "gt" | "amp" | "quot" | "apos")
}

/// Tracks an Oracle `q'...'` or `nq'...'` literal across characters, so a semicolon inside its
/// text never splits the statement.
#[derive(Default, Clone, Copy)]
struct OracleQQuoteState {
    awaiting_delimiter: bool,
    closer: Option<char>,
}

impl OracleQQuoteState {
    fn is_open(&self) -> bool {
        self.awaiting_delimiter || self.closer.is_some()
    }

    /// Consumes one character of an open literal; `previous` is the character
    /// before it, as tracked by the caller.
    fn consume(&mut self, ch: char, previous: Option<char>) {
        if self.awaiting_delimiter {
            self.closer = oracle_q_quote_closer(ch);
            self.awaiting_delimiter = false;
        } else if let Some(closer) = self.closer {
            if previous == Some(closer) && ch == '\'' {
                self.closer = None;
            }
        }
    }
}

#[derive(Default)]
pub struct SqlStatementSplitter {
    buffer: String,
    in_single_quote: bool,
    /// Whether the open `'...'` literal reads a backslash as escaping the next
    /// character: MySQL strings always do, PostgreSQL only inside `E'...'`.
    single_quote_escape_string: bool,
    in_double_quote: bool,
    in_backtick: bool,
    in_line_comment: bool,
    /// Depth of the open `/* ... */` comment. Engines that nest block comments
    /// increment it for every inner `/*`, so the inner `*/` does not end the
    /// comment and hand commented-out statements to the executor.
    block_comment_depth: usize,
    dollar_quote_tag: Option<String>,
    postgres_dollar_quoted_routine: bool,
    previous: Option<char>,
    pending_mysql_line_comment_dashes: bool,
    /// Open Oracle `q'...'` literal, if any.
    oracle_q_quote: OracleQQuoteState,
    /// PL/SQL block state of the buffered statement, advanced at each `;`.
    oracle_block: OraclePlSqlBlockTracker,
    custom_delimiter: Option<String>,
    stop_on_error: bool,
    pending_psql_command: Option<String>,
    options: SqlParsingOptions,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SqlStatementWithControl {
    pub sql: String,
    pub stop_on_error: bool,
}

impl SqlStatementSplitter {
    pub fn with_options(options: SqlParsingOptions) -> Self {
        Self { options, ..Self::default() }
    }

    /// A whole-line file directive must not be interpreted inside SQL text.
    pub fn can_start_file_directive(&self) -> bool {
        !self.in_single_quote
            && !self.in_double_quote
            && !self.in_backtick
            && !self.in_line_comment
            && self.block_comment_depth == 0
            && self.dollar_quote_tag.is_none()
            && !self.oracle_q_quote.is_open()
            && self.pending_psql_command.is_none()
    }

    pub fn is_at_file_directive_boundary(&self) -> bool {
        self.can_start_file_directive() && !has_executable_sql_with_options(&self.buffer, self.options)
    }

    pub fn push_chunk(&mut self, chunk: &str) -> Vec<String> {
        self.push_chunk_with_control(chunk).into_iter().map(|statement| statement.sql).collect()
    }

    pub fn push_chunk_with_control(&mut self, chunk: &str) -> Vec<SqlStatementWithControl> {
        let mut statements = Vec::new();
        let chars = chunk.chars().collect::<Vec<_>>();
        let mut i = 0;

        if self.pending_mysql_line_comment_dashes {
            if let Some(first) = chars.first().copied() {
                self.in_line_comment = dash_dash_starts_line_comment(self.options.profile, Some(first));
                self.pending_mysql_line_comment_dashes = false;
            }
        }

        while i < chars.len() {
            if let Some(command) = &mut self.pending_psql_command {
                let ch = chars[i];
                command.push(ch);
                if ch == '\n' {
                    self.finish_psql_command(&mut statements);
                }
                i += 1;
                continue;
            }
            // A psql command consumes the whole line, including quotes, comment
            // markers and semicolons in display text. Buffer it across chunks
            // before letting the SQL scanner interpret those characters.
            if self.options.profile.supports_psql_control_commands
                && chars[i] == '\\'
                && !self.in_single_quote
                && !self.in_double_quote
                && !self.in_backtick
                && !self.in_line_comment
                && self.block_comment_depth == 0
                && self.dollar_quote_tag.is_none()
                && self.buffer.rsplit('\n').next().unwrap_or("").trim().is_empty()
            {
                self.pending_psql_command = Some(String::from("\\"));
                i += 1;
                continue;
            }
            if let Some(tag) = &self.dollar_quote_tag {
                let tag_chars = tag.chars().collect::<Vec<_>>();
                if starts_with_chars(&chars, i, &tag_chars) {
                    for tag_ch in &tag_chars {
                        self.buffer.push(*tag_ch);
                        self.previous = Some(*tag_ch);
                    }
                    i += tag_chars.len();
                    self.dollar_quote_tag = None;
                    continue;
                }

                let ch = chars[i];
                self.buffer.push(ch);
                self.previous = Some(ch);
                i += 1;
                continue;
            }

            let ch = chars[i];
            let next = chars.get(i + 1).copied();

            if self.in_line_comment {
                self.buffer.push(ch);
                if ch == '\n' {
                    self.in_line_comment = false;
                }
                self.previous = Some(ch);
                i += 1;
                continue;
            }

            if self.block_comment_depth > 0 {
                self.buffer.push(ch);
                if self.options.profile.supports_nested_block_comments && self.previous == Some('/') && ch == '*' {
                    self.block_comment_depth += 1;
                    // A nested opener's asterisk must not pair with a following slash as a close.
                    self.previous = None;
                    i += 1;
                    continue;
                } else if self.previous == Some('*') && ch == '/' {
                    self.block_comment_depth -= 1;
                }
                self.previous = Some(ch);
                i += 1;
                continue;
            }

            if self.oracle_q_quote.is_open() {
                self.oracle_q_quote.consume(ch, self.previous);
                self.buffer.push(ch);
                self.previous = Some(ch);
                i += 1;
                continue;
            }

            if !self.in_single_quote && !self.in_double_quote && !self.in_backtick {
                if self.options.profile.supports_oracle_q_quotes
                    && ch == '\''
                    && ends_with_oracle_q_quote_prefix(&self.buffer)
                {
                    self.oracle_q_quote.awaiting_delimiter = true;
                    self.buffer.push(ch);
                    self.previous = Some(ch);
                    i += 1;
                    continue;
                }
                if self.previous == Some('-') && ch == '-' {
                    if self.options.profile.requires_whitespace_after_line_comment_dashes && next.is_none() {
                        self.pending_mysql_line_comment_dashes = true;
                        self.buffer.push(ch);
                        self.previous = Some(ch);
                        i += 1;
                        continue;
                    }
                    if dash_dash_starts_line_comment(self.options.profile, next) {
                        self.in_line_comment = true;
                        self.buffer.push(ch);
                        self.previous = Some(ch);
                        i += 1;
                        continue;
                    }
                }
                if self.previous == Some('/') && ch == '*' {
                    self.block_comment_depth = 1;
                    self.buffer.push(ch);
                    // The opener's own asterisk must not read as a nested opener.
                    self.previous = None;
                    i += 1;
                    continue;
                }
                if self.options.profile.supports_hash_line_comments && ch == '#' {
                    self.in_line_comment = true;
                    self.buffer.push(ch);
                    self.previous = Some(ch);
                    i += 1;
                    continue;
                }
                if ch == '/' && next == Some('*') {
                    self.block_comment_depth = 1;
                    self.buffer.push(ch);
                    // The opener's own asterisk must not read as a nested opener.
                    self.previous = None;
                    i += 1;
                    continue;
                }
                if let Some(tag) = self
                    .options
                    .profile
                    .supports_dollar_quoted_strings
                    .then(|| dollar_quote_tag_at(&chars, i))
                    .flatten()
                {
                    if self.custom_delimiter.is_none() && !self.on_delimiter_line() {
                        if self.options.profile.supports_postgres_dollar_quoted_routines
                            && starts_with_postgres_dollar_quoted_routine_prefix(&self.buffer)
                        {
                            self.postgres_dollar_quoted_routine = true;
                        }
                        for tag_ch in tag.chars() {
                            self.buffer.push(tag_ch);
                            self.previous = Some(tag_ch);
                        }
                        i += tag.chars().count();
                        self.dollar_quote_tag = Some(tag);
                        continue;
                    }
                }
            }

            match ch {
                '\'' if !(self.in_double_quote
                    || self.in_backtick
                    || self.single_quote_backslash_escapes() && has_odd_trailing_backslashes(&self.buffer)) =>
                {
                    self.in_single_quote = !self.in_single_quote;
                    self.single_quote_escape_string = self.in_single_quote
                        && (self.options.profile.supports_backslash_escaped_quotes
                            || (self.options.profile.supports_postgres_escape_strings
                                && ends_with_escape_string_prefix(&self.buffer)));
                    self.buffer.push(ch);
                }
                '"' if !(self.in_single_quote
                    || self.in_backtick
                    || self.options.profile.supports_backslash_escaped_quotes
                        && has_odd_trailing_backslashes(&self.buffer)) =>
                {
                    self.in_double_quote = !self.in_double_quote;
                    self.buffer.push(ch);
                }
                '`' if self.options.profile.supports_backtick_identifiers
                    && !self.in_single_quote
                    && !self.in_double_quote =>
                {
                    self.in_backtick = !self.in_backtick;
                    self.buffer.push(ch);
                }
                ';' if !self.in_single_quote && !self.in_double_quote && !self.in_backtick => {
                    if ends_with_xml_entity_reference(&self.buffer) {
                        // The `;` closes an XML/MyBatis entity (`&gt;`, `&lt;`,
                        // `&#39;`, ...), not the statement (#11699).
                        self.buffer.push(ch);
                    } else if (self.options.profile.supports_custom_delimiter_commands && self.on_delimiter_line())
                        || self.custom_delimiter.is_some()
                    {
                        self.buffer.push(ch);
                    } else if self.options.profile.supports_mysql_routine_blocks
                        && starts_with_mysql_routine_block(&self.buffer)
                    {
                        let mut candidate = self.buffer.clone();
                        candidate.push(ch);
                        if mysql_routine_block_is_complete(&candidate) {
                            // The final semicolon is the client-side statement delimiter.
                            // Keep semicolons inside BEGIN...END, but do not send the
                            // delimiter after END to the MySQL server.
                            self.push_current_statement(&mut statements);
                        } else {
                            self.buffer.push(ch);
                        }
                    } else if !self.postgres_dollar_quoted_routine
                        && self.oracle_block.keeps_block_together(self.options, &self.buffer)
                    {
                        self.buffer.push(ch);
                        if self.oracle_block.is_complete(&self.buffer) {
                            self.push_current_statement(&mut statements);
                        }
                    } else if self.options.profile.supports_hana_script_blocks
                        && starts_with_hana_script_block(&self.buffer)
                    {
                        self.buffer.push(ch);
                        if hana_script_block_is_complete(&self.buffer) {
                            self.push_current_statement(&mut statements);
                        }
                    } else if self.options.profile.supports_firebird_routine_blocks
                        && starts_with_firebird_routine_block(&self.buffer)
                    {
                        self.buffer.push(ch);
                        if firebird_routine_block_is_complete(&self.buffer) {
                            self.push_current_statement(&mut statements);
                        }
                    } else if keeps_sqlserver_control_flow_batch(self.options, &self.buffer) {
                        // T-SQL does not end a control-flow batch at a semicolon
                        // (#9336, #13051, #13514): the inner `;` stays in the
                        // batch and the statement ends after the block's final
                        // `END [TRY]`.
                        self.buffer.push(ch);
                        if sqlserver_control_flow_batch_is_complete(&self.buffer) {
                            // A final `END` without its own `;` shares the
                            // fragment with the next statement; the boundary
                            // sits right after that `END` instead (TS parity).
                            // An `END` directly followed by this `;` keeps the
                            // historical shape: the batch ends here with its
                            // terminating semicolon.
                            let body_end = self.buffer.len() - ch.len_utf8();
                            let body = self.buffer[..body_end].to_string();
                            let mut boundaries = Vec::new();
                            let mut cursor = 0usize;
                            while let Some(relative) = sqlserver_control_flow_batch_boundary(&body[cursor..]) {
                                if cursor + relative >= body.len() {
                                    break;
                                }
                                cursor += relative;
                                boundaries.push(cursor);
                            }
                            if boundaries.is_empty() {
                                self.push_current_statement(&mut statements);
                            } else {
                                let mut piece_from = 0usize;
                                for boundary_end in &boundaries {
                                    self.buffer.clear();
                                    self.buffer.push_str(&body[piece_from..*boundary_end]);
                                    self.push_current_statement(&mut statements);
                                    piece_from = *boundary_end;
                                }
                                let trailing = &body[piece_from..];
                                if !trailing.trim().is_empty() {
                                    self.buffer.clear();
                                    self.buffer.push_str(trailing);
                                    if keeps_sqlserver_control_flow_batch(self.options, trailing) {
                                        // A new batch in the remainder keeps the
                                        // terminating `;` when complete and this
                                        // `;` when it is still mid-typing.
                                        self.buffer.push(ch);
                                        if sqlserver_control_flow_batch_is_complete(trailing) {
                                            self.push_current_statement(&mut statements);
                                        }
                                    } else {
                                        self.push_current_statement(&mut statements);
                                    }
                                } else {
                                    self.buffer.clear();
                                }
                            }
                        }
                    } else {
                        self.push_current_statement(&mut statements);
                    }
                }
                _ => self.buffer.push(ch),
            }

            if !self.in_single_quote && !self.in_double_quote && !self.in_backtick && self.dollar_quote_tag.is_none() {
                if ch == '\n' {
                    let buf_end = self.buffer.len() - 1;
                    let last_line_start = self.buffer[..buf_end].rfind('\n').map_or(0, |p| p + 1);
                    let last_line = self.buffer[last_line_start..buf_end].trim();
                    if self.options.profile.supports_slash_line_block_delimiter && last_line == "/" {
                        let before = self.buffer[..last_line_start].trim();
                        if has_executable_sql_with_options(before, self.options) {
                            statements.push(SqlStatementWithControl {
                                sql: before.to_string(),
                                stop_on_error: self.stop_on_error,
                            });
                        }
                        self.buffer.clear();
                        self.oracle_block.reset();
                        self.postgres_dollar_quoted_routine = false;
                        self.previous = None;
                        i += 1;
                        continue;
                    }
                    if let Some(new_delim) = self
                        .options
                        .profile
                        .supports_custom_delimiter_commands
                        .then(|| {
                            parse_delimiter_command(last_line).filter(|_| {
                                !has_executable_sql_with_options(&self.buffer[..last_line_start], self.options)
                            })
                        })
                        .flatten()
                    {
                        self.custom_delimiter = if new_delim == ";" { None } else { Some(new_delim.to_string()) };
                        if last_line_start > 0 {
                            let before = self.buffer[..last_line_start].trim();
                            if has_executable_sql_with_options(before, self.options) {
                                statements.push(SqlStatementWithControl {
                                    sql: before.to_string(),
                                    stop_on_error: self.stop_on_error,
                                });
                            }
                        }
                        self.buffer.clear();
                        self.oracle_block.reset();
                        self.postgres_dollar_quoted_routine = false;
                        self.previous = None;
                        i += 1;
                        continue;
                    }
                }
                if let Some(delim) = self.custom_delimiter.clone() {
                    // A DELIMITER command can itself end with the active
                    // delimiter (for example `DELIMITER ;;`). Keep the
                    // directive intact so the newline handler can switch the
                    // delimiter instead of emitting a bogus `delimiter`
                    // statement or advancing past the line start.
                    if self.buffer.ends_with(delim.as_str()) && !self.on_delimiter_line() {
                        self.buffer.truncate(self.buffer.len() - delim.len());
                        self.push_current_statement(&mut statements);
                    }
                }
            }

            self.previous = Some(ch);
            i += 1;
        }

        statements
    }

    fn finish_psql_command(&mut self, statements: &mut Vec<SqlStatementWithControl>) {
        let command = self.pending_psql_command.take().expect("pending psql command");
        if let Some(control) = parse_ignorable_psql_control_command(command.trim()) {
            self.stop_on_error |= control == PsqlControlCommand::OnErrorStop;
        } else {
            // Unsupported commands must reach the SQL executor and fail visibly;
            // do not silently discard variable assignments or execution commands.
            self.options.profile.supports_psql_control_commands = false;
            statements.extend(self.push_chunk_with_control(&command));
            self.options.profile.supports_psql_control_commands = true;
        }
    }

    pub fn finish(self) -> Vec<String> {
        self.finish_with_control().into_iter().map(|statement| statement.sql).collect()
    }

    pub fn finish_with_control(mut self) -> Vec<SqlStatementWithControl> {
        let mut statements = Vec::new();
        if self.pending_psql_command.is_some() {
            self.finish_psql_command(&mut statements);
        }
        if self.pending_mysql_line_comment_dashes {
            self.in_line_comment = true;
            self.pending_mysql_line_comment_dashes = false;
        }
        let trimmed = self.buffer.trim();
        let last_line = trimmed.rsplit('\n').next().unwrap_or(trimmed).trim();
        let before_last_line = trimmed.rsplit_once('\n').map(|x| x.0).unwrap_or("").trim();
        if self.options.profile.supports_custom_delimiter_commands
            && parse_delimiter_command(last_line)
                .is_some_and(|_| !has_executable_sql_with_options(before_last_line, self.options))
        {
            let before = trimmed.rsplit_once('\n').map(|x| x.0).unwrap_or("").trim();
            if has_executable_sql_with_options(before, self.options) {
                statements.push(SqlStatementWithControl { sql: before.to_string(), stop_on_error: self.stop_on_error });
            }
            self.buffer.clear();
        } else if self.options.profile.supports_slash_line_block_delimiter && last_line == "/" {
            let before = trimmed.rsplit_once('\n').map(|x| x.0).unwrap_or("").trim();
            if has_executable_sql_with_options(before, self.options) {
                statements.push(SqlStatementWithControl { sql: before.to_string(), stop_on_error: self.stop_on_error });
            }
            self.buffer.clear();
        } else if let Some(ref delim) = self.custom_delimiter {
            if self.buffer.ends_with(delim.as_str()) {
                self.buffer.truncate(self.buffer.len() - delim.len());
            }
        }
        self.push_current_statement(&mut statements);
        statements
    }

    pub fn stop_on_error(&self) -> bool {
        self.stop_on_error
    }

    fn push_current_statement(&mut self, statements: &mut Vec<SqlStatementWithControl>) {
        let statement = self.buffer.trim();
        if has_executable_sql_with_options(statement, self.options) {
            statements.push(SqlStatementWithControl { sql: statement.to_string(), stop_on_error: self.stop_on_error });
        }
        self.buffer.clear();
        self.oracle_block.reset();
        self.postgres_dollar_quoted_routine = false;
        self.previous = None;
        self.pending_mysql_line_comment_dashes = false;
    }

    /// A backslash escapes a quote only where the dialect says so: MySQL for
    /// ordinary strings, PostgreSQL for `E'...'` literals. Outside a string the
    /// profile decides, which keeps the historical MySQL guard that a quote
    /// preceded by an odd number of backslashes does not open a literal.
    fn single_quote_backslash_escapes(&self) -> bool {
        if self.in_single_quote {
            self.single_quote_escape_string
        } else {
            self.options.profile.supports_backslash_escaped_quotes
        }
    }

    fn on_delimiter_line(&self) -> bool {
        let start = self.buffer.rfind('\n').map_or(0, |p| p + 1);
        let line = self.buffer[start..].trim_start().as_bytes();
        line.len() >= 9
            && line[..9].eq_ignore_ascii_case(b"delimiter")
            && !has_executable_sql_with_options(self.buffer[..start].trim(), self.options)
    }
}

fn has_odd_trailing_backslashes(sql: &str) -> bool {
    sql.as_bytes().iter().rev().take_while(|byte| **byte == b'\\').count() % 2 == 1
}

/// True when `text` ends with a PostgreSQL `E'`/`e'` escape-string introducer.
/// The `E` must start its own token: a type name that merely ends in `e`
/// (`DATE'2020-01-01'`) or an identifier such as `x$e` is not an escape string.
fn ends_with_escape_string_prefix(text: &str) -> bool {
    let mut chars = text.chars().rev();
    if !matches!(chars.next(), Some('E' | 'e')) {
        return false;
    }
    !chars.next().is_some_and(is_identifier_continue_char)
}

/// Whether `ch` can continue an unquoted identifier, which decides whether a
/// one-letter introducer (`E'...'`, `q'...'`) starts its own token.
fn is_identifier_continue_char(ch: char) -> bool {
    ch.is_alphanumeric() || ch == '_' || ch == '$'
}

/// Whether the text before a quote ends in an Oracle `q`/`nq` introducer token.
pub(crate) fn ends_with_oracle_q_quote_prefix(text: &str) -> bool {
    let mut chars = text.chars().rev();
    if !matches!(chars.next(), Some('q' | 'Q')) {
        return false;
    }
    let mut previous = chars.next();
    if matches!(previous, Some('n' | 'N')) {
        previous = chars.next();
    }
    !previous.is_some_and(is_identifier_continue_char)
}

/// The closing character of an Oracle alternative-quoting delimiter: brackets
/// pair up (`q'[a]'`) and every other character delimits itself (`q'!a!'`).
/// A quote or whitespace cannot delimit the literal.
fn oracle_q_quote_closer(opening: char) -> Option<char> {
    match opening {
        '[' => Some(']'),
        '{' => Some('}'),
        '(' => Some(')'),
        '<' => Some('>'),
        '\'' | ' ' | '\t' | '\n' | '\r' => None,
        other => Some(other),
    }
}

/// Byte index just past the closing quote of the `q'...'` literal whose opening
/// quote sits at `quote_index`, or `None` when the literal is not well formed.
pub(crate) fn oracle_q_quote_end(sql: &str, quote_index: usize) -> Option<usize> {
    let opening = next_char_at(sql, quote_index + 1)?;
    let closer = oracle_q_quote_closer(opening)?;
    let content_start = quote_index + 1 + opening.len_utf8();
    let closing = format!("{closer}'");
    let offset = sql.get(content_start..)?.find(&closing)?;
    Some(content_start + offset + closing.len())
}

pub fn split_sql_statements(sql: &str) -> Vec<String> {
    split_sql_statements_with_options(sql, SqlParsingOptions::default())
}

#[cfg(test)]
#[test]
fn kingbase_compatibility_profiles_preserve_routine_and_batch_boundaries() {
    for (mode, db_type, sql) in [
        ("oracle", DatabaseType::Gaussdb, "BEGIN\n NULL;\n NULL;\nEND;\n/\nSELECT 1;"),
        (
            "mysql",
            DatabaseType::Mysql,
            "DELIMITER $$\nCREATE PROCEDURE p() BEGIN SELECT 1; SELECT 2; END$$\nDELIMITER ;\nSELECT 3;",
        ),
        (
            "pg",
            DatabaseType::Postgres,
            "CREATE FUNCTION f() RETURNS int AS $$ BEGIN RETURN 1; END; $$ LANGUAGE plpgsql; SELECT 2;",
        ),
        (
            "sqlserver",
            DatabaseType::SqlServer,
            "CREATE PROCEDURE p AS\nBEGIN\n SELECT 1;\n SELECT 2;\nEND\nGO\nSELECT 3;",
        ),
    ] {
        assert_eq!(
            split_sql_statements_for_database_with_compatibility(sql, DatabaseType::Kingbase, Some(mode)),
            split_sql_statements_for_database(sql, db_type),
            "Kingbase mode {mode}"
        );
    }
}

pub fn split_sql_statements_for_database(sql: &str, db_type: DatabaseType) -> Vec<String> {
    sql_execution_plan_for_database(sql, db_type).statements
}

pub fn split_sql_statements_for_database_with_compatibility(
    sql: &str,
    db_type: DatabaseType,
    compatibility_mode: Option<&str>,
) -> Vec<String> {
    sql_execution_plan_for_database_with_compatibility(sql, db_type, compatibility_mode).statements
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SqlExecutionPlan {
    pub statements: Vec<String>,
    pub stop_on_error: bool,
}

pub fn sql_execution_plan_for_database(sql: &str, db_type: DatabaseType) -> SqlExecutionPlan {
    sql_execution_plan_with_options(sql, SqlParsingOptions::for_database_type(db_type))
}

pub fn sql_execution_plan_for_database_with_compatibility(
    sql: &str,
    db_type: DatabaseType,
    compatibility_mode: Option<&str>,
) -> SqlExecutionPlan {
    sql_execution_plan_with_options(
        sql,
        SqlParsingOptions::for_database_type_and_compatibility(db_type, compatibility_mode),
    )
}

fn sql_execution_plan_with_options(sql: &str, options: SqlParsingOptions) -> SqlExecutionPlan {
    if !options.profile.supports_psql_control_commands {
        return SqlExecutionPlan { statements: split_sql_statements_with_options(sql, options), stop_on_error: false };
    }

    let (sql, stop_on_error) = preprocess_psql_control_commands(sql, options.profile);
    let mut parsing_options = options;
    parsing_options.profile.supports_psql_control_commands = false;
    SqlExecutionPlan { statements: split_sql_statements_with_options(&sql, parsing_options), stop_on_error }
}

pub fn split_sql_statements_with_options(sql: &str, options: SqlParsingOptions) -> Vec<String> {
    let mut splitter = SqlStatementSplitter::with_options(options);
    let mut statements = splitter.push_chunk(sql);
    statements.extend(splitter.finish());
    statements
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SqlStatementRange {
    pub text: String,
    pub start: usize,
    pub end: usize,
}

pub fn find_statement_at_cursor(sql: &str, cursor_pos: usize) -> String {
    find_statement_at_cursor_with_options(sql, cursor_pos, SqlParsingOptions::default())
}

pub fn find_statement_at_cursor_for_database(sql: &str, cursor_pos: usize, db_type: DatabaseType) -> String {
    if db_type == DatabaseType::SqlServer {
        return find_sqlserver_statement_at_cursor(sql, cursor_pos);
    }
    let mut options = SqlParsingOptions::for_database_type(db_type);
    if options.profile.supports_psql_control_commands {
        let (sql, _) = preprocess_psql_control_commands(sql, options.profile);
        options.profile.supports_psql_control_commands = false;
        return find_statement_at_cursor_with_options(&sql, cursor_pos, options);
    }
    find_statement_at_cursor_with_options(sql, cursor_pos, options)
}

pub fn find_statement_at_cursor_with_options(sql: &str, cursor_pos: usize, options: SqlParsingOptions) -> String {
    let statements = split_sql_statement_ranges_with_options(sql, options);
    let cursor = utf16_offset_to_byte_index(sql, cursor_pos);

    for (idx, statement) in statements.iter().enumerate() {
        if cursor > statement.start && cursor < statement.end {
            return statement_text_at_cursor(sql, statement, cursor, options);
        }

        if cursor == statement.start {
            if cursor_has_sql_after_cursor_on_line(sql, cursor) {
                return statement_text_at_cursor(sql, statement, cursor, options);
            }
            if let Some(prev) = idx.checked_sub(1).and_then(|prev_idx| statements.get(prev_idx)) {
                return statement_text_at_cursor(sql, prev, cursor, options);
            }
            return statement_text_at_cursor(sql, statement, cursor, options);
        }

        if cursor < statement.start {
            if let Some(prev) = idx.checked_sub(1).and_then(|prev_idx| statements.get(prev_idx)) {
                return statement_text_at_cursor(sql, prev, cursor, options);
            }
            return statement_text_at_cursor(sql, statement, cursor, options);
        }
    }

    statements
        .last()
        .map(|statement| statement_text_at_cursor(sql, statement, cursor, options))
        .unwrap_or_else(|| sql.trim().to_string())
}

fn cursor_has_sql_after_cursor_on_line(sql: &str, cursor: usize) -> bool {
    let line_end = sql[cursor..].find('\n').map_or(sql.len(), |offset| cursor + offset);
    sql[cursor..line_end].chars().any(|ch| !ch.is_whitespace())
}

fn statement_text_at_cursor(
    sql: &str,
    statement: &SqlStatementRange,
    cursor: usize,
    options: SqlParsingOptions,
) -> String {
    let soft_ranges = split_statement_range_at_blank_lines(sql, statement, options);
    find_statement_text_in_ranges(sql, &soft_ranges, cursor).unwrap_or_else(|| statement.text.clone())
}

fn find_statement_text_in_ranges(sql: &str, ranges: &[SqlStatementRange], cursor: usize) -> Option<String> {
    for (idx, range) in ranges.iter().enumerate() {
        if cursor > range.start && cursor < range.end {
            return Some(range.text.clone());
        }

        if cursor == range.start {
            if cursor_has_sql_after_cursor_on_line(sql, cursor) {
                return Some(range.text.clone());
            }
            if let Some(prev) = idx.checked_sub(1).and_then(|prev_idx| ranges.get(prev_idx)) {
                return Some(prev.text.clone());
            }
            return Some(range.text.clone());
        }

        if cursor < range.start {
            if let Some(prev) = idx.checked_sub(1).and_then(|prev_idx| ranges.get(prev_idx)) {
                return Some(prev.text.clone());
            }
            return Some(range.text.clone());
        }
    }

    ranges.last().map(|range| range.text.clone())
}

fn split_statement_range_at_blank_lines(
    sql: &str,
    statement: &SqlStatementRange,
    options: SqlParsingOptions,
) -> Vec<SqlStatementRange> {
    if keeps_oracle_style_block_together(options, &statement.text) {
        return vec![statement.clone()];
    }
    if options.profile.supports_hana_script_blocks && starts_with_hana_script_block(&statement.text) {
        return vec![statement.clone()];
    }
    if options.profile.supports_firebird_routine_blocks && starts_with_firebird_routine_block(&statement.text) {
        return vec![statement.clone()];
    }

    let mut ranges = Vec::new();
    let mut scanner = SqlScanner::with_profile(options.profile);
    let mut current_start = statement.start;
    let mut line_start = statement.start;
    let mut line_has_non_whitespace = false;
    let mut blank_line_run = 0usize;

    for (relative_idx, ch) in sql[statement.start..statement.end].char_indices() {
        let idx = statement.start + relative_idx;
        if ch == '\n' {
            if !line_has_non_whitespace && !scanner.is_masked() {
                blank_line_run += 1;
            } else {
                blank_line_run = 0;
            }
            scanner.step(sql, idx, ch);
            line_start = idx + ch.len_utf8();
            line_has_non_whitespace = false;
            continue;
        }

        if !line_has_non_whitespace && !ch.is_whitespace() {
            if blank_line_run >= 2
                && !scanner.is_masked()
                && has_executable_sql_with_options(&sql[current_start..line_start], options)
                && starts_with_soft_statement_keyword(&sql[line_start..statement.end], options)
            {
                push_statement_range(&mut ranges, sql, current_start, line_start, options);
                current_start = line_start;
            }
            blank_line_run = 0;
            line_has_non_whitespace = true;
        }

        scanner.step(sql, idx, ch);
    }

    push_statement_range(&mut ranges, sql, current_start, statement.end, options);
    if ranges.is_empty() {
        vec![statement.clone()]
    } else {
        ranges
    }
}

fn starts_with_soft_statement_keyword(sql: &str, options: SqlParsingOptions) -> bool {
    if options.profile.supports_hana_script_blocks
        && starts_with_executable_sql_keyword_with_options(sql, &["DO"], options)
    {
        return true;
    }
    if options.profile.supports_firebird_routine_blocks
        && starts_with_executable_sql_keyword_with_options(sql, &["RECREATE"], options)
    {
        return true;
    }
    starts_with_executable_sql_keyword_with_options(
        sql,
        &[
            "CREATE", "ALTER", "DROP", "INSERT", "UPDATE", "DELETE", "MERGE", "REPLACE", "TRUNCATE", "GRANT", "REVOKE",
            "COMMENT", "EXPLAIN", "SHOW", "DESCRIBE", "USE", "SET", "CALL", "EXEC", "EXECUTE", "BEGIN", "COMMIT",
            "ROLLBACK", "DECLARE", "ANALYZE", "VACUUM", "PRAGMA", "REFRESH", "COPY",
        ],
        options,
    )
}

#[allow(dead_code)]
fn split_sql_statement_ranges(sql: &str) -> Vec<SqlStatementRange> {
    split_sql_statement_ranges_with_options(sql, SqlParsingOptions::default())
}

/// Statement ranges that keep their byte offsets into `sql`, so callers can rewrite
/// individual statements in place (see the Oracle administrative DDL tolerance in
/// `sql_analysis`).
pub(crate) fn statement_ranges_for_database(sql: &str, db_type: DatabaseType) -> Vec<SqlStatementRange> {
    split_sql_statement_ranges_with_options(sql, SqlParsingOptions::for_database_type(db_type))
}

fn split_sql_statement_ranges_with_options(sql: &str, options: SqlParsingOptions) -> Vec<SqlStatementRange> {
    let mut ranges = Vec::new();
    let mut start = 0;
    let mut i = 0;
    let mut in_single_quote = false;
    let mut in_double_quote = false;
    let mut in_backtick = false;
    let mut in_line_comment = false;
    let mut block_comment_depth = 0usize;
    let mut dollar_quote_tag: Option<String> = None;
    let mut custom_delimiter: Option<String> = None;
    let mut single_quote_escape_string = false;
    let mut postgres_dollar_quoted_routine = false;
    let mut oracle_block = OraclePlSqlBlockTracker::default();
    let mut oracle_block_start = 0;

    while i < sql.len() {
        if let Some(tag) = &dollar_quote_tag {
            if sql[i..].starts_with(tag) {
                i += tag.len();
                dollar_quote_tag = None;
                continue;
            }
            i += next_char_len(sql, i);
            continue;
        }

        let ch = next_char(sql, i);
        let next = next_char_at(sql, i + ch.len_utf8());

        if in_line_comment {
            i += ch.len_utf8();
            if ch == '\n' {
                in_line_comment = false;
            }
            continue;
        }

        if block_comment_depth > 0 {
            if ch == '*' && next == Some('/') {
                i += 2;
                block_comment_depth -= 1;
            } else if options.profile.supports_nested_block_comments && ch == '/' && next == Some('*') {
                i += 2;
                block_comment_depth += 1;
            } else {
                i += ch.len_utf8();
            }
            continue;
        }

        if !in_single_quote && !in_double_quote && !in_backtick {
            if options.profile.supports_oracle_q_quotes && ch == '\'' && ends_with_oracle_q_quote_prefix(&sql[..i]) {
                if let Some(end) = oracle_q_quote_end(sql, i) {
                    i = end;
                    continue;
                }
            }
            if ch == '-'
                && next == Some('-')
                && dash_dash_starts_line_comment(options.profile, next_char_at(sql, i + 2))
            {
                in_line_comment = true;
                i += 2;
                continue;
            }
            if options.profile.supports_hash_line_comments && ch == '#' {
                in_line_comment = true;
                i += ch.len_utf8();
                continue;
            }
            if ch == '/' && next == Some('*') {
                block_comment_depth = 1;
                i += 2;
                continue;
            }
            if let Some(tag) =
                options.profile.supports_dollar_quoted_strings.then(|| dollar_quote_tag_at_str(sql, i)).flatten()
            {
                if custom_delimiter.is_none() && !is_on_delimiter_line(sql, start, i, options) {
                    if options.profile.supports_postgres_dollar_quoted_routines
                        && starts_with_postgres_dollar_quoted_routine_prefix(&sql[start..i])
                    {
                        postgres_dollar_quoted_routine = true;
                    }
                    i += tag.len();
                    dollar_quote_tag = Some(tag);
                    continue;
                }
            }
            if ch == '\n' {
                let line_start = sql[..i].rfind('\n').map_or(0, |pos| pos + 1);
                let line = sql[line_start..i].trim();
                if options.profile.supports_slash_line_block_delimiter && line == "/" {
                    push_statement_range(&mut ranges, sql, start, line_start, options);
                    start = i + ch.len_utf8();
                    postgres_dollar_quoted_routine = false;
                    i = start;
                    continue;
                }
                if let Some(new_delimiter) = options
                    .profile
                    .supports_custom_delimiter_commands
                    .then(|| {
                        parse_delimiter_command(line)
                            .filter(|_| !has_executable_sql_with_options(&sql[start..line_start], options))
                    })
                    .flatten()
                {
                    let before = sql[start..line_start].trim();
                    if has_executable_sql_with_options(before, options) {
                        push_statement_range(&mut ranges, sql, start, line_start, options);
                    }
                    custom_delimiter = if new_delimiter == ";" { None } else { Some(new_delimiter.to_string()) };
                    start = i + ch.len_utf8();
                    postgres_dollar_quoted_routine = false;
                    i = start;
                    continue;
                }
            }
        }

        let single_quote_backslash_escapes = if in_single_quote {
            single_quote_escape_string
        } else {
            options.profile.supports_backslash_escaped_quotes
        };

        match ch {
            '\'' if !(in_double_quote
                || in_backtick
                || single_quote_backslash_escapes && has_odd_trailing_backslashes(&sql[start..i])) =>
            {
                in_single_quote = !in_single_quote;
                single_quote_escape_string = in_single_quote
                    && (options.profile.supports_backslash_escaped_quotes
                        || (options.profile.supports_postgres_escape_strings
                            && ends_with_escape_string_prefix(&sql[start..i])));
                i += ch.len_utf8();
            }
            '"' if !(in_single_quote
                || in_backtick
                || options.profile.supports_backslash_escaped_quotes
                    && has_odd_trailing_backslashes(&sql[start..i])) =>
            {
                in_double_quote = !in_double_quote;
                i += ch.len_utf8();
            }
            '`' if options.profile.supports_backtick_identifiers && !in_single_quote && !in_double_quote => {
                in_backtick = !in_backtick;
                i += ch.len_utf8();
            }
            ';' if !(in_single_quote
                || in_double_quote
                || in_backtick
                || custom_delimiter.is_some()
                || (options.profile.supports_custom_delimiter_commands
                    && is_on_delimiter_line(sql, start, i, options))) =>
            {
                let is_mysql_routine =
                    options.profile.supports_mysql_routine_blocks && starts_with_mysql_routine_block(&sql[start..i]);
                if is_mysql_routine {
                    if !mysql_routine_block_is_complete(&sql[start..i + ch.len_utf8()]) {
                        i += ch.len_utf8();
                        continue;
                    }
                    push_statement_range(&mut ranges, sql, start, i, options);
                } else {
                    if oracle_block_start != start {
                        oracle_block.reset();
                        oracle_block_start = start;
                    }
                    let is_oracle_plsql =
                        !postgres_dollar_quoted_routine && oracle_block.keeps_block_together(options, &sql[start..i]);
                    if is_oracle_plsql {
                        if !oracle_block.is_complete(&sql[start..i + ch.len_utf8()]) {
                            i += ch.len_utf8();
                            continue;
                        }
                        push_statement_range(&mut ranges, sql, start, i + ch.len_utf8(), options);
                    } else if options.profile.supports_hana_script_blocks
                        && starts_with_hana_script_block(&sql[start..i])
                    {
                        if !hana_script_block_is_complete(&sql[start..i + ch.len_utf8()]) {
                            i += ch.len_utf8();
                            continue;
                        }
                        push_statement_range(&mut ranges, sql, start, i + ch.len_utf8(), options);
                    } else if options.profile.supports_firebird_routine_blocks
                        && starts_with_firebird_routine_block(&sql[start..i])
                    {
                        if !firebird_routine_block_is_complete(&sql[start..i + ch.len_utf8()]) {
                            i += ch.len_utf8();
                            continue;
                        }
                        push_statement_range(&mut ranges, sql, start, i + ch.len_utf8(), options);
                    } else if keeps_sqlserver_control_flow_batch(options, &sql[start..i]) {
                        // T-SQL does not end a control-flow batch at a semicolon
                        // (#9336, #13051): the inner `;` stays in the batch and
                        // the statement ends at the block's final `END [TRY]`.
                        if !sqlserver_control_flow_batch_is_complete(&sql[start..i + ch.len_utf8()]) {
                            i += ch.len_utf8();
                            continue;
                        }
                        // A final `END` without its own `;` shares the fragment
                        // with the next statement; the boundary sits right after
                        // that `END` instead (TS parity with
                        // `sqlStatementRanges.ts`). An `END` directly followed
                        // by this `;` keeps the historical range shape.
                        let body = &sql[start..i];
                        let mut boundaries = Vec::new();
                        let mut cursor = 0usize;
                        while let Some(relative) = sqlserver_control_flow_batch_boundary(&body[cursor..]) {
                            if cursor + relative >= body.len() {
                                break;
                            }
                            cursor += relative;
                            boundaries.push(cursor);
                        }
                        if boundaries.is_empty() {
                            push_statement_range(&mut ranges, sql, start, i + ch.len_utf8(), options);
                        } else {
                            let mut piece_from = 0usize;
                            for boundary_end in &boundaries {
                                push_statement_range(
                                    &mut ranges,
                                    sql,
                                    start + piece_from,
                                    start + boundary_end,
                                    options,
                                );
                                piece_from = *boundary_end;
                            }
                            let trailing = &body[piece_from..];
                            if !trailing.trim().is_empty() {
                                if keeps_sqlserver_control_flow_batch(options, trailing) {
                                    if sqlserver_control_flow_batch_is_complete(trailing) {
                                        push_statement_range(
                                            &mut ranges,
                                            sql,
                                            start + piece_from,
                                            i + ch.len_utf8(),
                                            options,
                                        );
                                    } else {
                                        // The remainder opens a new batch that is
                                        // still mid-typing: this `;` stays inside it.
                                        start += piece_from;
                                        i += ch.len_utf8();
                                        continue;
                                    }
                                } else {
                                    push_statement_range(&mut ranges, sql, start + piece_from, i, options);
                                }
                            }
                        }
                    } else {
                        push_statement_range(&mut ranges, sql, start, i, options);
                    }
                }
                i += ch.len_utf8();
                start = i;
                postgres_dollar_quoted_routine = false;
            }
            _ => {
                i += ch.len_utf8();
                if !in_single_quote && !in_double_quote && !in_backtick {
                    if let Some(delimiter) = &custom_delimiter {
                        if sql[start..i].ends_with(delimiter) && !is_on_delimiter_line(sql, start, i, options) {
                            let end = i - delimiter.len();
                            push_statement_range(&mut ranges, sql, start, end, options);
                            start = i;
                            postgres_dollar_quoted_routine = false;
                        }
                    }
                }
            }
        }
    }

    let trimmed = sql[start..].trim();
    let last_line = trimmed.rsplit('\n').next().unwrap_or(trimmed).trim();
    let before_last_line = trimmed.rsplit_once('\n').map(|x| x.0).unwrap_or("").trim();
    if options.profile.supports_custom_delimiter_commands
        && parse_delimiter_command(last_line)
            .is_some_and(|_| !has_executable_sql_with_options(before_last_line, options))
    {
        if let Some(line_start) = sql[start..].rfind('\n').map(|pos| start + pos + 1) {
            push_statement_range(&mut ranges, sql, start, line_start, options);
        }
    } else if options.profile.supports_slash_line_block_delimiter && last_line == "/" {
        if let Some(line_start) = sql[start..].rfind('\n').map(|pos| start + pos + 1) {
            push_statement_range(&mut ranges, sql, start, line_start, options);
        }
    } else {
        push_statement_range(&mut ranges, sql, start, sql.len(), options);
    }

    ranges
}

fn push_statement_range(
    ranges: &mut Vec<SqlStatementRange>,
    sql: &str,
    start: usize,
    end: usize,
    options: SqlParsingOptions,
) {
    let Some((relative_start, relative_end)) = executable_sql_bounds(&sql[start..end], options) else {
        return;
    };
    let statement_start = start + relative_start;
    let statement_end = start + relative_end;
    let text = sql[statement_start..statement_end].to_string();
    if !text.is_empty() {
        ranges.push(SqlStatementRange { text, start: statement_start, end: statement_end });
    }
}

fn utf16_offset_to_byte_index(sql: &str, offset: usize) -> usize {
    let mut utf16_seen = 0;
    for (byte_index, ch) in sql.char_indices() {
        if utf16_seen >= offset {
            return byte_index;
        }
        utf16_seen += ch.len_utf16();
        if utf16_seen > offset {
            return byte_index + ch.len_utf8();
        }
    }
    sql.len()
}

fn next_char(sql: &str, index: usize) -> char {
    sql[index..].chars().next().unwrap_or('\0')
}

fn next_char_at(sql: &str, index: usize) -> Option<char> {
    if index >= sql.len() {
        None
    } else {
        sql[index..].chars().next()
    }
}

fn next_char_len(sql: &str, index: usize) -> usize {
    next_char(sql, index).len_utf8()
}

fn is_on_delimiter_line(sql: &str, range_start: usize, index: usize, options: SqlParsingOptions) -> bool {
    let line_start = sql[range_start..index].rfind('\n').map_or(range_start, |pos| range_start + pos + 1);
    sql[line_start..index].trim_start().as_bytes().get(..9).is_some_and(|prefix| {
        prefix.eq_ignore_ascii_case(b"delimiter")
            && !has_executable_sql_with_options(sql[range_start..line_start].trim(), options)
    })
}

fn dollar_quote_tag_at_str(sql: &str, index: usize) -> Option<String> {
    let rest = &sql[index..];
    if !rest.starts_with('$') {
        return None;
    }
    let end = rest[1..].find('$')? + 1;
    let tag = &rest[..=end];
    if tag.len() == 2 {
        return Some(tag.to_string());
    }
    let name = &tag[1..tag.len() - 1];
    if !name.chars().all(|ch| ch == '_' || ch.is_ascii_alphanumeric()) {
        return None;
    }
    Some(tag.to_string())
}

pub fn split_sql_batches(sql: &str) -> Vec<String> {
    let ranges = split_sql_batch_ranges(sql, SqlDialectProfile::sql_server());
    if ranges.is_empty() {
        let trimmed = sql.trim();
        return if trimmed.is_empty() { Vec::new() } else { vec![trimmed.to_string()] };
    }
    ranges.into_iter().map(|range| range.text).collect()
}

fn split_sql_batch_ranges(sql: &str, profile: SqlDialectProfile) -> Vec<SqlStatementRange> {
    let mut batches = Vec::new();
    let mut current_start = 0;
    let lines: Vec<&str> = sql.split('\n').collect();
    let mut offset = 0;
    let mut scanner = SqlScanner::with_profile(profile);

    for line in &lines {
        let line_start = offset;
        let line_end = offset + line.len();
        offset = line_end + 1; // +1 for the '\n'

        let trimmed = line.trim();
        let is_batch_separator = profile.supports_go_batch_separator
            && !scanner.is_masked()
            && (trimmed.eq_ignore_ascii_case("go")
                || trimmed.to_ascii_lowercase().starts_with("go ") && trimmed[2..].trim().is_empty());
        if is_batch_separator {
            push_batch_range(&mut batches, sql, current_start, line_start);
            current_start = line_end.min(sql.len());
            if current_start < sql.len() && sql.as_bytes()[current_start] == b'\n' {
                current_start += 1;
            }
        } else {
            for (relative_idx, ch) in line.char_indices() {
                scanner.step(sql, line_start + relative_idx, ch);
            }
        }
        if line_end < sql.len() {
            scanner.step(sql, line_end, '\n');
        }
    }

    push_batch_range(&mut batches, sql, current_start, sql.len());
    batches
}

fn push_batch_range(ranges: &mut Vec<SqlStatementRange>, sql: &str, start: usize, end: usize) {
    let Some((relative_start, relative_end)) = executable_sql_bounds(&sql[start..end], SqlParsingOptions::default())
    else {
        return;
    };
    let statement_start = start + relative_start;
    let statement_end = start + relative_end;
    let text = sql[statement_start..statement_end].to_string();
    if !text.is_empty() {
        ranges.push(SqlStatementRange { text, start: statement_start, end: statement_end });
    }
}

fn find_sqlserver_statement_at_cursor(sql: &str, cursor_pos: usize) -> String {
    let profile = SqlDialectProfile::sql_server();
    let cursor = utf16_offset_to_byte_index(sql, cursor_pos);
    let batches = split_sql_batch_ranges(sql, profile);

    for (idx, batch) in batches.iter().enumerate() {
        if cursor >= batch.start && cursor <= batch.end {
            // Module DDL is checked before the block scan: a procedure body is
            // itself a `BEGIN ... END` block, and the whole `CREATE`/`ALTER`
            // batch is the execution unit there.
            if profile.keeps_sqlserver_module_batch_at_cursor && starts_with_sqlserver_module_ddl(&batch.text) {
                return batch.text.clone();
            }
            if let Some(statement) =
                sqlserver_control_flow_statement_at(&batch.text, Some(cursor.saturating_sub(batch.start)))
            {
                return statement;
            }
            let relative_cursor = sql[..cursor].encode_utf16().count() - sql[..batch.start].encode_utf16().count();
            return find_statement_at_cursor_with_options(&batch.text, relative_cursor, SqlParsingOptions::default());
        }

        if cursor < batch.start {
            if let Some(prev) = idx.checked_sub(1).and_then(|prev_idx| batches.get(prev_idx)) {
                if profile.keeps_sqlserver_module_batch_at_cursor && starts_with_sqlserver_module_ddl(&prev.text) {
                    return prev.text.clone();
                }
                if let Some(statement) = sqlserver_control_flow_statement_at(&prev.text, None) {
                    return statement;
                }
                let relative_cursor = prev.text.encode_utf16().count();
                return find_statement_at_cursor_with_options(
                    &prev.text,
                    relative_cursor,
                    SqlParsingOptions::default(),
                );
            }
            return batch.text.clone();
        }
    }

    batches.last().map(|batch| batch.text.clone()).unwrap_or_else(|| sql.trim().to_string())
}

/// A top-level token of a SQL Server batch: a word or a `;` terminator outside
/// string literals, quoted identifiers, comments and parentheses. `CASE ... END`
/// inside a condition or select list therefore never looks like a block.
struct SqlServerTopLevelToken<'a> {
    text: &'a str,
    start: usize,
    end: usize,
}

impl SqlServerTopLevelToken<'_> {
    fn is_word(&self, keyword: &str) -> bool {
        self.text.eq_ignore_ascii_case(keyword)
    }
}

fn sqlserver_top_level_tokens(sql: &str) -> Vec<SqlServerTopLevelToken<'_>> {
    let bytes = sql.as_bytes();
    let mut tokens = Vec::new();
    let mut paren_depth = 0usize;
    let mut index = 0usize;

    while index < bytes.len() {
        match bytes[index] {
            quote @ (b'\'' | b'"') => {
                index += 1;
                while index < bytes.len() {
                    if bytes[index] == quote {
                        if bytes.get(index + 1) == Some(&quote) {
                            index += 2;
                            continue;
                        }
                        index += 1;
                        break;
                    }
                    index += 1;
                }
            }
            b'[' => {
                index += 1;
                while index < bytes.len() {
                    if bytes[index] == b']' {
                        if bytes.get(index + 1) == Some(&b']') {
                            index += 2;
                            continue;
                        }
                        index += 1;
                        break;
                    }
                    index += 1;
                }
            }
            b'-' if bytes.get(index + 1) == Some(&b'-') => {
                index += 2;
                while index < bytes.len() && bytes[index] != b'\n' {
                    index += 1;
                }
            }
            b'/' if bytes.get(index + 1) == Some(&b'*') => {
                index += 2;
                while index < bytes.len() && !(bytes[index] == b'*' && bytes.get(index + 1) == Some(&b'/')) {
                    index += 1;
                }
                index = (index + 2).min(bytes.len());
            }
            b'(' => {
                paren_depth += 1;
                index += 1;
            }
            b')' => {
                paren_depth = paren_depth.saturating_sub(1);
                index += 1;
            }
            b';' if paren_depth == 0 => {
                tokens.push(SqlServerTopLevelToken { text: ";", start: index, end: index + 1 });
                index += 1;
            }
            byte if paren_depth == 0 && (byte == b'_' || byte.is_ascii_alphabetic()) => {
                let start = index;
                index += 1;
                while index < bytes.len() {
                    let next = bytes[index];
                    if next == b'_' || next.is_ascii_alphanumeric() || next == b'$' {
                        index += 1;
                    } else {
                        break;
                    }
                }
                tokens.push(SqlServerTopLevelToken { text: &sql[start..index], start, end: index });
            }
            _ => index += 1,
        }
    }

    tokens
}

/// `tokens[index]` opens a real block (`BEGIN ... END`, `BEGIN TRY`,
/// `BEGIN CATCH`) rather than a transaction or conversation, which has no
/// matching `END`.
fn sqlserver_begins_block(tokens: &[SqlServerTopLevelToken<'_>], index: usize) -> bool {
    let Some(next) = tokens.get(index + 1) else {
        return false;
    };
    next.text != ";"
        && !["TRANSACTION", "TRAN", "DISTRIBUTED", "DIALOG", "CONVERSATION"].iter().any(|keyword| next.is_word(keyword))
}

#[derive(Clone, Copy, PartialEq, Eq)]
enum SqlServerBlockKind {
    Begin,
    Case,
}

struct SqlServerBlockFrame {
    kind: SqlServerBlockKind,
    start: usize,
    /// An `IF`/`WHILE`/`ELSE` appeared since the last top-level `;`, so this
    /// block is a branch body and its control statement is the execution unit.
    control_statement: bool,
}

/// Byte span of a top-level SQL Server `BEGIN ... END` block.
#[derive(Clone, Copy)]
struct SqlServerControlFlowBlock {
    start: usize,
    end: usize,
    control_statement: bool,
}

/// Top-level `BEGIN ... END` blocks of a batch (`BEGIN TRY ... END TRY BEGIN
/// CATCH ... END CATCH` counts as one). `CASE` frames keep their own `END` from
/// closing the surrounding block, and an unclosed block runs to the end of the
/// batch so a block being typed stays whole.
fn sqlserver_top_level_blocks(sql: &str) -> Vec<SqlServerControlFlowBlock> {
    let tokens = sqlserver_top_level_tokens(sql);
    let mut blocks = Vec::new();
    let mut stack: Vec<SqlServerBlockFrame> = Vec::new();
    let mut pending_try: Option<SqlServerBlockFrame> = None;
    let mut in_control_statement = false;

    for (index, token) in tokens.iter().enumerate() {
        if token.text == ";" {
            in_control_statement = false;
            continue;
        }
        if token.is_word("IF") || token.is_word("WHILE") || token.is_word("ELSE") {
            in_control_statement = true;
            continue;
        }
        if token.is_word("BEGIN") {
            if !sqlserver_begins_block(&tokens, index) {
                continue;
            }
            let frame = match pending_try.take() {
                Some(frame) if stack.is_empty() => frame,
                _ => SqlServerBlockFrame {
                    kind: SqlServerBlockKind::Begin,
                    start: token.start,
                    control_statement: in_control_statement,
                },
            };
            stack.push(frame);
            continue;
        }
        if token.is_word("CASE") {
            stack.push(SqlServerBlockFrame {
                kind: SqlServerBlockKind::Case,
                start: token.start,
                control_statement: in_control_statement,
            });
            continue;
        }
        if !token.is_word("END") {
            continue;
        }
        let next = tokens.get(index + 1);
        // `END CONVERSATION`/`END DIALOG` close a conversation, not a block.
        if next.is_some_and(|next| next.is_word("CONVERSATION") || next.is_word("DIALOG")) {
            continue;
        }
        let Some(frame) = stack.pop() else {
            continue;
        };
        if frame.kind != SqlServerBlockKind::Begin || !stack.is_empty() {
            continue;
        }
        // `END TRY`/`END CATCH` are two-token closers: the span includes the
        // keyword so the boundary sits after the pair.
        let end = match next {
            Some(next) if next.is_word("TRY") || next.is_word("CATCH") => next.end,
            _ => token.end,
        };
        if next.is_some_and(|next| next.is_word("TRY"))
            && tokens.get(index + 2).is_some_and(|token| token.is_word("BEGIN"))
            && tokens.get(index + 3).is_some_and(|token| token.is_word("CATCH"))
        {
            // `END TRY` immediately followed by `BEGIN CATCH`: both halves are
            // one batch, so the CATCH block continues the TRY block's span.
            pending_try = Some(frame);
            continue;
        }
        blocks.push(SqlServerControlFlowBlock { start: frame.start, end, control_statement: frame.control_statement });
    }

    if let Some(frame) = pending_try {
        // `END TRY` without its `BEGIN CATCH` yet: keep the half written batch
        // whole while the user is still typing it.
        blocks.push(SqlServerControlFlowBlock {
            start: frame.start,
            end: sql.len(),
            control_statement: frame.control_statement,
        });
    } else if let Some(frame) = stack.first() {
        if frame.kind == SqlServerBlockKind::Begin {
            blocks.push(SqlServerControlFlowBlock {
                start: frame.start,
                end: sql.len(),
                control_statement: frame.control_statement,
            });
        }
    }

    blocks
}

/// Text of the SQL Server control-flow statement that contains `cursor` (a byte
/// offset into `sql`), or `None` when the batch is ordinary `;`-separated
/// statements. `None` for the cursor means it sits after this batch, so any
/// top-level block keeps the whole batch.
///
/// `IF`/`WHILE` batches and top-level `BEGIN ... END` blocks contain no
/// independent statements: a `;` inside them does not end an execution range
/// (#9336), and a batch that only *contains* the block, after a leading
/// `SET XACT_ABORT ON;` for instance, still has to run it as one unit (#13051).
fn sqlserver_control_flow_statement_at(sql: &str, cursor: Option<usize>) -> Option<String> {
    if starts_with_sqlserver_control_flow_batch(sql) {
        return Some(sql.to_string());
    }
    let blocks = sqlserver_top_level_blocks(sql);
    let block = match cursor {
        Some(cursor) => blocks.iter().find(|block| cursor >= block.start && cursor <= block.end),
        None => blocks.last(),
    }?;
    // A branch body alone is invalid T-SQL, so its whole control statement is
    // the unit; the whole batch keeps the leading statements too.
    if block.control_statement || cursor.is_none() {
        return Some(sql.to_string());
    }
    Some(sql[block.start..block.end].to_string())
}

/// True when the batch starts with a whole T-SQL control-flow statement: an
/// `IF` batch, or a `BEGIN` block. `BEGIN` keywords that start a transaction or
/// conversation have no matching `END` and stay split per statement.
fn starts_with_sqlserver_control_flow_batch(sql: &str) -> bool {
    let tokens = sqlserver_top_level_tokens(sql);
    let Some(first) = tokens.first() else {
        return false;
    };
    if first.is_word("IF") {
        return tokens.iter().any(|token| token.is_word("ELSE"))
            && tokens.iter().any(|token| token.is_word("BEGIN"))
            && tokens.iter().any(|token| token.is_word("END"));
    }
    first.is_word("BEGIN") && sqlserver_begins_block(&tokens, 0) && tokens.iter().any(|token| token.is_word("END"))
}

pub fn starts_with_sqlserver_module_ddl(sql: &str) -> bool {
    let tokens = first_sql_tokens(sql, 4);
    if tokens.len() >= 4
        && tokens[0].eq_ignore_ascii_case("CREATE")
        && tokens[1].eq_ignore_ascii_case("OR")
        && tokens[2].eq_ignore_ascii_case("ALTER")
    {
        return is_sqlserver_module_keyword(&tokens[3]);
    }

    tokens.len() >= 2
        && (tokens[0].eq_ignore_ascii_case("CREATE") || tokens[0].eq_ignore_ascii_case("ALTER"))
        && is_sqlserver_module_keyword(&tokens[1])
}

fn is_sqlserver_module_keyword(token: &str) -> bool {
    ["FUNCTION", "PROC", "PROCEDURE", "TRIGGER", "VIEW"].iter().any(|keyword| token.eq_ignore_ascii_case(keyword))
}

fn starts_with_mysql_routine_block(sql: &str) -> bool {
    is_mysql_routine_ddl_start(sql) && mysql_routine_tokens(sql).iter().any(|token| token.eq_ignore_ascii_case("BEGIN"))
}

fn is_mysql_routine_ddl_start(sql: &str) -> bool {
    let executable = leading_executable_sql_with_options(sql, SqlParsingOptions::mysql_compatible());
    let tokens = first_sql_tokens(executable, 16);
    if tokens.first().is_none_or(|token| !token.eq_ignore_ascii_case("CREATE")) {
        return false;
    }

    for token in tokens.iter().skip(1) {
        if ["PROCEDURE", "FUNCTION", "TRIGGER", "EVENT"].iter().any(|keyword| token.eq_ignore_ascii_case(keyword)) {
            return true;
        }
        if [
            "DATABASE",
            "INDEX",
            "LOGFILE",
            "ROLE",
            "SCHEMA",
            "SERVER",
            "SPATIAL",
            "TABLE",
            "TEMPORARY",
            "UNIQUE",
            "USER",
            "VIEW",
        ]
        .iter()
        .any(|keyword| token.eq_ignore_ascii_case(keyword))
        {
            return false;
        }
    }

    false
}

#[derive(Clone, Copy, PartialEq, Eq)]
enum MysqlRoutineBlockType {
    Begin,
    Case,
}

fn mysql_routine_block_is_complete(sql: &str) -> bool {
    if !starts_with_mysql_routine_block(sql) {
        return false;
    }

    let tokens = mysql_routine_tokens(sql);
    let mut block_stack = Vec::new();
    let mut saw_begin = false;

    for (index, token) in tokens.iter().enumerate() {
        if token == ";" {
            continue;
        }
        if token.eq_ignore_ascii_case("BEGIN") {
            if previous_mysql_routine_word(&tokens, index).is_some_and(|previous| previous.eq_ignore_ascii_case("END"))
            {
                continue;
            }
            saw_begin = true;
            block_stack.push(MysqlRoutineBlockType::Begin);
            continue;
        }
        if token.eq_ignore_ascii_case("CASE") {
            if previous_mysql_routine_word(&tokens, index).is_some_and(|previous| previous.eq_ignore_ascii_case("END"))
            {
                continue;
            }
            block_stack.push(MysqlRoutineBlockType::Case);
            continue;
        }
        if token.eq_ignore_ascii_case("END") && saw_begin {
            let suffix = next_mysql_routine_word(&tokens, index);
            if suffix.is_some_and(|next| next.eq_ignore_ascii_case("CASE")) {
                if block_stack.last() == Some(&MysqlRoutineBlockType::Case) {
                    block_stack.pop();
                }
                continue;
            }
            if suffix.is_some_and(is_mysql_control_block_suffix) {
                continue;
            }
            block_stack.pop();
        }
    }

    saw_begin && block_stack.is_empty() && tokens.last().is_some_and(|token| token == ";")
}

fn is_mysql_control_block_suffix(token: &str) -> bool {
    ["IF", "LOOP", "CASE", "REPEAT", "WHILE"].iter().any(|keyword| token.eq_ignore_ascii_case(keyword))
}

fn previous_mysql_routine_word(tokens: &[String], index: usize) -> Option<&str> {
    tokens[..index].iter().rev().find(|token| token.as_str() != ";").map(String::as_str)
}

fn next_mysql_routine_word(tokens: &[String], index: usize) -> Option<&str> {
    tokens.get(index + 1..)?.iter().find(|token| token.as_str() != ";").map(String::as_str)
}

fn mysql_routine_tokens(sql: &str) -> Vec<String> {
    let chars = sql.chars().collect::<Vec<_>>();
    let mut tokens = Vec::new();
    let mut in_line_comment = false;
    let mut in_block_comment = false;
    let mut in_single_quote = false;
    let mut in_double_quote = false;
    let mut in_backtick = false;
    let mut i = 0;

    while i < chars.len() {
        let ch = chars[i];
        let next = chars.get(i + 1).copied();

        if in_line_comment {
            if ch == '\n' {
                in_line_comment = false;
            }
            i += 1;
            continue;
        }

        if in_block_comment {
            // MySQL block comments do not nest, so a single flag is enough here.
            if ch == '*' && next == Some('/') {
                in_block_comment = false;
                i += 2;
            } else {
                i += 1;
            }
            continue;
        }

        if in_single_quote {
            if ch == '\\' && next.is_some() {
                i += 2;
                continue;
            }
            if ch == '\'' {
                if next == Some('\'') {
                    i += 2;
                    continue;
                }
                in_single_quote = false;
            }
            i += 1;
            continue;
        }

        if in_double_quote {
            if ch == '\\' && next.is_some() {
                i += 2;
                continue;
            }
            if ch == '"' {
                if next == Some('"') {
                    i += 2;
                    continue;
                }
                in_double_quote = false;
            }
            i += 1;
            continue;
        }

        if in_backtick {
            if ch == '`' {
                if next == Some('`') {
                    i += 2;
                    continue;
                }
                in_backtick = false;
            }
            i += 1;
            continue;
        }

        if ch == '-' && next == Some('-') {
            in_line_comment = true;
            i += 2;
            continue;
        }
        if ch == '#' {
            in_line_comment = true;
            i += 1;
            continue;
        }
        if ch == '/' && next == Some('*') {
            in_block_comment = true;
            i += 2;
            continue;
        }
        if ch == '\'' {
            in_single_quote = true;
            i += 1;
            continue;
        }
        if ch == '"' {
            in_double_quote = true;
            i += 1;
            continue;
        }
        if ch == '`' {
            in_backtick = true;
            i += 1;
            continue;
        }
        if ch == ';' {
            tokens.push(";".to_string());
            i += 1;
            continue;
        }
        if ch == '_' || ch.is_ascii_alphabetic() {
            let start = i;
            i += 1;
            while i < chars.len() && is_sql_ident_char(chars[i]) {
                i += 1;
            }
            tokens.push(chars[start..i].iter().collect::<String>().to_ascii_uppercase());
            continue;
        }

        i += 1;
    }

    tokens
}

fn first_sql_tokens(sql: &str, limit: usize) -> Vec<String> {
    let mut tokens = Vec::new();
    let mut token = String::new();
    let mut chars = sql.chars().peekable();

    while let Some(ch) = chars.next() {
        if ch == '-' && chars.peek() == Some(&'-') {
            chars.next();
            if !token.is_empty() {
                tokens.push(std::mem::take(&mut token));
            }
            for comment_char in chars.by_ref() {
                if comment_char == '\n' {
                    break;
                }
            }
        } else if ch == '/' && chars.peek() == Some(&'*') {
            chars.next();
            if !token.is_empty() {
                tokens.push(std::mem::take(&mut token));
            }
            let mut previous = None;
            for comment_char in chars.by_ref() {
                if previous == Some('*') && comment_char == '/' {
                    break;
                }
                previous = Some(comment_char);
            }
        } else if ch.is_ascii_alphanumeric() || ch == '_' {
            token.push(ch);
        } else if !token.is_empty() {
            tokens.push(std::mem::take(&mut token));
        }

        if tokens.len() >= limit {
            break;
        }
    }

    if tokens.len() < limit && !token.is_empty() {
        tokens.push(token);
    }
    tokens
}

fn parse_delimiter_command(line: &str) -> Option<&str> {
    let line = line.trim();
    if line.eq_ignore_ascii_case("delimiter;") {
        return Some(";");
    }
    let bytes = line.as_bytes();
    let rest = if bytes.len() > 10
        && (bytes[..10].eq_ignore_ascii_case(b"delimiter ") || bytes[..10].eq_ignore_ascii_case(b"delimiter\t"))
    {
        Some(&line[10..])
    } else {
        None
    };
    rest.map(|r| r.trim()).filter(|r| !r.is_empty())
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum PsqlControlCommand {
    OnErrorStop,
    ClientDisplay,
}

fn parse_ignorable_psql_control_command(line: &str) -> Option<PsqlControlCommand> {
    let mut parts = line.split_whitespace();
    let command = parts.next()?;

    if command.eq_ignore_ascii_case("\\echo") {
        // Display-only output can be omitted, but another meta-command on the
        // same line or psql's backtick command substitution must not be ignored.
        let arguments = &line[line.find(command)? + command.len()..];
        return (!arguments.contains(['\\', '`'])).then_some(PsqlControlCommand::ClientDisplay);
    }

    if command.eq_ignore_ascii_case("\\timing") {
        let valid =
            parts.next().is_none_or(|value| value.eq_ignore_ascii_case("on") || value.eq_ignore_ascii_case("off"));
        return (valid && parts.next().is_none()).then_some(PsqlControlCommand::ClientDisplay);
    }

    if !command.eq_ignore_ascii_case("\\set") {
        return None;
    }
    let variable = parts.next()?;
    let value = parts.next()?;
    if parts.next().is_some() {
        return None;
    }

    match variable.to_ascii_uppercase().as_str() {
        "ON_ERROR_STOP" if matches!(value.to_ascii_lowercase().as_str(), "on" | "true" | "1") => {
            Some(PsqlControlCommand::OnErrorStop)
        }
        "VERBOSITY" if matches!(value.to_ascii_lowercase().as_str(), "default" | "verbose" | "terse" | "sqlstate") => {
            Some(PsqlControlCommand::ClientDisplay)
        }
        _ => None,
    }
}

fn preprocess_psql_control_commands(sql: &str, profile: SqlDialectProfile) -> (String, bool) {
    let mut output = String::with_capacity(sql.len());
    let mut scanner = SqlScanner::with_profile(profile);
    let mut offset = 0usize;
    let mut stop_on_error = false;

    for segment in sql.split_inclusive('\n') {
        let line = segment.strip_suffix('\n').unwrap_or(segment);
        let command = (!scanner.is_masked()).then(|| parse_ignorable_psql_control_command(line.trim())).flatten();
        if let Some(command) = command {
            stop_on_error |= command == PsqlControlCommand::OnErrorStop;
            // Cursor positions arrive as UTF-16 offsets from the editor. Keep
            // those offsets stable even when display text contains emoji.
            for ch in line.chars() {
                if ch.is_whitespace() {
                    output.push(ch);
                } else {
                    output.extend(std::iter::repeat_n(' ', ch.len_utf16()));
                }
            }
            if segment.ends_with('\n') {
                output.push('\n');
                scanner.step(sql, offset + line.len(), '\n');
            }
        } else {
            output.push_str(segment);
            for (relative_idx, ch) in segment.char_indices() {
                scanner.step(sql, offset + relative_idx, ch);
            }
        }
        offset += segment.len();
    }

    (output, stop_on_error)
}

pub fn statement_summary(statement: &str) -> String {
    const MAX_LEN: usize = 120;

    let collapsed = statement.split_whitespace().collect::<Vec<_>>().join(" ");
    if collapsed.chars().count() <= MAX_LEN {
        return collapsed;
    }

    collapsed.chars().take(MAX_LEN).collect()
}

pub fn prepare_sql_file_statement(
    statement: &str,
    db_type: &DatabaseType,
    driver_profile: Option<&str>,
) -> SqlFileStatementAction {
    let statement = statement.trim();
    let postgres_statement =
        (*db_type == DatabaseType::Postgres).then(|| strip_postgres_pg_dump_guard_command(statement)).flatten();
    let statement = postgres_statement.as_deref().unwrap_or(statement).trim();
    if statement.is_empty()
        || (*db_type == DatabaseType::Postgres
            && postgres_statement.is_some()
            && !has_executable_sql_with_options(
                statement,
                SqlParsingOptions::for_database_type(DatabaseType::Postgres),
            ))
    {
        return SqlFileStatementAction::Skip;
    }

    let is_mysql_compatible_target = is_mysql_compatible_import_target(db_type, driver_profile);
    if is_mysql_compatible_target && is_mysql_lock_table_statement(statement) {
        return SqlFileStatementAction::Skip;
    }

    let Some(body) = mysql_executable_comment_body(statement) else {
        if is_mysql_compatible_target && is_mysql_session_restore_statement(statement) {
            return SqlFileStatementAction::Skip;
        }
        return SqlFileStatementAction::Execute(statement.to_string());
    };

    if !is_mysql_compatible_target {
        return SqlFileStatementAction::Skip;
    }

    let body = body.trim();
    if body.is_empty() || is_mysql_key_toggle_statement(body) || is_mysql_session_restore_statement(body) {
        return SqlFileStatementAction::Skip;
    }

    SqlFileStatementAction::Execute(body.to_string())
}

fn strip_postgres_pg_dump_guard_command(statement: &str) -> Option<String> {
    let executable =
        leading_executable_sql_with_options(statement, SqlParsingOptions::for_database_type(DatabaseType::Postgres));
    let line_end = executable.find('\n').unwrap_or(executable.len());
    if !is_postgres_pg_dump_guard_command(&executable[..line_end]) {
        return None;
    }

    let prefix_len = statement.len() - executable.len();
    let suffix_start = prefix_len + line_end + usize::from(line_end < executable.len());
    let mut prepared = String::with_capacity(statement.len());
    prepared.push_str(&statement[..prefix_len]);
    prepared.push_str(&statement[suffix_start..]);
    Some(prepared)
}

fn is_postgres_pg_dump_guard_command(line: &str) -> bool {
    let mut parts = line.split_whitespace();
    let Some(command) = parts.next() else {
        return false;
    };
    if !matches!(command, "\\restrict" | "\\unrestrict") {
        return false;
    }

    let Some(key) = parts.next() else {
        return false;
    };
    parts.next().is_none() && key.bytes().all(|byte| byte.is_ascii_alphanumeric())
}

pub fn optimize_sql_file_import_statements(
    statements: &[String],
    db_type: Option<DatabaseType>,
    driver_profile: Option<&str>,
) -> Vec<SqlFileImportStatement> {
    optimize_sql_file_import_statements_with_max_insert_batch_statements(
        statements,
        db_type,
        driver_profile,
        SQL_FILE_INSERT_BATCH_MAX_STATEMENTS,
    )
}

pub fn optimize_sql_file_import_statements_with_max_insert_batch_statements(
    statements: &[String],
    db_type: Option<DatabaseType>,
    driver_profile: Option<&str>,
    max_insert_batch_statements: usize,
) -> Vec<SqlFileImportStatement> {
    let mut optimized = Vec::new();
    let mut pending_insert: Option<PendingInsertBatch> = None;
    let merge_adjacent_inserts =
        db_type.as_ref().is_none_or(|db_type| !is_mysql_compatible_import_target(db_type, driver_profile));
    let insert_batch_syntax = insert_batch_syntax(db_type.as_ref());

    for statement in statements {
        let action = db_type
            .as_ref()
            .map(|db_type| prepare_sql_file_statement(statement, db_type, driver_profile))
            .unwrap_or_else(|| SqlFileStatementAction::Execute(statement.trim().to_string()));

        match action {
            SqlFileStatementAction::Skip => {
                flush_pending_insert(&mut optimized, &mut pending_insert);
                optimized.push(SqlFileImportStatement {
                    kind: SqlFileImportStatementKind::Skip,
                    sql: statement.trim().to_string(),
                    source_sqls: vec![statement.trim().to_string()],
                    source_statement_count: 1,
                });
            }
            SqlFileStatementAction::Execute(sql) => {
                // Combining separate MySQL INSERT statements changes session
                // semantics such as LAST_INSERT_ID(), so execute them with the
                // same statement boundaries as the source file.
                let mergeable_insert = merge_adjacent_inserts
                    .then(|| {
                        let options = db_type.map(SqlParsingOptions::for_database_type).unwrap_or_default();
                        parse_mergeable_insert(&sql, options)
                    })
                    .flatten();
                if let Some(insert) = mergeable_insert {
                    match pending_insert.as_mut() {
                        Some(batch) if batch.can_accept(&insert, max_insert_batch_statements) => batch.push(insert),
                        Some(_) => {
                            flush_pending_insert(&mut optimized, &mut pending_insert);
                            pending_insert = Some(PendingInsertBatch::new(insert, insert_batch_syntax));
                        }
                        None => {
                            pending_insert = Some(PendingInsertBatch::new(insert, insert_batch_syntax));
                        }
                    }
                } else {
                    flush_pending_insert(&mut optimized, &mut pending_insert);
                    optimized.push(SqlFileImportStatement {
                        kind: SqlFileImportStatementKind::Execute,
                        sql: sql.clone(),
                        source_sqls: vec![sql],
                        source_statement_count: 1,
                    });
                }
            }
        }
    }

    flush_pending_insert(&mut optimized, &mut pending_insert);
    optimized
}

fn flush_pending_insert(optimized: &mut Vec<SqlFileImportStatement>, pending_insert: &mut Option<PendingInsertBatch>) {
    if let Some(batch) = pending_insert.take() {
        optimized.push(SqlFileImportStatement {
            kind: SqlFileImportStatementKind::Execute,
            sql: batch.to_sql(),
            source_sqls: batch.source_sqls,
            source_statement_count: batch.source_statement_count,
        });
    }
}

const SQL_FILE_INSERT_BATCH_MAX_STATEMENTS: usize = 500;
const SQL_FILE_INSERT_BATCH_MAX_BYTES: usize = 4 * 1024 * 1024;

/// How a merged insert batch must be spelled for its target dialect.
///
/// Oracle-family servers reject the MySQL multi-row `VALUES (…), (…)` form, so
/// merging there has to produce `INSERT ALL … SELECT 1 FROM dual` instead.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum InsertBatchSyntax {
    MultiRowValues,
    OracleInsertAll,
}

fn insert_batch_syntax(db_type: Option<&DatabaseType>) -> InsertBatchSyntax {
    match db_type {
        Some(DatabaseType::Oracle | DatabaseType::OceanbaseOracle) => InsertBatchSyntax::OracleInsertAll,
        _ => InsertBatchSyntax::MultiRowValues,
    }
}

#[derive(Debug, Clone)]
struct MergeableInsert {
    prefix: String,
    prefix_key: String,
    values: String,
    sql: String,
}

#[derive(Debug, Clone)]
struct PendingInsertBatch {
    prefix: String,
    prefix_key: String,
    values: Vec<String>,
    source_sqls: Vec<String>,
    source_statement_count: usize,
    byte_len: usize,
    syntax: InsertBatchSyntax,
}

impl PendingInsertBatch {
    fn new(insert: MergeableInsert, syntax: InsertBatchSyntax) -> Self {
        let byte_len = insert.prefix.len() + insert.values.len() + 16;
        Self {
            syntax,
            prefix: insert.prefix,
            prefix_key: insert.prefix_key,
            values: vec![insert.values],
            source_sqls: vec![insert.sql],
            source_statement_count: 1,
            byte_len,
        }
    }

    fn can_accept(&self, insert: &MergeableInsert, max_insert_batch_statements: usize) -> bool {
        self.prefix_key == insert.prefix_key
            && self.source_statement_count < max_insert_batch_statements
            && self.byte_len + insert.values.len() + 3 <= SQL_FILE_INSERT_BATCH_MAX_BYTES
    }

    fn push(&mut self, insert: MergeableInsert) {
        self.byte_len += insert.values.len() + 3;
        self.values.push(insert.values);
        self.source_sqls.push(insert.sql);
        self.source_statement_count += 1;
    }

    fn to_sql(&self) -> String {
        if self.source_statement_count == 1 {
            return self.source_sqls.first().cloned().unwrap_or_default();
        }
        if self.syntax == InsertBatchSyntax::OracleInsertAll {
            if let Some(target) = oracle_insert_all_target(&self.prefix) {
                let mut sql = String::with_capacity(
                    self.byte_len + "INSERT ALL\n".len() + "SELECT 1 FROM dual".len() + target.len() + 14,
                );
                sql.push_str("INSERT ALL\n");
                for values in &self.values {
                    sql.push_str("INTO ");
                    sql.push_str(target);
                    sql.push_str(" VALUES ");
                    sql.push_str(values);
                    sql.push('\n');
                }
                sql.push_str("SELECT 1 FROM dual");
                return sql;
            }
        }
        format!("{} VALUES\n{}", self.prefix, self.values.join(",\n"))
    }
}

/// The `table (columns)` part of `INSERT INTO table (columns) VALUES …`, used
/// as the repeated `INTO` clause of an `INSERT ALL` batch.
fn oracle_insert_all_target(prefix: &str) -> Option<&str> {
    let mut scanner = SqlScanner::default();
    let mut seen_insert = false;
    for (idx, ch) in prefix.char_indices() {
        scanner.step(prefix, idx, ch);
        if scanner.is_masked() {
            continue;
        }
        if !seen_insert {
            seen_insert = keyword_at(prefix, idx, "insert");
            continue;
        }
        if keyword_at(prefix, idx, "into") {
            let target = prefix[idx + "into".len()..].trim();
            return (!target.is_empty()).then_some(target);
        }
    }
    None
}

fn parse_mergeable_insert(sql: &str, options: SqlParsingOptions) -> Option<MergeableInsert> {
    let executable = leading_executable_sql_with_options(sql, options).trim().trim_end_matches(';').trim();
    if !starts_with_keyword(executable, "insert") {
        return None;
    }

    let (values_start, values_end) = find_top_level_values_keyword(executable)?;
    let prefix_without_values = executable[..values_start].trim_end();
    let values = executable[values_end..].trim();
    let values = parse_insert_values_tail(values)?;

    let prefix = prefix_without_values.to_string();
    Some(MergeableInsert {
        prefix_key: normalize_insert_prefix_key(&prefix),
        prefix,
        values,
        sql: executable.to_string(),
    })
}

fn find_top_level_values_keyword(sql: &str) -> Option<(usize, usize)> {
    let mut scanner = SqlScanner::default();
    let mut depth = 0usize;

    for (idx, ch) in sql.char_indices() {
        scanner.step(sql, idx, ch);
        if scanner.is_masked() {
            continue;
        }

        match ch {
            '(' => depth += 1,
            ')' => depth = depth.saturating_sub(1),
            _ if depth == 0 => {
                for keyword in ["values", "value"] {
                    if keyword_at(sql, idx, keyword) {
                        return Some((idx, idx + keyword.len()));
                    }
                }
            }
            _ => {}
        }
    }

    None
}

fn parse_insert_values_tail(tail: &str) -> Option<String> {
    let tail = tail.trim().trim_end_matches(';').trim();
    if tail.is_empty() {
        return None;
    }

    let mut scanner = SqlScanner::default();
    let mut depth = 0usize;
    let mut saw_tuple = false;
    let mut expecting_tuple = true;

    for (idx, ch) in tail.char_indices() {
        scanner.step(tail, idx, ch);
        if scanner.is_masked() {
            continue;
        }

        if expecting_tuple {
            if ch.is_whitespace() || (saw_tuple && ch == ',') {
                continue;
            }
            if ch != '(' {
                return None;
            }
            expecting_tuple = false;
            saw_tuple = true;
            depth = 1;
            continue;
        }

        match ch {
            '(' => depth += 1,
            ')' => {
                depth = depth.checked_sub(1)?;
                if depth == 0 {
                    expecting_tuple = true;
                }
            }
            ',' if depth == 0 => {}
            _ if depth == 0 && !ch.is_whitespace() => return None,
            _ => {}
        }
    }

    if saw_tuple && depth == 0 {
        Some(tail.to_string())
    } else {
        None
    }
}

#[derive(Default)]
struct SqlScanner {
    profile: SqlDialectProfile,
    in_single_quote: bool,
    single_quote_escape_string: bool,
    in_double_quote: bool,
    in_backtick: bool,
    in_line_comment: bool,
    block_comment_depth: usize,
    oracle_q_quote: OracleQQuoteState,
    dollar_quote_tag: Option<String>,
    previous: Option<char>,
}

impl SqlScanner {
    fn with_profile(profile: SqlDialectProfile) -> Self {
        Self { profile, ..Self::default() }
    }

    fn step(&mut self, sql: &str, idx: usize, ch: char) {
        if let Some(tag) = self.dollar_quote_tag.clone() {
            if sql[idx..].starts_with(&tag) {
                self.dollar_quote_tag = None;
            }
            self.previous = Some(ch);
            return;
        }

        let next = next_char_at(sql, idx + ch.len_utf8());
        if self.in_line_comment {
            if ch == '\n' {
                self.in_line_comment = false;
            }
            self.previous = Some(ch);
            return;
        }
        if self.block_comment_depth > 0 {
            if self.profile.supports_nested_block_comments && self.previous == Some('/') && ch == '*' {
                self.block_comment_depth += 1;
                // A nested opener's asterisk must not pair with a following slash as a close.
                self.previous = None;
                return;
            } else if self.previous == Some('*') && ch == '/' {
                self.block_comment_depth -= 1;
            }
            self.previous = Some(ch);
            return;
        }

        if self.oracle_q_quote.is_open() {
            self.oracle_q_quote.consume(ch, self.previous);
            self.previous = Some(ch);
            return;
        }

        if !self.in_single_quote && !self.in_double_quote && !self.in_backtick {
            if self.profile.supports_oracle_q_quotes && ch == '\'' && ends_with_oracle_q_quote_prefix(&sql[..idx]) {
                self.oracle_q_quote.awaiting_delimiter = true;
                self.previous = Some(ch);
                return;
            }
            if (ch == '-' && next == Some('-')) || (self.profile.supports_hash_line_comments && ch == '#') {
                self.in_line_comment = true;
            } else if ch == '/' && next == Some('*') {
                self.block_comment_depth = 1;
                // The opener's own asterisk must not read as a nested opener.
                self.previous = None;
                return;
            } else if let Some(tag) =
                self.profile.supports_dollar_quoted_strings.then(|| dollar_quote_tag_at_str(sql, idx)).flatten()
            {
                self.dollar_quote_tag = Some(tag);
            }
        }

        let single_quote_backslash_escapes = if self.in_single_quote {
            self.single_quote_escape_string
        } else {
            self.profile.supports_backslash_escaped_quotes
        };
        match ch {
            '\'' if !(self.in_double_quote
                || self.in_backtick
                || single_quote_backslash_escapes && self.previous == Some('\\')) =>
            {
                self.in_single_quote = !self.in_single_quote;
                self.single_quote_escape_string = self.in_single_quote
                    && (self.profile.supports_backslash_escaped_quotes
                        || (self.profile.supports_postgres_escape_strings
                            && ends_with_escape_string_prefix(&sql[..idx])));
            }
            '"' if !(self.in_single_quote
                || self.in_backtick
                || self.profile.supports_backslash_escaped_quotes && self.previous == Some('\\')) =>
            {
                self.in_double_quote = !self.in_double_quote;
            }
            '`' if self.profile.supports_backtick_identifiers && !self.in_single_quote && !self.in_double_quote => {
                self.in_backtick = !self.in_backtick;
            }
            _ => {}
        }
        self.previous = Some(ch);
    }

    fn is_masked(&self) -> bool {
        self.in_single_quote
            || self.in_double_quote
            || self.in_backtick
            || self.in_line_comment
            || self.block_comment_depth > 0
            || self.oracle_q_quote.is_open()
            || self.dollar_quote_tag.is_some()
    }
}

fn keyword_at(sql: &str, idx: usize, keyword: &str) -> bool {
    let end = idx + keyword.len();
    sql.get(idx..end).is_some_and(|candidate| candidate.eq_ignore_ascii_case(keyword))
        && sql[..idx].chars().next_back().is_none_or(|ch| !is_sql_ident_char(ch))
        && sql.get(end..).and_then(|tail| tail.chars().next()).is_none_or(|ch| !is_sql_ident_char(ch))
}

fn starts_with_keyword(sql: &str, keyword: &str) -> bool {
    sql.get(..keyword.len()).is_some_and(|candidate| candidate.eq_ignore_ascii_case(keyword))
        && sql.get(keyword.len()..).and_then(|tail| tail.chars().next()).is_none_or(|ch| !is_sql_ident_char(ch))
}

fn is_sql_ident_char(ch: char) -> bool {
    ch == '_' || ch == '$' || ch.is_ascii_alphanumeric()
}

fn normalize_insert_prefix_key(prefix: &str) -> String {
    let mut scanner = SqlScanner::default();
    let mut key = String::with_capacity(prefix.len());
    let mut previous_space = false;

    for (idx, ch) in prefix.char_indices() {
        scanner.step(prefix, idx, ch);
        if scanner.in_single_quote
            || scanner.in_double_quote
            || scanner.in_backtick
            || scanner.dollar_quote_tag.is_some()
        {
            key.push(ch);
            previous_space = false;
            continue;
        }

        if ch.is_whitespace() {
            if !previous_space {
                key.push(' ');
            }
            previous_space = true;
        } else {
            key.push(ch.to_ascii_lowercase());
            previous_space = false;
        }
    }

    key.trim().to_string()
}

pub fn starts_with_executable_sql_keyword(sql: &str, keywords: &[&str]) -> bool {
    starts_with_executable_sql_keyword_with_options(sql, keywords, SqlParsingOptions::default())
}

pub fn starts_with_executable_sql_keyword_for_database(sql: &str, keywords: &[&str], db_type: DatabaseType) -> bool {
    starts_with_executable_sql_keyword_with_options(sql, keywords, SqlParsingOptions::for_database_type(db_type))
}

pub fn starts_with_duckdb_result_sql_keyword(sql: &str) -> bool {
    starts_with_executable_sql_keyword(
        sql,
        &[
            "SELECT",
            "SHOW",
            "DESCRIBE",
            "EXPLAIN",
            "WITH",
            "PRAGMA",
            "FROM",
            "SUMMARIZE",
            "SUMMARISE",
            "PIVOT",
            "UNPIVOT",
        ],
    )
}

pub fn starts_with_executable_sql_keyword_with_options(
    sql: &str,
    keywords: &[&str],
    options: SqlParsingOptions,
) -> bool {
    let Some(token) = first_executable_sql_token_with_options(sql, options) else {
        return false;
    };
    keywords.iter().any(|keyword| executable_sql_keyword_matches(token, keyword))
}

fn executable_sql_keyword_matches(token: &str, keyword: &str) -> bool {
    token.eq_ignore_ascii_case(keyword)
        || (keyword.eq_ignore_ascii_case("DESCRIBE") && token.eq_ignore_ascii_case("DESC"))
}

fn is_mysql_compatible_import_profile(profile: &str) -> bool {
    matches!(
        profile,
        "mariadb"
            | "tidb"
            | "oceanbase"
            | "custom_mysql"
            | "doris"
            | "starrocks"
            | "manticoresearch"
            | "selectdb"
            | "goldendb"
    )
}

pub fn supports_connection_level_database_bootstrap_target(
    db_type: &DatabaseType,
    driver_profile: Option<&str>,
) -> bool {
    matches!(db_type, DatabaseType::Mysql | DatabaseType::Doris | DatabaseType::StarRocks | DatabaseType::Goldendb)
        || driver_profile
            .map(|profile| profile.to_ascii_lowercase())
            .is_some_and(|profile| is_mysql_compatible_import_profile(&profile) && profile != "manticoresearch")
}

pub fn is_mysql_compatible_import_target(db_type: &DatabaseType, driver_profile: Option<&str>) -> bool {
    matches!(
        db_type,
        DatabaseType::Mysql
            | DatabaseType::Doris
            | DatabaseType::StarRocks
            | DatabaseType::ManticoreSearch
            | DatabaseType::Goldendb
    ) || driver_profile
        .map(|profile| profile.to_ascii_lowercase())
        .is_some_and(|profile| is_mysql_compatible_import_profile(&profile))
}

fn mysql_executable_comment_body(statement: &str) -> Option<&str> {
    let bytes = statement.as_bytes();
    let start = leading_mysql_executable_comment_start(statement)?;
    let body_start = if bytes.get(start + 2) == Some(&b'!') { start + 3 } else { start + 4 };
    let mut body_start = body_start;
    while body_start < bytes.len() && (bytes[body_start].is_ascii_digit() || bytes[body_start].is_ascii_whitespace()) {
        body_start += 1;
    }

    let close = find_block_comment_close(bytes, body_start, false)?;
    if has_executable_sql(&statement[close + 2..]) {
        return None;
    }

    Some(&statement[body_start..close])
}

fn leading_mysql_executable_comment_start(statement: &str) -> Option<usize> {
    let bytes = statement.as_bytes();
    let mut i = 0;

    while i < bytes.len() {
        while i < bytes.len() && bytes[i].is_ascii_whitespace() {
            i += 1;
        }

        if i + 1 < bytes.len() && bytes[i] == b'-' && bytes[i + 1] == b'-' {
            i += 2;
            while i < bytes.len() && bytes[i] != b'\n' {
                i += 1;
            }
            continue;
        }

        if bytes[i] == b'#' {
            i += 1;
            while i < bytes.len() && bytes[i] != b'\n' {
                i += 1;
            }
            continue;
        }

        if i + 1 < bytes.len() && bytes[i] == b'/' && bytes[i + 1] == b'*' {
            if i + 2 < bytes.len() && (bytes[i + 2] == b'!' || (i + 3 < bytes.len() && &bytes[i + 2..i + 4] == b"M!")) {
                return Some(i);
            }

            let close = find_block_comment_close(bytes, i + 2, false)?;
            i = close + 2;
            continue;
        }

        return None;
    }

    None
}

fn find_block_comment_close(bytes: &[u8], mut start: usize, nested: bool) -> Option<usize> {
    let mut depth = 1usize;
    while start + 1 < bytes.len() {
        if bytes[start] == b'*' && bytes[start + 1] == b'/' {
            depth -= 1;
            if depth == 0 {
                return Some(start);
            }
            start += 2;
            continue;
        }
        if nested && bytes[start] == b'/' && bytes[start + 1] == b'*' {
            depth += 1;
            start += 2;
            continue;
        }
        start += 1;
    }
    None
}

fn is_mysql_key_toggle_statement(statement: &str) -> bool {
    let upper = statement.split_whitespace().collect::<Vec<_>>().join(" ").to_ascii_uppercase();
    upper.starts_with("ALTER TABLE ") && (upper.ends_with(" ENABLE KEYS") || upper.ends_with(" DISABLE KEYS"))
}

fn is_mysql_lock_table_statement(statement: &str) -> bool {
    let executable = leading_executable_sql(statement);
    let upper = executable.split_whitespace().collect::<Vec<_>>().join(" ").to_ascii_uppercase();
    upper == "UNLOCK TABLES" || (upper.starts_with("LOCK TABLES ") && upper.ends_with(" WRITE"))
}

fn is_mysql_session_restore_statement(statement: &str) -> bool {
    let executable = leading_executable_sql_with_options(statement, SqlParsingOptions::mysql_compatible());
    let upper = executable.split_whitespace().collect::<Vec<_>>().join(" ").to_ascii_uppercase();
    if !upper.starts_with("SET ") {
        return false;
    }

    let assignment = upper.trim_start_matches("SET ").trim();
    if assignment.starts_with('@') {
        return false;
    }

    assignment.contains("= @OLD_")
        || assignment.contains("=@OLD_")
        || assignment.contains("= @SAVED_")
        || assignment.contains("=@SAVED_")
}

fn leading_executable_sql(sql: &str) -> &str {
    leading_executable_sql_with_options(sql, SqlParsingOptions::default())
}

fn leading_executable_sql_with_options(sql: &str, options: SqlParsingOptions) -> &str {
    let bytes = sql.as_bytes();
    let mut i = 0;

    while i < bytes.len() {
        while i < bytes.len() && bytes[i].is_ascii_whitespace() {
            i += 1;
        }

        if i >= bytes.len() {
            break;
        }

        if i + 1 < bytes.len() && bytes[i] == b'-' && bytes[i + 1] == b'-' {
            i += 2;
            while i < bytes.len() && bytes[i] != b'\n' {
                i += 1;
            }
            continue;
        }

        if options.profile.supports_hash_line_comments && bytes[i] == b'#' {
            i += 1;
            while i < bytes.len() && bytes[i] != b'\n' {
                i += 1;
            }
            continue;
        }

        if i + 1 < bytes.len() && bytes[i] == b'/' && bytes[i + 1] == b'*' {
            if i + 2 < bytes.len() && (bytes[i + 2] == b'!' || (i + 3 < bytes.len() && &bytes[i + 2..i + 4] == b"M!")) {
                break;
            }

            let Some(close) = find_block_comment_close(bytes, i + 2, options.profile.supports_nested_block_comments)
            else {
                return &sql[sql.len()..];
            };
            i = close + 2;
            continue;
        }

        break;
    }

    &sql[i..]
}

fn first_executable_sql_token_with_options(sql: &str, options: SqlParsingOptions) -> Option<&str> {
    let bytes = sql.as_bytes();
    let mut i = 0;

    while i < bytes.len() {
        while i < bytes.len() && (bytes[i].is_ascii_whitespace() || bytes[i] == b'(') {
            i += 1;
        }

        if i >= bytes.len() {
            break;
        }

        if i + 1 < bytes.len() && bytes[i] == b'-' && bytes[i + 1] == b'-' {
            i += 2;
            while i < bytes.len() && bytes[i] != b'\n' {
                i += 1;
            }
            continue;
        }

        if options.profile.supports_hash_line_comments && bytes[i] == b'#' {
            i += 1;
            while i < bytes.len() && bytes[i] != b'\n' {
                i += 1;
            }
            continue;
        }

        if i + 1 < bytes.len() && bytes[i] == b'/' && bytes[i + 1] == b'*' {
            if i + 2 < bytes.len() && (bytes[i + 2] == b'!' || (i + 3 < bytes.len() && &bytes[i + 2..i + 4] == b"M!")) {
                i += if bytes[i + 2] == b'!' { 3 } else { 4 };
                while i < bytes.len() && (bytes[i].is_ascii_digit() || bytes[i].is_ascii_whitespace()) {
                    i += 1;
                }
                break;
            }

            i += 2;
            while i + 1 < bytes.len() && !(bytes[i] == b'*' && bytes[i + 1] == b'/') {
                i += 1;
            }
            i = (i + 2).min(bytes.len());
            continue;
        }

        break;
    }

    let start = i;
    while i < bytes.len() && (bytes[i].is_ascii_alphabetic() || bytes[i] == b'_') {
        i += 1;
    }

    (i > start).then_some(&sql[start..i])
}

fn starts_with_oracle_plsql_block(sql: &str) -> bool {
    OraclePlSqlBlock::parse(sql).starts_block()
}

/// Whether a statement must stay a single statement instead of being cut at its inner
/// semicolons: Oracle PL/SQL blocks for Oracle-like dialects, and the Oracle-style routine bodies
/// that PostgreSQL-family connections reach on a GaussDB/openGauss Oracle-compatibility server.
fn keeps_oracle_style_block_together(options: SqlParsingOptions, statement_head: &str) -> bool {
    if options.profile.supports_oracle_plsql_blocks {
        return starts_with_oracle_plsql_block(statement_head);
    }
    options.profile.supports_oracle_style_routine_bodies && starts_with_oracle_style_routine_body(statement_head)
}

/// Whether the statement opened so far is a T-SQL control-flow batch that the
/// `;`-statement splitter must keep whole: an `IF`/`WHILE` batch (its block
/// body keeps the splitter going; a branchless one is a single statement
/// anyway), or a top-level `BEGIN` that opens a real block (`BEGIN TRY ... END
/// TRY BEGIN CATCH ... END CATCH` counts as one). `BEGIN TRAN[SACTION]` and
/// friends have no matching `END` and stay split per statement. Only meaningful
/// when the profile keeps such batches (`keeps_sqlserver_control_flow_batches`).
fn keeps_sqlserver_control_flow_batch(options: SqlParsingOptions, statement_head: &str) -> bool {
    if !options.profile.keeps_sqlserver_control_flow_batches {
        return false;
    }
    let tokens = sqlserver_top_level_tokens(statement_head);
    let Some(first) = tokens.first() else {
        return false;
    };
    if first.is_word("IF") || first.is_word("WHILE") {
        return true;
    }
    first.is_word("BEGIN") && sqlserver_begins_block(&tokens, 0)
}

/// Top-level `BEGIN`/`CASE` blocks the T-SQL statement has left open at its
/// end. `END TRY` immediately followed by `BEGIN CATCH` continues the TRY
/// block, so the pair keeps the depth open instead of ending the batch
/// (#13051). Tokens inside strings, bracketed identifiers, comments and
/// parentheses are ignored, so a nested statement's own blocks do not matter.
fn sqlserver_control_flow_open_blocks(sql: &str) -> usize {
    let tokens = sqlserver_top_level_tokens(sql);
    let mut depth = 0usize;
    let mut carried_try = false;
    for (index, token) in tokens.iter().enumerate() {
        if token.is_word("BEGIN") {
            if !sqlserver_begins_block(&tokens, index) {
                continue;
            }
            if carried_try {
                // `BEGIN CATCH` continues the carried TRY block: the depth the
                // `END TRY` left open is consumed here, not extended.
                carried_try = false;
            } else {
                depth += 1;
            }
            continue;
        }
        if token.is_word("CASE") {
            depth += 1;
            continue;
        }
        if !token.is_word("END") {
            continue;
        }
        let next = tokens.get(index + 1);
        // `END CONVERSATION`/`END DIALOG` close a conversation, not a block.
        if next.is_some_and(|next| next.is_word("CONVERSATION") || next.is_word("DIALOG")) {
            continue;
        }
        if next.is_some_and(|next| next.is_word("TRY"))
            && tokens.get(index + 2).is_some_and(|token| token.is_word("BEGIN"))
            && tokens.get(index + 3).is_some_and(|token| token.is_word("CATCH"))
        {
            // `END TRY` immediately followed by `BEGIN CATCH`: both halves are
            // one batch, so the CATCH block continues the TRY block's span.
            carried_try = true;
            continue;
        }
        depth = depth.saturating_sub(1);
        carried_try = false;
    }
    depth
}

/// Whether the buffered control-flow batch is complete: every top-level
/// `BEGIN`/`CASE` it opened has been closed, so this `;` is a real statement
/// boundary. A batch still open — including one that is mid-typing — keeps the
/// `;` and stays whole.
fn sqlserver_control_flow_batch_is_complete(sql: &str) -> bool {
    sqlserver_control_flow_open_blocks(sql) == 0
}

/// Byte offset just after the `END`/`END TRY`/`END CATCH` that closes the block
/// a `;`-fragment carried into it, when that closure is final (not followed by
/// `ELSE`). T-SQL semicolons are optional, so a batch whose final `END` has no
/// trailing `;` shares its fragment with the next statement; the statement
/// boundary then sits right after the closing token instead of at the next
/// `;`. Mirrors `scanSqlServerControlFlow`'s `closedAt`/`wordAfterClose` in
/// `sqlStatementRanges.ts`: a block opened and closed inside one `;`-free run
/// has no boundary (the whole run stays one statement), and a closure followed
/// by `ELSE` only continues the same `IF`, so a later closure in the same
/// fragment replaces it.
fn sqlserver_control_flow_batch_boundary(sql: &str) -> Option<usize> {
    let tokens = sqlserver_top_level_tokens(sql);
    let mut index = 0usize;
    let mut fragment_start_depth = 0usize;
    while index < tokens.len() {
        // Scan one `;`-delimited fragment with the depth the previous fragment
        // left open; only a closure of that carried depth is a boundary.
        let mut depth = fragment_start_depth;
        let mut carried_try = false;
        let mut boundary: Option<(usize, &str)> = None;
        while index < tokens.len() {
            let token = &tokens[index];
            if token.is_word(";") {
                index += 1;
                break;
            }
            if token.is_word("BEGIN") {
                if sqlserver_begins_block(&tokens, index) {
                    if carried_try {
                        // `BEGIN CATCH` continues the carried TRY block.
                        carried_try = false;
                    } else {
                        depth += 1;
                    }
                }
                index += 1;
                continue;
            }
            if token.is_word("CASE") {
                depth += 1;
                index += 1;
                continue;
            }
            if !token.is_word("END") {
                index += 1;
                continue;
            }
            let next = tokens.get(index + 1);
            // `END CONVERSATION`/`END DIALOG` close a conversation, not a block.
            if next.is_some_and(|next| next.is_word("CONVERSATION") || next.is_word("DIALOG")) {
                index += 1;
                continue;
            }
            if next.is_some_and(|next| next.is_word("TRY"))
                && tokens.get(index + 2).is_some_and(|token| token.is_word("BEGIN"))
                && tokens.get(index + 3).is_some_and(|token| token.is_word("CATCH"))
            {
                // `END TRY BEGIN CATCH` keeps the pair in one batch.
                carried_try = true;
                index += 1;
                continue;
            }
            depth = depth.saturating_sub(1);
            carried_try = false;
            if fragment_start_depth > 0 && depth == 0 {
                // `END TRY`/`END CATCH` are two-token closers: the boundary sits
                // after the pair, and the word after the pair decides finality.
                let paired = next.is_some_and(|next| next.is_word("TRY") || next.is_word("CATCH"));
                let (end_offset, word_after) = if paired {
                    (tokens[index + 1].end, tokens.get(index + 2).map_or("", |token| token.text))
                } else {
                    (token.end, next.map_or("", |token| token.text))
                };
                if boundary.as_ref().is_none_or(|(_, word)| word.eq_ignore_ascii_case("ELSE")) {
                    boundary = Some((end_offset, word_after));
                }
            }
            index += 1;
        }
        if let Some((offset, word_after)) = boundary {
            if !word_after.eq_ignore_ascii_case("ELSE") {
                return Some(offset);
            }
        }
        fragment_start_depth = depth;
    }
    None
}

fn starts_with_oracle_style_routine_body(sql: &str) -> bool {
    OraclePlSqlBlock::parse(sql).starts_oracle_style_routine_body()
}

fn starts_with_postgres_dollar_quoted_routine_prefix(sql: &str) -> bool {
    let block = OraclePlSqlBlock::parse(sql);
    let Some(first) = block.tokens.first() else {
        return false;
    };
    if !first.is_word("CREATE") {
        return false;
    }
    let tokens = OraclePlSqlBlock::skip_create_modifiers(&block.tokens[1..]);
    tokens.first().is_some_and(|token| token.is_any_word(&["FUNCTION", "PROCEDURE"]))
        && block.tokens.iter().rev().find_map(OraclePlSqlToken::as_word) == Some("AS")
}

pub(crate) fn oracle_plsql_block_is_complete(sql: &str) -> bool {
    OraclePlSqlBlock::parse(sql).is_complete()
}

fn starts_with_hana_script_block(sql: &str) -> bool {
    HanaScriptBlock::parse(sql).starts_block()
}

fn hana_script_block_is_complete(sql: &str) -> bool {
    if let Some((_, last_line)) = sql.rsplit_once('\n') {
        if !last_line.trim_start().to_ascii_uppercase().starts_with("END;") {
            return false;
        }
    }
    HanaScriptBlock::parse(sql).is_complete()
}

struct HanaScriptBlock {
    tokens: Vec<OraclePlSqlToken>,
}

impl HanaScriptBlock {
    fn parse(sql: &str) -> Self {
        Self { tokens: oracle_plsql_tokens(sql) }
    }

    fn starts_block(&self) -> bool {
        let Some(first) = self.tokens.first().and_then(OraclePlSqlToken::as_word) else {
            return false;
        };
        if first == "DO" {
            return true;
        }
        let mut index = 1;
        if first == "CREATE"
            && self.tokens.get(index).is_some_and(|token| token.is_word("OR"))
            && self.tokens.get(index + 1).is_some_and(|token| token.is_word("REPLACE"))
        {
            index += 2;
        }
        let Some(object_type) = self.tokens.get(index).and_then(OraclePlSqlToken::as_word) else {
            return false;
        };
        if first != "CREATE" && first != "ALTER" {
            return false;
        }
        if !matches!(object_type, "PROCEDURE" | "FUNCTION" | "TRIGGER") {
            return false;
        }
        // HANA also accepts ALTER PROCEDURE ... RECOMPILE. Only hold a statement
        // as a script block once its SQLScript body is present, otherwise a plain
        // metadata/compilation ALTER would never flush at its semicolon.
        self.tokens.iter().any(|token| token.is_word("BEGIN"))
    }

    fn is_complete(&self) -> bool {
        if !self.starts_block() {
            return false;
        }

        let mut block_depth = 0usize;
        let mut case_depth = 0usize;
        let mut saw_begin = false;

        for (index, token) in self.tokens.iter().enumerate() {
            if token.is_word("BEGIN") {
                if previous_adjacent_word(&self.tokens, index).is_some_and(|previous| previous == "END") {
                    continue;
                }
                block_depth += 1;
                saw_begin = true;
                continue;
            }
            if token.is_word("CASE") {
                if previous_adjacent_word(&self.tokens, index).is_none_or(|previous| previous != "END") {
                    case_depth += 1;
                }
                continue;
            }
            if token.is_word("END") {
                let next = next_adjacent_word(&self.tokens, index);
                if matches!(next, Some("IF" | "FOR" | "WHILE")) {
                    continue;
                }
                if case_depth > 0 {
                    case_depth -= 1;
                } else {
                    block_depth = block_depth.saturating_sub(1);
                }
            }
        }

        saw_begin
            && block_depth == 0
            && case_depth == 0
            && self.tokens.last().is_some_and(OraclePlSqlToken::is_semicolon)
    }
}

fn starts_with_firebird_routine_block(sql: &str) -> bool {
    FirebirdRoutineBlock::parse(sql).starts_block()
}

fn firebird_routine_block_is_complete(sql: &str) -> bool {
    FirebirdRoutineBlock::parse(sql).is_complete()
}

struct FirebirdRoutineBlock {
    tokens: Vec<OraclePlSqlToken>,
}

impl FirebirdRoutineBlock {
    fn parse(sql: &str) -> Self {
        Self { tokens: oracle_plsql_tokens(sql) }
    }

    fn starts_block(&self) -> bool {
        let Some(first) = self.tokens.first().and_then(OraclePlSqlToken::as_word) else {
            return false;
        };
        if first == "EXECUTE" {
            return self.tokens.get(1).is_some_and(|token| token.is_word("BLOCK"));
        }
        if !matches!(first, "CREATE" | "RECREATE" | "ALTER") {
            return false;
        }
        let mut index = 1;
        if self.tokens.get(index).is_some_and(|token| token.is_word("OR"))
            && self.tokens.get(index + 1).is_some_and(|token| token.is_any_word(&["ALTER", "REPLACE"]))
        {
            index += 2;
        }
        let Some(object_type) = self.tokens.get(index).and_then(OraclePlSqlToken::as_word) else {
            return false;
        };
        if object_type == "PACKAGE" {
            if !self.tokens.get(index + 1).is_some_and(|token| token.is_word("BODY")) {
                return false;
            }
        } else if !matches!(object_type, "PROCEDURE" | "FUNCTION" | "TRIGGER") {
            return false;
        }
        if first == "ALTER" {
            // Firebird accepts `ALTER TRIGGER name ACTIVE/INACTIVE;`. Only treat ALTER
            // as a routine block when it defines a body via AS or BEGIN.
            return self.tokens.iter().any(|token| token.is_any_word(&["AS", "BEGIN"]));
        }
        true
    }

    fn is_complete(&self) -> bool {
        if !self.starts_block() {
            return false;
        }

        let mut block_depth = 0usize;
        let mut case_depth = 0usize;
        let mut saw_begin = false;

        for (index, token) in self.tokens.iter().enumerate() {
            if token.is_word("BEGIN") {
                if previous_adjacent_word(&self.tokens, index).is_some_and(|previous| previous == "END") {
                    continue;
                }
                block_depth += 1;
                saw_begin = true;
                continue;
            }
            if token.is_word("CASE") {
                if previous_adjacent_word(&self.tokens, index).is_none_or(|previous| previous != "END") {
                    case_depth += 1;
                }
                continue;
            }
            if token.is_word("END") {
                if case_depth > 0 {
                    case_depth -= 1;
                } else {
                    block_depth = block_depth.saturating_sub(1);
                }
            }
        }

        saw_begin
            && block_depth == 0
            && case_depth == 0
            && self.tokens.last().is_some_and(OraclePlSqlToken::is_semicolon)
    }
}

/// The BEGIN/END scope walk behind [`OraclePlSqlBlock::is_complete`], kept resumable so
/// [`OraclePlSqlBlockTracker`] only walks the tokens added since its previous check.
#[derive(Debug, Clone)]
struct OraclePlSqlBlockWalk {
    object_kind: Option<OraclePlSqlCreateObjectKind>,
    scopes: Vec<OraclePlSqlScope>,
    awaiting_routine_declarations: bool,
    saw_begin: bool,
    complete: bool,
    next_index: usize,
}

impl OraclePlSqlBlockWalk {
    fn new(block: &OraclePlSqlBlock) -> Self {
        // Package/type specifications have declarations and an outer END with
        // no BEGIN. Bodies also own an outer END beyond nested routine END
        // pairs so an inner END cannot finish the object.
        let object_kind = block.create_object_kind();
        let scopes = match object_kind {
            Some(OraclePlSqlCreateObjectKind::Body | OraclePlSqlCreateObjectKind::Spec) => {
                vec![OraclePlSqlScope::Object]
            }
            None => Vec::new(),
        };
        Self {
            object_kind,
            scopes,
            // A stored PROCEDURE/FUNCTION has no DECLARE keyword: its declare section
            // starts right after its own IS/AS. Opening it there lets a local subprogram
            // own its BEGIN ... END instead of ending the routine.
            awaiting_routine_declarations: block.is_create_routine(),
            saw_begin: false,
            complete: false,
            next_index: 0,
        }
    }

    fn advance(&mut self, tokens: &[OraclePlSqlToken]) {
        while self.next_index < tokens.len() {
            self.step(tokens, self.next_index);
            self.next_index += 1;
        }
    }

    fn step(&mut self, tokens: &[OraclePlSqlToken], index: usize) {
        let token = &tokens[index];
        let scopes = &mut self.scopes;
        if token.is_semicolon() {
            if matches!(scopes.last(), Some(OraclePlSqlScope::RoutineHeader)) {
                scopes.pop();
            }
            return;
        }

        if self.awaiting_routine_declarations && token.is_any_word(&["IS", "AS"]) {
            self.awaiting_routine_declarations = false;
            scopes.push(OraclePlSqlScope::Declaration);
        } else if token.is_word("DECLARE") {
            if !matches!(scopes.last(), Some(OraclePlSqlScope::Declaration)) {
                scopes.push(OraclePlSqlScope::Declaration);
            }
        } else if token.is_any_word(&["PROCEDURE", "FUNCTION"])
            && matches!(scopes.last(), Some(OraclePlSqlScope::Declaration | OraclePlSqlScope::Routine))
        {
            scopes.push(OraclePlSqlScope::RoutineHeader);
        } else if token.is_any_word(&["IS", "AS"]) && matches!(scopes.last(), Some(OraclePlSqlScope::RoutineHeader)) {
            *scopes.last_mut().unwrap() = OraclePlSqlScope::Routine;
        } else if token.is_word("BEGIN") {
            // A local routine's BEGIN belongs to that routine, not to the outer block.
            if matches!(scopes.last(), Some(OraclePlSqlScope::Declaration | OraclePlSqlScope::Routine)) {
                *scopes.last_mut().unwrap() = OraclePlSqlScope::Block;
            } else {
                scopes.push(OraclePlSqlScope::Block);
            }
            self.saw_begin = true;
            self.complete = false;
        } else if token.is_word("CASE") {
            // Both CASE expressions and CASE statements own an END.
            // The CASE token that follows END CASE is a suffix, not a scope start.
            // Require source adjacency: `end ), (case` must open a new CASE scope.
            if previous_adjacent_word(tokens, index) != Some("END") {
                scopes.push(OraclePlSqlScope::Case);
            }
        } else if token.is_word("END") {
            let next = next_adjacent_word(tokens, index);
            if matches!(next, Some("IF" | "LOOP")) {
                return;
            }
            if matches!(next, Some("CASE")) && !matches!(scopes.last(), Some(OraclePlSqlScope::Case)) {
                return;
            }
            if scopes.pop().is_some() {
                self.complete = scopes.is_empty();
            }
        }
    }

    fn is_complete(&self) -> bool {
        match self.object_kind {
            // Package/type objects complete on their outer END [name]; a package
            // body may omit an initialization BEGIN when it has no executable
            // initialization section.
            Some(OraclePlSqlCreateObjectKind::Body | OraclePlSqlCreateObjectKind::Spec) => self.complete,
            _ => self.saw_begin && self.complete,
        }
    }
}

/// Incremental [`keeps_oracle_style_block_together`] and [`oracle_plsql_block_is_complete`]
/// for a statement that the splitters grow one statement-level `;` at a time. Re-tokenizing
/// the whole statement at every inner `;` made splitting a large package body quadratic: a
/// 370 KB DM8 package body spent minutes in the splitter before reaching the server (#13450).
///
/// The splitters only consult it at a `;` outside quotes and comments, so tokenizing the
/// statement in slices that start or end at those semicolons yields the same tokens as
/// tokenizing it whole.
#[derive(Debug, Default)]
struct OraclePlSqlBlockTracker {
    block: OraclePlSqlBlock,
    scanned_len: usize,
    walk: Option<OraclePlSqlBlockWalk>,
}

impl OraclePlSqlBlockTracker {
    fn reset(&mut self) {
        *self = Self::default();
    }

    fn scan(&mut self, statement: &str) {
        if statement.len() < self.scanned_len {
            self.reset();
        }
        self.block.tokens.extend(oracle_plsql_tokens(&statement[self.scanned_len..]));
        self.scanned_len = statement.len();
    }

    /// [`keeps_oracle_style_block_together`] for `statement_head`, the statement before the `;`.
    fn keeps_block_together(&mut self, options: SqlParsingOptions, statement_head: &str) -> bool {
        if !options.profile.supports_oracle_plsql_blocks && !options.profile.supports_oracle_style_routine_bodies {
            return false;
        }
        self.scan(statement_head);
        if options.profile.supports_oracle_plsql_blocks {
            return self.block.starts_block();
        }
        self.block.starts_oracle_style_routine_body()
    }

    /// [`oracle_plsql_block_is_complete`] for `statement`, which ends with the `;`.
    fn is_complete(&mut self, statement: &str) -> bool {
        self.scan(statement);
        if let Some(complete) = self.block.completion_without_block_walk() {
            return complete;
        }
        let block = &self.block;
        let walk = self.walk.get_or_insert_with(|| OraclePlSqlBlockWalk::new(block));
        walk.advance(&block.tokens);
        walk.is_complete()
    }
}

#[derive(Debug, Default)]
struct OraclePlSqlBlock {
    tokens: Vec<OraclePlSqlToken>,
}

#[derive(Debug, Clone, PartialEq, Eq)]
enum OraclePlSqlToken {
    Word(String),
    /// A double-quoted identifier (`"schema"."procedure"`). Kept as its own variant
    /// instead of a [`Self::Word`]: the block detectors compare keywords, and a quoted
    /// name must never satisfy `is_word` (a column called `"END"` is not the block end).
    /// Dropping it entirely made `BEGIN "S"."P"(); END;` tokenize exactly like a
    /// transaction `BEGIN;`, so the splitter cut the block at the inner semicolon and
    /// the server rejected the truncated statement (#10434).
    QuotedIdentifier,
    Semicolon,
    /// Punctuation / operators / numbers. Kept so `end ), (case` is not treated as the
    /// PL/SQL closer `END CASE` (adjacent-word checks must not skip across these).
    Other,
}

impl OraclePlSqlBlock {
    fn parse(sql: &str) -> Self {
        Self { tokens: oracle_plsql_tokens(sql) }
    }

    fn starts_block(&self) -> bool {
        match self.tokens.as_slice() {
            [first, ..] if first.is_word("DECLARE") => true,
            [first, second, ..] if first.is_word("BEGIN") && !Self::is_transaction_begin_tail(second) => true,
            // Oracle 12c `WITH [FUNCTION|PROCEDURE ... END;] <main query>` inline PL/SQL
            // declarations (also accepted by DM8 — issue #11275). The declaration section is
            // PL/SQL, but the statement is not over at its `END;` — the main query's own
            // terminator ends it.
            [first, second, ..] if first.is_word("WITH") && second.is_any_word(&["FUNCTION", "PROCEDURE"]) => true,
            [first, rest @ ..] if first.is_word("CREATE") => Self::starts_create_plsql_object(rest),
            _ => false,
        }
    }

    /// Whether the statement is a routine whose body is written in Oracle PL/SQL syntax
    /// (`CREATE [OR REPLACE] PROCEDURE|FUNCTION ... { AS | IS } { DECLARE | BEGIN }`, plus the
    /// Oracle-only `PACKAGE BODY` / `TYPE BODY` forms).
    ///
    /// This is deliberately narrower than [`Self::starts_block`]. A PostgreSQL connection only
    /// sees this shape when the server is a GaussDB/openGauss instance in Oracle (A) compatibility
    /// mode, because PostgreSQL itself requires a dollar-quoted or string body
    /// (`AS $$ ... $$`, `AS 'body'`) and has no `PACKAGE`/`TYPE BODY`. Keeping the narrow test at
    /// the entry point lets [`Self::is_complete`] end such a body at its outer `END;` while
    /// ordinary PostgreSQL routines, `CREATE TRIGGER ... EXECUTE FUNCTION` statements and
    /// transaction `BEGIN;` blocks keep splitting at their own statement terminator.
    fn starts_oracle_style_routine_body(&self) -> bool {
        let [first, rest @ ..] = self.tokens.as_slice() else {
            return false;
        };
        if !first.is_word("CREATE") {
            return false;
        }
        let rest = Self::skip_create_modifiers(rest);
        match rest {
            [object, body, ..] if object.is_any_word(&["PACKAGE", "TYPE"]) && body.is_word("BODY") => true,
            [object, ..] if object.is_any_word(&["FUNCTION", "PROCEDURE"]) => {
                Self::routine_body_starts_with_plsql_keyword(rest)
            }
            _ => false,
        }
    }

    /// The body introducer of an Oracle-style routine. Declarations may follow `AS`/`IS` either
    /// directly or after the optional `DECLARE` keyword, so only the `DECLARE`/`BEGIN` forms are
    /// recognized; a dollar-quoted or string body is never a word token, so PostgreSQL routines
    /// cannot match here.
    fn routine_body_starts_with_plsql_keyword(tokens: &[OraclePlSqlToken]) -> bool {
        for (index, token) in tokens.iter().enumerate() {
            if !token.is_any_word(&["AS", "IS"]) {
                continue;
            }
            return tokens.get(index + 1).is_some_and(|next| next.is_any_word(&["DECLARE", "BEGIN"]));
        }
        false
    }

    fn is_complete(&self) -> bool {
        if let Some(complete) = self.completion_without_block_walk() {
            return complete;
        }
        let mut walk = OraclePlSqlBlockWalk::new(self);
        walk.advance(&self.tokens);
        walk.is_complete()
    }

    /// The completion rules decided by the statement header alone; `None` means the
    /// BEGIN/END walk in [`OraclePlSqlBlockWalk`] decides.
    fn completion_without_block_walk(&self) -> Option<bool> {
        if !self.starts_block() {
            return Some(false);
        }

        // `WITH [FUNCTION|PROCEDURE ... END;] <main query>;` follows its own completion
        // rule (see with_function_is_complete); the classic block walk would fire at the
        // declaration's `END;` and cut the main query off the statement.
        if self.starts_with_function_declaration() {
            return Some(self.with_function_is_complete());
        }

        if self.tokens.first().is_some_and(|token| token.is_word("CREATE")) {
            let object = Self::skip_create_modifiers(&self.tokens[1..]);
            if object.first().is_some_and(|token| token.is_word("TRIGGER"))
                && object
                    .iter()
                    .find(|token| token.is_any_word(&["BEGIN", "DECLARE", "COMPOUND", "CALL"]))
                    .is_some_and(|token| token.is_word("CALL"))
            {
                return Some(self.tokens.last().is_some_and(OraclePlSqlToken::is_semicolon));
            }
        }
        None
    }

    fn starts_with_function_declaration(&self) -> bool {
        matches!(
            self.tokens.as_slice(),
            [first, second, ..] if first.is_word("WITH") && second.is_any_word(&["FUNCTION", "PROCEDURE"])
        )
    }

    /// Completion rule for `WITH [FUNCTION|PROCEDURE ... END;] <main query>;` (issue #11275):
    /// no depth-0 `;` may end the statement while the WITH declaration section is open —
    /// declaration assignments, nested block ends and the `END;` closing each declaration all
    /// stay inside. Once the main query starts at an empty scope, its own terminator
    /// completes the statement.
    fn with_function_is_complete(&self) -> bool {
        if !self.tokens.last().is_some_and(OraclePlSqlToken::is_semicolon) {
            return false;
        }

        let mut scopes: Vec<OraclePlSqlScope> = Vec::new();
        let mut in_main_query = false;

        for (index, token) in self.tokens.iter().enumerate() {
            if token.is_semicolon() {
                if in_main_query && scopes.is_empty() {
                    return true;
                }
                continue;
            }
            let Some(word) = token.as_word() else {
                continue;
            };

            // The statement-initial WITH token sits at index 0 and must not open the query.
            if index > 0
                && scopes.is_empty()
                && matches!(word, "SELECT" | "INSERT" | "UPDATE" | "DELETE" | "MERGE" | "WITH")
            {
                in_main_query = true;
                continue;
            }

            match word {
                "BEGIN" => scopes.push(OraclePlSqlScope::Block),
                "CASE" if previous_adjacent_word(&self.tokens, index) != Some("END") => {
                    scopes.push(OraclePlSqlScope::Case);
                }
                "END" => {
                    let next = next_adjacent_word(&self.tokens, index);
                    if matches!(next, Some("IF" | "LOOP")) {
                        continue;
                    }
                    if matches!(next, Some("CASE")) && !matches!(scopes.last(), Some(OraclePlSqlScope::Case)) {
                        continue;
                    }
                    scopes.pop();
                }
                _ => {}
            }
        }

        false
    }

    fn starts_create_plsql_object(tokens: &[OraclePlSqlToken]) -> bool {
        let tokens = Self::skip_create_modifiers(tokens);
        match tokens {
            // PACKAGE BODY / TYPE BODY are programmable blocks with an outer END.
            [object, body, ..] if object.is_any_word(&["PACKAGE", "TYPE"]) && body.is_word("BODY") => true,
            // Plain CREATE TYPE ... AS OBJECT (...); ends with ");" — not a PL/SQL block.
            [object, ..] if object.is_word("TYPE") => false,
            [object, ..] if object.is_any_word(&["FUNCTION", "PROCEDURE", "TRIGGER", "PACKAGE"]) => true,
            _ => false,
        }
    }

    fn create_object_kind(&self) -> Option<OraclePlSqlCreateObjectKind> {
        if self.tokens.first().is_none_or(|token| !token.is_word("CREATE")) {
            return None;
        }
        let tokens = Self::skip_create_modifiers(&self.tokens[1..]);
        match tokens {
            [object, body, ..] if object.is_any_word(&["PACKAGE", "TYPE"]) && body.is_word("BODY") => {
                Some(OraclePlSqlCreateObjectKind::Body)
            }
            // A compound trigger's timing-point sections each own a BEGIN ... END
            // <timing point>, and only the outer END [trigger] finishes it.
            [object, header @ ..] if object.is_word("TRIGGER") && Self::is_compound_trigger_header(header) => {
                Some(OraclePlSqlCreateObjectKind::Body)
            }
            // Only PACKAGE specs lack BEGIN; plain TYPE objects are ordinary SQL.
            [object, ..] if object.is_word("PACKAGE") => Some(OraclePlSqlCreateObjectKind::Spec),
            _ => None,
        }
    }

    /// Whether a trigger header (the tokens after `TRIGGER`) declares a `COMPOUND TRIGGER`.
    /// Only the header is inspected: it ends at the body of a simple trigger.
    fn is_compound_trigger_header(tokens: &[OraclePlSqlToken]) -> bool {
        let header_end = tokens
            .iter()
            .position(|token| token.is_semicolon() || token.is_any_word(&["BEGIN", "DECLARE", "CALL"]))
            .unwrap_or(tokens.len());
        tokens[..header_end].windows(2).any(|pair| pair[0].is_word("COMPOUND") && pair[1].is_word("TRIGGER"))
    }

    /// `CREATE [OR REPLACE] [EDITIONABLE] PROCEDURE|FUNCTION ...`.
    fn is_create_routine(&self) -> bool {
        let [first, rest @ ..] = self.tokens.as_slice() else {
            return false;
        };
        first.is_word("CREATE")
            && Self::skip_create_modifiers(rest)
                .first()
                .is_some_and(|object| object.is_any_word(&["PROCEDURE", "FUNCTION"]))
    }

    /// Skip OR REPLACE / FORCE / NOFORCE / EDITIONABLE modifiers after CREATE.
    fn skip_create_modifiers(tokens: &[OraclePlSqlToken]) -> &[OraclePlSqlToken] {
        let mut rest = tokens;
        loop {
            match rest {
                [or, replace, tail @ ..] if or.is_word("OR") && replace.is_word("REPLACE") => {
                    rest = tail;
                }
                [modifier, tail @ ..]
                    if modifier.is_any_word(&["FORCE", "NOFORCE", "EDITIONABLE", "NONEDITIONABLE"]) =>
                {
                    rest = tail;
                }
                _ => break,
            }
        }
        rest
    }

    fn is_transaction_begin_tail(token: &OraclePlSqlToken) -> bool {
        token.is_semicolon() || token.is_any_word(&["TRANSACTION", "WORK"])
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum OraclePlSqlCreateObjectKind {
    Spec,
    Body,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum OraclePlSqlScope {
    Object,
    /// DECLARE section awaiting its own BEGIN.
    Declaration,
    /// Local PROCEDURE/FUNCTION header, before IS/AS (a `;` here is a forward declaration).
    RoutineHeader,
    /// Local PROCEDURE/FUNCTION after IS/AS, awaiting its own BEGIN.
    Routine,
    Block,
    Case,
}

impl OraclePlSqlToken {
    fn word(value: String) -> Self {
        Self::Word(value)
    }

    fn from_sqlparser_token(token: Token) -> Option<Self> {
        match token {
            Token::Word(word) if word.quote_style.is_none() => Some(Self::Word(word.value.to_ascii_uppercase())),
            Token::Word(_) => Some(Self::QuotedIdentifier),
            Token::SemiColon => Some(Self::Semicolon),
            Token::Whitespace(_) | Token::Placeholder(_) => None,
            _ => Some(Self::Other),
        }
    }

    fn is_word(&self, expected: &str) -> bool {
        matches!(self, Self::Word(value) if value == expected)
    }

    fn as_word(&self) -> Option<&str> {
        match self {
            Self::Word(value) => Some(value),
            Self::QuotedIdentifier | Self::Semicolon | Self::Other => None,
        }
    }

    fn is_any_word(&self, expected: &[&str]) -> bool {
        expected.iter().any(|word| self.is_word(word))
    }

    fn is_semicolon(&self) -> bool {
        matches!(self, Self::Semicolon)
    }
}

/// Word immediately before `index` in the token stream (no skipping punctuation).
/// Used for `END CASE` / `END IF` pairing so `end ), (case` is not treated as `END CASE`.
fn previous_adjacent_word(tokens: &[OraclePlSqlToken], index: usize) -> Option<&str> {
    index.checked_sub(1).and_then(|previous| tokens.get(previous)).and_then(OraclePlSqlToken::as_word)
}

fn next_adjacent_word(tokens: &[OraclePlSqlToken], index: usize) -> Option<&str> {
    tokens.get(index + 1).and_then(OraclePlSqlToken::as_word)
}

fn push_other_token(tokens: &mut Vec<OraclePlSqlToken>) {
    if tokens.last() != Some(&OraclePlSqlToken::Other) {
        tokens.push(OraclePlSqlToken::Other);
    }
}

fn oracle_plsql_tokens(sql: &str) -> Vec<OraclePlSqlToken> {
    let dialect = OracleDialect {};
    if let Ok(tokens) = Tokenizer::new(&dialect, sql).tokenize() {
        let mut out = Vec::new();
        for token in tokens {
            if let Some(mapped) = OraclePlSqlToken::from_sqlparser_token(token) {
                if mapped == OraclePlSqlToken::Other {
                    push_other_token(&mut out);
                } else {
                    out.push(mapped);
                }
            }
        }
        return out;
    }

    oracle_plsql_tokens_fallback(sql)
}

fn oracle_plsql_tokens_fallback(sql: &str) -> Vec<OraclePlSqlToken> {
    let mut tokens = Vec::new();
    let mut iter = sql.char_indices().peekable();

    while let Some((_, ch)) = iter.next() {
        if ch.is_whitespace() {
            continue;
        }

        if ch == '-' && iter.peek().is_some_and(|(_, next)| *next == '-') {
            iter.next();
            for (_, comment_ch) in iter.by_ref() {
                if comment_ch == '\n' {
                    break;
                }
            }
            continue;
        }

        if ch == '/' && iter.peek().is_some_and(|(_, next)| *next == '*') {
            iter.next();
            let mut previous = '\0';
            for (_, comment_ch) in iter.by_ref() {
                if previous == '*' && comment_ch == '/' {
                    break;
                }
                previous = comment_ch;
            }
            continue;
        }

        if ch == '\'' {
            while let Some((_, quote_ch)) = iter.next() {
                if quote_ch == '\'' {
                    if iter.peek().is_some_and(|(_, next)| *next == '\'') {
                        iter.next();
                    } else {
                        break;
                    }
                }
            }
            // String literals separate keywords the same way punctuation does.
            push_other_token(&mut tokens);
            continue;
        }

        if ch == '"' {
            for (_, ident_ch) in iter.by_ref() {
                if ident_ch == '"' {
                    break;
                }
            }
            tokens.push(OraclePlSqlToken::QuotedIdentifier);
            continue;
        }

        if ch == ';' {
            tokens.push(OraclePlSqlToken::Semicolon);
            continue;
        }

        if ch.is_ascii_alphabetic() || ch == '_' {
            let mut token = String::new();
            token.push(ch.to_ascii_uppercase());
            while let Some((_, next)) = iter.peek().copied() {
                if next.is_ascii_alphanumeric() || next == '_' || next == '$' || next == '#' {
                    token.push(next.to_ascii_uppercase());
                    iter.next();
                } else {
                    break;
                }
            }
            tokens.push(OraclePlSqlToken::word(token));
            continue;
        }

        push_other_token(&mut tokens);
    }

    tokens
}

fn starts_with_chars(chars: &[char], start: usize, needle: &[char]) -> bool {
    start + needle.len() <= chars.len() && chars[start..start + needle.len()] == *needle
}

fn dollar_quote_tag_at(chars: &[char], start: usize) -> Option<String> {
    if chars.get(start) != Some(&'$') {
        return None;
    }

    match chars.get(start + 1) {
        Some('$') => return Some("$$".to_string()),
        Some(ch) if ch.is_ascii_alphabetic() || *ch == '_' => {}
        _ => return None,
    }

    let mut end = start + 2;
    while let Some(ch) = chars.get(end) {
        if *ch == '$' {
            return Some(chars[start..=end].iter().collect());
        }
        if !ch.is_ascii_alphanumeric() && *ch != '_' {
            return None;
        }
        end += 1;
    }

    None
}

pub fn has_executable_sql(statement: &str) -> bool {
    has_executable_sql_with_options(statement, SqlParsingOptions::default())
}

pub fn has_executable_sql_for_database(statement: &str, db_type: DatabaseType) -> bool {
    has_executable_sql_with_options(statement, SqlParsingOptions::for_database_type(db_type))
}

fn executable_sql_bounds(statement: &str, options: SqlParsingOptions) -> Option<(usize, usize)> {
    let trimmed_end = statement.trim_end().len();
    let trimmed = &statement[..trimmed_end];
    let executable = leading_executable_sql_with_options(trimmed, options);
    if executable.is_empty() {
        return None;
    }
    let executable_start = trimmed.len() - executable.len();
    let start = if options.profile.preserves_tdsql_leading_directives {
        crate::tdsql_mysql::leading_directive_start(trimmed, executable_start).unwrap_or(executable_start)
    } else {
        executable_start
    };
    Some((start, trimmed_end))
}

fn has_executable_sql_with_options(statement: &str, options: SqlParsingOptions) -> bool {
    let chars = statement.chars().collect::<Vec<_>>();
    let mut in_line_comment = false;
    let mut block_comment_depth = 0usize;
    let mut previous = None;
    let mut i = 0;

    while i < chars.len() {
        let ch = chars[i];
        let next = chars.get(i + 1).copied();

        if in_line_comment {
            if ch == '\n' {
                in_line_comment = false;
            }
            previous = Some(ch);
            i += 1;
            continue;
        }

        if block_comment_depth > 0 {
            if options.profile.supports_nested_block_comments && previous == Some('/') && ch == '*' {
                block_comment_depth += 1;
                // A nested opener's asterisk must not pair with a following slash as a close.
                previous = None;
                i += 1;
                continue;
            } else if previous == Some('*') && ch == '/' {
                block_comment_depth -= 1;
            }
            previous = Some(ch);
            i += 1;
            continue;
        }

        if ch == '-' && next == Some('-') && dash_dash_starts_line_comment(options.profile, chars.get(i + 2).copied()) {
            in_line_comment = true;
            previous = Some(ch);
            i += 1;
            continue;
        }

        if options.profile.supports_hash_line_comments && ch == '#' {
            in_line_comment = true;
            previous = Some(ch);
            i += 1;
            continue;
        }

        if ch == '/' && next == Some('*') {
            if is_mysql_executable_comment_start(&chars, i) {
                return true;
            }
            block_comment_depth = 1;
            // The opener's own asterisk must not read as a nested opener.
            previous = None;
            i += 1;
            continue;
        }

        if !ch.is_whitespace() {
            return true;
        }

        previous = Some(ch);
        i += 1;
    }

    false
}

fn is_mysql_executable_comment_start(chars: &[char], start: usize) -> bool {
    chars.get(start) == Some(&'/')
        && chars.get(start + 1) == Some(&'*')
        && (chars.get(start + 2) == Some(&'!')
            || (chars.get(start + 2) == Some(&'M') && chars.get(start + 3) == Some(&'!')))
}

#[cfg(test)]
fn split_sql_script(sql: &str) -> Result<Vec<String>, String> {
    Ok(split_sql_statements(sql))
}

#[cfg(test)]
mod tests {
    use crate::models::connection::DatabaseType;

    use super::{
        contains_or_fuzzy_match, dash_dash_starts_line_comment, decode_sql_file_bytes,
        find_statement_at_cursor_for_database, fuzzy_filter_enabled, fuzzy_like_pattern_with_escape,
        fuzzy_subsequence_match, optimize_sql_file_import_statements, prepare_sql_file_statement, split_sql_script,
        split_sql_statement_ranges_with_options, split_sql_statements_for_database, starts_with_executable_sql_keyword,
        starts_with_executable_sql_keyword_for_database, starts_with_oracle_style_routine_body, SqlDialectProfile,
        SqlFileRequest, SqlFileStatementAction, SqlParsingOptions, SqlStatementSplitter,
    };

    #[test]
    fn file_directive_boundaries_use_the_dialect_line_comment_rule() {
        let mut mysql = SqlStatementSplitter::with_options(SqlParsingOptions::for_database_type(DatabaseType::Mysql));
        mysql.push_chunk("--foo\n");
        assert!(!mysql.is_at_file_directive_boundary());
        let mut sqlite = SqlStatementSplitter::with_options(SqlParsingOptions::for_database_type(DatabaseType::Sqlite));
        sqlite.push_chunk("--foo\n");
        assert!(sqlite.is_at_file_directive_boundary());
        let mut mysql_comment =
            SqlStatementSplitter::with_options(SqlParsingOptions::for_database_type(DatabaseType::Mysql));
        mysql_comment.push_chunk("-- real comment\n");
        assert!(mysql_comment.is_at_file_directive_boundary());
    }

    #[test]
    fn sql_file_request_keeps_failure_logging_on_when_the_field_is_absent() {
        // Older frontends never send the flag; their imports must keep writing
        // the failure log (dbx#11619), so the serde default is "enabled".
        let base = serde_json::json!({
            "executionId": "exec-1",
            "connectionId": "conn-1",
            "database": "shop",
            "filePath": "/tmp/dump.sql",
            "continueOnError": false
        });
        let legacy: SqlFileRequest = serde_json::from_value(base.clone()).unwrap();
        assert!(legacy.failure_log_enabled);

        let mut explicit_off = base;
        explicit_off["failureLogEnabled"] = serde_json::Value::Bool(false);
        let disabled: SqlFileRequest = serde_json::from_value(explicit_off).unwrap();
        assert!(!disabled.failure_log_enabled);
    }

    #[test]
    fn sql_file_request_schema_is_optional_and_round_trips_when_present() {
        let legacy = serde_json::json!({
            "executionId": "legacy",
            "connectionId": "mysql-1",
            "database": "app",
            "filePath": "backup.sql",
            "continueOnError": false
        });
        let legacy_request: SqlFileRequest = serde_json::from_value(legacy).unwrap();
        assert_eq!(legacy_request.schema, None);
        assert!(serde_json::to_value(&legacy_request).unwrap().get("schema").is_none());

        let with_schema = serde_json::json!({
            "executionId": "oracle-schema",
            "connectionId": "oceanbase-oracle-1",
            "database": "tenant_service",
            "schema": "APP",
            "filePath": "restore.sql",
            "continueOnError": false
        });
        let request: SqlFileRequest = serde_json::from_value(with_schema).unwrap();
        assert_eq!(request.database, "tenant_service");
        assert_eq!(request.schema.as_deref(), Some("APP"));
        assert_eq!(serde_json::to_value(request).unwrap()["schema"], "APP");
    }

    #[test]
    fn fuzzy_subsequence_match_matches_ordered_characters() {
        assert!(fuzzy_subsequence_match("system_user", "sysu"));
        assert!(contains_or_fuzzy_match("user_order", "uo"));
        assert!(!contains_or_fuzzy_match("alpha", "uo"));
    }

    #[test]
    fn contains_or_fuzzy_match_skips_fuzzy_for_single_character_filters() {
        assert!(fuzzy_filter_enabled("uo"));
        assert!(!fuzzy_filter_enabled("u"));
        assert!(contains_or_fuzzy_match("user_order", "u"));
        assert!(!contains_or_fuzzy_match("orders", "u"));
    }

    #[test]
    fn fuzzy_like_pattern_with_escape_keeps_wildcards_literal() {
        let pattern = fuzzy_like_pattern_with_escape("user_%", |value| value.replace('%', "\\%").replace('_', "\\_"));

        assert_eq!(pattern, "%u%s%e%r%\\_%\\%%");
    }

    #[test]
    fn splits_semicolon_delimited_statements() {
        assert_eq!(
            split_sql_script("CREATE TABLE a(id int); INSERT INTO a VALUES (1);").unwrap(),
            vec!["CREATE TABLE a(id int)", "INSERT INTO a VALUES (1)"]
        );
    }

    #[test]
    fn keeps_mybatis_comparison_entity_semicolons_inside_one_statement() {
        // Issue #11699: the `;` of `&gt;`/`&lt;`/`&#39;` closes an XML entity,
        // not the statement.
        let sql = "select * from course_user cu\nwhere cu.is_delete = 0\nand cu.create_time &gt;= #{param.startDateTime}\nand cu.create_time &lt;= #{param.endDateTime}\ngroup by cu.dept_id";

        assert_eq!(split_sql_statements_for_database(sql, DatabaseType::Mysql), vec![sql.to_string()]);
        assert_eq!(
            split_sql_statements_for_database("SELECT a FROM t WHERE b &gt;= 1;\nSELECT 2;", DatabaseType::Mysql),
            vec!["SELECT a FROM t WHERE b &gt;= 1".to_string(), "SELECT 2".to_string()]
        );
        // A bitwise AND before a real terminator must still split.
        assert_eq!(
            split_sql_statements_for_database("SELECT a FROM t WHERE a&b;", DatabaseType::Mysql),
            vec!["SELECT a FROM t WHERE a&b".to_string()]
        );
        // Numeric character references and quoted entities stay intact too.
        assert_eq!(
            split_sql_statements_for_database("SELECT 'Tom &amp; Jerry' AS n;\nSELECT 2;", DatabaseType::Mysql),
            vec!["SELECT 'Tom &amp; Jerry' AS n".to_string(), "SELECT 2".to_string()]
        );
        // Numeric character references: MySQL-family dialects read a bare `#` as a
        // line comment, so exercise this on SQL Server (whose `#` is an identifier
        // marker) where `&#39;` reaches the splitter as code.
        assert_eq!(
            split_sql_statements_for_database("SELECT &#39; AS q;\nSELECT 2;", DatabaseType::SqlServer),
            vec!["SELECT &#39; AS q".to_string(), "SELECT 2".to_string()]
        );
    }

    #[test]
    fn keeps_postgres_e_string_newlines_inside_batch_statement() {
        let sql = "SELECT version();\n\nCREATE TABLE dbx_test (\n    delimiter VARCHAR(32) DEFAULT E'\\n\\n'\n);";

        assert_eq!(
            split_sql_statements_for_database(sql, DatabaseType::Postgres),
            vec![
                "SELECT version()".to_string(),
                "CREATE TABLE dbx_test (\n    delimiter VARCHAR(32) DEFAULT E'\\n\\n'\n)".to_string(),
            ]
        );

        assert_eq!(
            split_sql_statement_ranges_with_options(sql, SqlParsingOptions::for_database_type(DatabaseType::Postgres))
                .into_iter()
                .map(|range| range.text)
                .collect::<Vec<_>>(),
            vec![
                "SELECT version()".to_string(),
                "CREATE TABLE dbx_test (\n    delimiter VARCHAR(32) DEFAULT E'\\n\\n'\n)".to_string(),
            ]
        );
    }

    #[test]
    fn delimiter_line_after_unterminated_statement_merges() {
        // A DELIMITER line is only honored as a client directive when no executable
        // SQL is pending, so an unterminated statement swallows the line instead of
        // splitting off and switching the delimiter.
        let sql = "SELECT 1\nDELIMITER $$";

        assert_eq!(
            split_sql_statements_for_database(sql, DatabaseType::Postgres),
            vec!["SELECT 1\nDELIMITER $$".to_string()]
        );

        assert_eq!(
            split_sql_statement_ranges_with_options(sql, SqlParsingOptions::for_database_type(DatabaseType::Postgres))
                .into_iter()
                .map(|range| range.text)
                .collect::<Vec<_>>(),
            vec!["SELECT 1\nDELIMITER $$".to_string()]
        );

        let sql = "SELECT 1\nDELIMITER $$\nSELECT 2$$";

        assert_eq!(
            split_sql_statements_for_database(sql, DatabaseType::Postgres),
            vec!["SELECT 1\nDELIMITER $$\nSELECT 2$$".to_string()]
        );

        assert_eq!(
            split_sql_statement_ranges_with_options(sql, SqlParsingOptions::for_database_type(DatabaseType::Postgres))
                .into_iter()
                .map(|range| range.text)
                .collect::<Vec<_>>(),
            vec!["SELECT 1\nDELIMITER $$\nSELECT 2$$".to_string()]
        );
    }

    #[test]
    fn mysql_split_skips_comment_only_statement() {
        assert!(split_sql_statements_for_database("-- DBX SQL preview crash reproducer\n\n;", DatabaseType::Mysql)
            .is_empty());
    }

    #[test]
    fn mysql_dash_dash_without_trailing_space_is_not_a_comment_per_issue_5382() {
        // MySQL requires `--` to be followed by whitespace to start a line comment;
        // `5--1` is subtraction (5 - -1), not a comment.
        assert_eq!(split_sql_statements_for_database("SELECT 5--1;", DatabaseType::Mysql), vec!["SELECT 5--1"]);
    }

    #[test]
    fn mysql_dash_dash_without_trailing_space_does_not_merge_following_statements_per_issue_5382() {
        let statements = split_sql_statements_for_database(
            "INSERT INTO t VALUES (1, 5--1);\nINSERT INTO t VALUES (2, 10);",
            DatabaseType::Mysql,
        );
        assert_eq!(statements, vec!["INSERT INTO t VALUES (1, 5--1)", "INSERT INTO t VALUES (2, 10)"]);
    }

    #[test]
    fn mysql_dash_dash_with_trailing_space_still_starts_a_line_comment() {
        // The comment text itself is preserved verbatim in the following statement's
        // buffer (comments are never stripped, just protected from delimiter parsing) —
        // this only asserts the embedded `;` inside the comment doesn't split early.
        let statements = split_sql_statements_for_database(
            "INSERT INTO t VALUES (1); -- trailing comment; with semicolon\nINSERT INTO t VALUES (2);",
            DatabaseType::Mysql,
        );
        assert_eq!(
            statements,
            vec!["INSERT INTO t VALUES (1)", "-- trailing comment; with semicolon\nINSERT INTO t VALUES (2)"]
        );
    }

    #[test]
    fn dash_dash_requires_space_only_for_mysql_compatible_profiles() {
        let mysql_profile = SqlDialectProfile::for_database_type(DatabaseType::Mysql);
        assert!(dash_dash_starts_line_comment(mysql_profile, Some(' ')));
        assert!(dash_dash_starts_line_comment(mysql_profile, Some('\n')));
        assert!(dash_dash_starts_line_comment(mysql_profile, Some('\u{1}')));
        assert!(dash_dash_starts_line_comment(mysql_profile, None));
        assert!(!dash_dash_starts_line_comment(mysql_profile, Some('1')));

        // Postgres, Oracle/DM, SQL Server, ... treat `--` as a comment opener unconditionally.
        let default_profile = SqlDialectProfile::default();
        assert!(dash_dash_starts_line_comment(default_profile, Some('1')));
        assert!(dash_dash_starts_line_comment(default_profile, None));
    }

    #[test]
    fn mysql_dash_dash_opener_without_space_can_span_chunks() {
        let mut splitter = SqlStatementSplitter::with_options(SqlParsingOptions::mysql_compatible());

        assert_eq!(splitter.push_chunk("SELECT 5-"), Vec::<String>::new());
        assert_eq!(splitter.push_chunk("-1;"), vec!["SELECT 5--1"]);
        assert_eq!(splitter.finish(), Vec::<String>::new());
    }

    #[test]
    fn mysql_complete_dash_dash_sequence_waits_for_the_next_chunk() {
        let mut splitter = SqlStatementSplitter::with_options(SqlParsingOptions::mysql_compatible());

        assert_eq!(splitter.push_chunk("SELECT 5--"), Vec::<String>::new());
        assert_eq!(splitter.push_chunk("1;\nSELECT 2;"), vec!["SELECT 5--1", "SELECT 2"]);
        assert_eq!(splitter.finish(), Vec::<String>::new());
    }

    #[test]
    fn mysql_control_character_after_dashes_starts_a_line_comment() {
        let statements = split_sql_statements_for_database("SELECT 1--\u{1}; hidden\nSELECT 2;", DatabaseType::Mysql);

        assert_eq!(statements, vec!["SELECT 1--\u{1}; hidden\nSELECT 2"]);
    }

    #[test]
    fn mysql_keyword_detection_skips_comment_only_input() {
        assert!(!starts_with_executable_sql_keyword_for_database(
            "-- DBX SQL preview crash reproducer\n\n",
            &["SELECT"],
            DatabaseType::Mysql,
        ));
    }

    #[test]
    fn decodes_utf8_bom_sql_file_bytes_without_bom_statement_prefix() {
        let sql = decode_sql_file_bytes(b"\xEF\xBB\xBFCREATE TABLE t(id int);").unwrap();

        assert_eq!(sql, "CREATE TABLE t(id int);");
    }

    #[test]
    fn decodes_gbk_sql_file_bytes_before_execution() {
        let bytes = b"INSERT INTO t VALUES ('\xD6\xD0\xCE\xC4');";
        let sql = decode_sql_file_bytes(bytes).unwrap();

        assert_eq!(sql, "INSERT INTO t VALUES ('中文');");
    }

    #[test]
    fn decodes_utf16le_bom_sql_file_bytes() {
        let bytes = [
            0xFF, 0xFE, b'S', 0x00, b'E', 0x00, b'L', 0x00, b'E', 0x00, b'C', 0x00, b'T', 0x00, b' ', 0x00, b'1', 0x00,
            b';', 0x00,
        ];
        let sql = decode_sql_file_bytes(&bytes).unwrap();

        assert_eq!(sql, "SELECT 1;");
    }

    #[test]
    fn ignores_semicolons_inside_quotes_and_comments() {
        let sql = "\
            INSERT INTO logs VALUES ('a;b', \"c;d\", `weird;name`);\n\
            -- comment ; ignored\n\
            /* block ; ignored */\n\
            SELECT 1;";
        assert_eq!(
            split_sql_script(sql).unwrap(),
            vec![
                "INSERT INTO logs VALUES ('a;b', \"c;d\", `weird;name`)",
                "-- comment ; ignored\n/* block ; ignored */\nSELECT 1",
            ]
        );
    }

    #[test]
    fn closes_mysql_string_after_even_trailing_backslashes() {
        let sql = r#"CREATE TABLE paths (value varchar(100) COMMENT 'Windows path\\'); DROP TABLE paths;"#;

        assert_eq!(
            split_sql_statements_for_database(sql, DatabaseType::Mysql),
            vec![r#"CREATE TABLE paths (value varchar(100) COMMENT 'Windows path\\')"#, "DROP TABLE paths"]
        );
    }

    #[test]
    fn cursor_statement_closes_mysql_string_after_escaped_backslash() {
        let sql = "SELECT 'a\\\\';\nSELECT 2;";
        let cursor = sql.find("SELECT 2").unwrap() + 3;
        assert_eq!(find_statement_at_cursor_for_database(sql, cursor, DatabaseType::Mysql), "SELECT 2");
        assert_eq!(find_statement_at_cursor_for_database(sql, 3, DatabaseType::Mysql), "SELECT 'a\\\\'");
    }

    #[test]
    fn cursor_statement_treats_mysql_dash_dash_without_space_as_minus() {
        let sql = "SELECT 5--1;\nSELECT 2;";
        let cursor = sql.find("SELECT 2").unwrap() + 3;
        assert_eq!(find_statement_at_cursor_for_database(sql, cursor, DatabaseType::Mysql), "SELECT 2");
        assert_eq!(find_statement_at_cursor_for_database(sql, 3, DatabaseType::Mysql), "SELECT 5--1");
    }

    #[test]
    fn keeps_mysql_string_open_after_odd_trailing_backslashes() {
        let sql = r#"INSERT INTO notes VALUES ('it\'s; still one value'); SELECT 1;"#;

        assert_eq!(
            split_sql_statements_for_database(sql, DatabaseType::Mysql),
            vec![r#"INSERT INTO notes VALUES ('it\'s; still one value')"#, "SELECT 1"]
        );
    }

    #[test]
    fn closes_mysql_string_after_even_trailing_backslashes_across_chunks() {
        let mut splitter =
            SqlStatementSplitter::with_options(SqlParsingOptions::for_database_type(DatabaseType::Mysql));

        assert!(splitter.push_chunk("CREATE TABLE paths (value varchar(100) COMMENT 'Windows path\\").is_empty());
        assert_eq!(
            splitter.push_chunk("\\'); DROP TABLE paths;"),
            vec![r#"CREATE TABLE paths (value varchar(100) COMMENT 'Windows path\\')"#, "DROP TABLE paths"]
        );
        assert!(splitter.finish().is_empty());
    }

    #[test]
    fn postgres_plain_string_ends_before_a_trailing_backslash() {
        let sql = r#"SELECT 'dir\'; DELETE FROM users;"#;

        assert_eq!(
            split_sql_statements_for_database(sql, DatabaseType::Postgres),
            vec![r#"SELECT 'dir\'"#, "DELETE FROM users"]
        );
    }

    #[test]
    fn vastbase_plain_string_ends_before_a_trailing_backslash() {
        let sql = r#"SELECT 'dir\'; DELETE FROM users;"#;

        assert_eq!(
            split_sql_statements_for_database(sql, DatabaseType::Vastbase),
            vec![r#"SELECT 'dir\'"#, "DELETE FROM users"]
        );
    }

    #[test]
    fn vastbase_escape_string_keeps_a_backslash_escaped_quote() {
        let sql = r#"COMMENT ON COLUMN "s"."t"."c" IS E'C:\\tmp\n\t\'';"#;

        assert_eq!(
            split_sql_statements_for_database(sql, DatabaseType::Vastbase),
            vec![r#"COMMENT ON COLUMN "s"."t"."c" IS E'C:\\tmp\n\t\''"#]
        );
    }

    #[test]
    fn duckdb_escape_strings_match_the_existing_expectations() {
        let sql = r#"SELECT E'it\'s;ok'; SELECT e'path\\;name'; SELECT 2"#;

        assert_eq!(
            split_sql_statements_for_database(sql, DatabaseType::DuckDb),
            vec![r#"SELECT E'it\'s;ok'"#, r#"SELECT e'path\\;name'"#, "SELECT 2"]
        );
    }

    #[test]
    fn duckdb_plain_strings_keep_windows_paths_and_following_statements_separate() {
        let sql = r#"SET VARIABLE path = 'C:\path\'; SET VARIABLE next = 'value'; SELECT 1;"#;

        assert_eq!(
            split_sql_statements_for_database(sql, DatabaseType::DuckDb),
            vec![r#"SET VARIABLE path = 'C:\path\'"#, "SET VARIABLE next = 'value'", "SELECT 1"]
        );
    }

    #[test]
    fn postgres_escape_string_keeps_a_backslash_escaped_quote() {
        let sql = r#"SELECT E'it\'s; still one value'; SELECT 1;"#;

        assert_eq!(
            split_sql_statements_for_database(sql, DatabaseType::Postgres),
            vec![r#"SELECT E'it\'s; still one value'"#, "SELECT 1"]
        );
    }

    #[test]
    fn cursor_statement_keeps_postgres_delete_after_a_trailing_backslash() {
        let sql = "SELECT 'dir\\';\nDELETE FROM users;";
        let cursor = sql.find("DELETE FROM users").unwrap() + 3;

        assert_eq!(find_statement_at_cursor_for_database(sql, cursor, DatabaseType::Postgres), "DELETE FROM users");
    }

    #[test]
    fn cursor_statement_keeps_postgres_escape_string_quote_together() {
        let sql = "SELECT E'it\\'s; x';\nSELECT 2;";
        let cursor = sql.find("SELECT 2").unwrap() + 3;

        assert_eq!(find_statement_at_cursor_for_database(sql, cursor, DatabaseType::Postgres), "SELECT 2");
        assert_eq!(find_statement_at_cursor_for_database(sql, 3, DatabaseType::Postgres), r#"SELECT E'it\'s; x'"#);
    }

    #[test]
    fn postgres_nested_block_comments_keep_commented_out_statements_out() {
        // The inner comment closes first, so without nesting the UPDATE behind the
        // semicolon becomes a statement of its own and reaches the executor.
        let sql = "/* a\n/* b */ ;\nUPDATE prod.orders SET paid = 0;\n*/\nSELECT 1;";
        let statements = split_sql_statements_for_database(sql, DatabaseType::Postgres);

        assert!(!statements.iter().any(|statement| statement.starts_with("UPDATE")), "{statements:?}");
        assert!(statements.iter().any(|statement| statement.contains("SELECT 1")), "{statements:?}");
    }

    #[test]
    fn sqlserver_nested_block_comments_keep_commented_out_statements_out() {
        let sql = "/* a\n/* b */ ;\nUPDATE prod.orders SET paid = 0;\n*/\nSELECT 1;";
        let statements = split_sql_statements_for_database(sql, DatabaseType::SqlServer);

        assert!(!statements.iter().any(|statement| statement.starts_with("UPDATE")), "{statements:?}");
        assert!(statements.iter().any(|statement| statement.contains("SELECT 1")), "{statements:?}");
    }

    #[test]
    fn nested_opener_slash_asterisk_slash_does_not_close_the_comment() {
        // The lexer consumes `/*` atomically, so the `/` right after a nested opener
        // is literal text and must not pair with the preceding `*` to close it.
        let sql = "/* /*/ */ SELECT 1;";
        let statements = split_sql_statements_for_database(sql, DatabaseType::Postgres);

        assert!(!statements.iter().any(|statement| statement.trim_start().starts_with("SELECT")), "{statements:?}");
    }

    #[test]
    fn clickhouse_block_comments_nest() {
        let sql = "/* a\n/* b */ ;\nUPDATE prod.orders SET paid = 0;\n*/\nSELECT 1;";
        let statements = split_sql_statements_for_database(sql, DatabaseType::ClickHouse);

        assert!(!statements.iter().any(|statement| statement.starts_with("UPDATE")), "{statements:?}");
        assert!(statements.iter().any(|statement| statement.contains("SELECT 1")), "{statements:?}");
    }

    #[test]
    fn mysql_block_comments_do_not_nest() {
        let sql = "/* a /* b */ SELECT 1; SELECT 2;";

        // MySQL documents that block comments do not nest, so the inner `*/` ends
        // the comment and the statements behind it stay separate.
        assert_eq!(
            split_sql_statements_for_database(sql, DatabaseType::Mysql),
            vec!["/* a /* b */ SELECT 1", "SELECT 2"]
        );
    }

    #[test]
    fn cursor_statement_ignores_statements_inside_a_nested_comment() {
        let sql = "/* a\n/* b */ ;\nUPDATE prod.orders SET paid = 0;\n*/\nSELECT 1;";
        let cursor = sql.find("UPDATE").unwrap() + 3;

        let statement = find_statement_at_cursor_for_database(sql, cursor, DatabaseType::Postgres);
        assert!(!statement.contains("UPDATE prod.orders"), "{statement}");
    }

    #[test]
    fn oracle_alternative_quoting_keeps_apostrophes_and_semicolons_inside_the_literal() {
        let sql = "SELECT q'[it's; still one value]' FROM dual; SELECT 1 FROM dual;";

        assert_eq!(
            split_sql_statements_for_database(sql, DatabaseType::Oracle),
            vec!["SELECT q'[it's; still one value]' FROM dual", "SELECT 1 FROM dual"]
        );
    }

    #[test]
    fn oracle_national_alternative_quoting_preserves_statement_boundaries() {
        for database in [DatabaseType::Oracle, DatabaseType::OceanbaseOracle] {
            let sql = "UPDATE events SET name = nq'{it's; DELETE FROM events; --}'; SELECT 1 FROM dual;";
            assert_eq!(
                split_sql_statements_for_database(sql, database),
                vec!["UPDATE events SET name = nq'{it's; DELETE FROM events; --}'", "SELECT 1 FROM dual"]
            );
            let sql = "UPDATE events SET name = nq'[a'b]'; DELETE FROM events; --'";
            assert_eq!(
                split_sql_statements_for_database(sql, database),
                vec!["UPDATE events SET name = nq'[a'b]'", "DELETE FROM events"]
            );
        }
    }

    #[test]
    fn oracle_alternative_quoting_supports_every_delimiter_form() {
        for oracle_literal in [
            "q'{a;b}'",
            "q'(a;b)'",
            "q'<a;b>'",
            "q'!a;b!'",
            "q'Aa;bA'",
            "Q'[i's; x]'",
            "nq'[i's; x]'",
            "NQ'<i's; x>'",
            "nq'!i's; x!'",
            "nQ'(i's; x)'",
        ] {
            let sql = format!("SELECT {oracle_literal} FROM dual; SELECT 1 FROM dual;");

            assert_eq!(
                split_sql_statements_for_database(&sql, DatabaseType::Oracle),
                vec![format!("SELECT {oracle_literal} FROM dual"), "SELECT 1 FROM dual".to_string()],
                "{oracle_literal}"
            );
        }
    }

    #[test]
    fn oracle_alternative_quoting_stays_intact_across_chunk_boundaries() {
        for literal in ["q'[it's; one]'", "nq'{it's; one}'", "NQ'<it's; one>'", "nQ'!it's; one!'"] {
            let statement = format!("UPDATE events SET name = {literal}");
            let sql = format!("{statement}; DELETE FROM events;");
            for boundary in 0..=sql.len() {
                let mut splitter =
                    SqlStatementSplitter::with_options(SqlParsingOptions::for_database_type(DatabaseType::Oracle));
                let mut statements = splitter.push_chunk(&sql[..boundary]);
                statements.extend(splitter.push_chunk(&sql[boundary..]));
                statements.extend(splitter.finish());
                assert_eq!(
                    statements,
                    vec![statement.clone(), "DELETE FROM events".to_string()],
                    "boundary {boundary}"
                );
            }
        }
    }

    #[test]
    fn oracle_alternative_quoting_requires_an_introducer_token() {
        for prefix in ["aq", "anq", "_nq", "column$nq"] {
            let sql = format!("SELECT {prefix}'[a'b]'; DELETE FROM events; --'");
            assert_eq!(split_sql_statements_for_database(&sql, DatabaseType::Oracle), vec![sql]);
        }
    }

    #[test]
    fn non_oracle_dialects_do_not_interpret_national_alternative_quoting() {
        let sql = "SELECT nq'[a'b]'; DELETE FROM events; --'";
        for database in [DatabaseType::Mysql, DatabaseType::Postgres, DatabaseType::Sqlite, DatabaseType::SqlServer] {
            assert_eq!(split_sql_statements_for_database(sql, database), vec![sql]);
        }
    }

    #[test]
    fn oceanbase_oracle_unsupported_quoting_does_not_hide_statement_boundaries() {
        for (sql, expected) in [
            ("UPDATE t SET x=$$;DELETE FROM t;$$", vec!["UPDATE t SET x=$$", "DELETE FROM t", "$$"]),
            ("UPDATE t SET x='a\\'; DELETE FROM t; --'", vec!["UPDATE t SET x='a\\'", "DELETE FROM t"]),
            ("UPDATE t SET x=`a;DELETE FROM t;`", vec!["UPDATE t SET x=`a", "DELETE FROM t", "`"]),
            (
                "DELIMITER $$\nUPDATE t SET x=1; DELETE FROM t;$$",
                vec!["DELIMITER $$\nUPDATE t SET x=1", "DELETE FROM t", "$$"],
            ),
        ] {
            assert_eq!(split_sql_statements_for_database(sql, DatabaseType::OceanbaseOracle), expected, "{sql}");
        }
    }

    #[test]
    fn oceanbase_oracle_cursor_uses_its_own_quote_boundaries() {
        for sql in [
            "UPDATE t SET x=$$; DELETE FROM t;$$",
            "UPDATE t SET x='a\\'; DELETE FROM t; --'",
            "UPDATE t SET x=`a; DELETE FROM t;`",
            "DELIMITER $$\nUPDATE t SET x=1; DELETE FROM t;$$",
        ] {
            let cursor = sql.find("DELETE").unwrap() + 3;
            assert_eq!(
                find_statement_at_cursor_for_database(sql, cursor, DatabaseType::OceanbaseOracle),
                "DELETE FROM t",
                "{sql}"
            );
        }
        for sql in [
            "SELECT 'a\\'\n\n\nUPDATE t SET x=2;",
            "SELECT `x\n\n\nUPDATE t SET x=2;",
            "SELECT $$\n\n\nUPDATE t SET x=2;",
        ] {
            let cursor = sql.find("UPDATE").unwrap() + 3;
            assert_eq!(
                find_statement_at_cursor_for_database(sql, cursor, DatabaseType::OceanbaseOracle),
                "UPDATE t SET x=2",
                "{sql}"
            );
        }
    }

    #[test]
    fn oceanbase_oracle_quote_rules_do_not_change_other_dialects() {
        for database in [DatabaseType::Oracle, DatabaseType::Dameng, DatabaseType::Gaussdb, DatabaseType::Mysql] {
            for sql in ["UPDATE t SET x=$$;DELETE FROM t;$$", "UPDATE t SET x=`a;DELETE FROM t;`"] {
                assert_eq!(split_sql_statements_for_database(sql, database), vec![sql]);
            }
        }
        let statement = "SELECT E'a\\'\n\n\nDELETE FROM t' FROM t";
        let sql = format!("{statement}; SELECT 2;");
        for database in [DatabaseType::Postgres, DatabaseType::Gaussdb] {
            let cursor = sql.find("DELETE").unwrap() + 3;
            assert_eq!(find_statement_at_cursor_for_database(&sql, cursor, database), statement);
        }
    }

    #[test]
    fn dameng_alternative_quoting_matches_oracle() {
        let sql = "SELECT q'[it's; x]' FROM dual; SELECT 1 FROM dual;";

        assert_eq!(
            split_sql_statements_for_database(sql, DatabaseType::Dameng),
            vec!["SELECT q'[it's; x]' FROM dual", "SELECT 1 FROM dual"]
        );
    }

    #[test]
    fn mysql_treats_q_quotes_as_plain_strings() {
        let sql = "SELECT q'[a;b]' FROM t; SELECT 1;";

        assert_eq!(
            split_sql_statements_for_database(sql, DatabaseType::Mysql),
            vec!["SELECT q'[a;b]' FROM t", "SELECT 1"]
        );
    }

    #[test]
    fn cursor_statement_keeps_oracle_alternative_quoting_together() {
        let sql = "SELECT q'[it's; still one value]' FROM dual;\nSELECT 1 FROM dual;";
        let cursor = sql.find("SELECT 1").unwrap() + 3;

        assert_eq!(find_statement_at_cursor_for_database(sql, cursor, DatabaseType::Oracle), "SELECT 1 FROM dual");
    }

    #[test]
    fn oracle_like_cursor_recognizes_blank_line_boundary_after_backslash() {
        let sql = "SELECT 'a\\'\n\n\nUPDATE t SET x=2;";
        for database in [
            DatabaseType::Oracle,
            DatabaseType::OceanbaseOracle,
            DatabaseType::Dameng,
            DatabaseType::Yashandb,
            DatabaseType::Oscar,
        ] {
            let cursor = sql.find("UPDATE").unwrap() + 3;
            assert_eq!(
                find_statement_at_cursor_for_database(sql, cursor, database),
                "UPDATE t SET x=2",
                "{database:?}"
            );
        }
    }

    #[test]
    fn cursor_statement_keeps_national_alternative_quoting_and_blank_lines_together() {
        let statement = "UPDATE events SET name = NQ'<it's;\n\n\nDELETE FROM events; -->' WHERE id = 1";
        let sql = format!("{statement};\nSELECT 1 FROM dual;");
        for database in [DatabaseType::Oracle, DatabaseType::OceanbaseOracle] {
            let cursor = sql.find("DELETE").unwrap() + 3;
            assert_eq!(find_statement_at_cursor_for_database(&sql, cursor, database), statement);
            let cursor = sql.find("SELECT 1").unwrap() + 3;
            assert_eq!(find_statement_at_cursor_for_database(&sql, cursor, database), "SELECT 1 FROM dual");
        }
    }

    #[test]
    fn emits_trailing_statement_without_semicolon() {
        assert_eq!(
            split_sql_script("CREATE TABLE a(id int);\nINSERT INTO a VALUES (1)").unwrap(),
            vec!["CREATE TABLE a(id int)", "INSERT INTO a VALUES (1)"]
        );
    }

    #[test]
    fn line_comment_openers_can_span_chunks() {
        let mut splitter = SqlStatementSplitter::default();

        assert_eq!(splitter.push_chunk("SELECT 1; -"), vec!["SELECT 1"]);
        assert_eq!(splitter.push_chunk("- comment ; ignored\nSELECT 2;"), vec!["-- comment ; ignored\nSELECT 2"]);
        assert_eq!(splitter.finish(), Vec::<String>::new());
    }

    #[test]
    fn block_comment_openers_can_span_chunks() {
        let mut splitter = SqlStatementSplitter::default();

        assert_eq!(splitter.push_chunk("SELECT 1; /"), vec!["SELECT 1"]);
        assert_eq!(splitter.push_chunk("* comment ; ignored */\nSELECT 2;"), vec!["/* comment ; ignored */\nSELECT 2"]);
        assert_eq!(splitter.finish(), Vec::<String>::new());
    }

    #[test]
    fn skips_comment_only_tail_after_statement() {
        assert_eq!(
            split_sql_script("CREATE TABLE a(id int); -- done\n/* no more sql */").unwrap(),
            vec!["CREATE TABLE a(id int)"]
        );
    }

    #[test]
    fn skips_comment_only_statement_with_semicolon() {
        assert_eq!(
            split_sql_script("-- insert sqluser.tb_a values (6,'006','测试6','无');").unwrap(),
            Vec::<String>::new()
        );
        assert!(!super::has_executable_sql("-- insert sqluser.tb_a values (6,'006','测试6','无');"));
    }

    #[test]
    fn keeps_postgres_dollar_quoted_function_body_together() {
        let sql = "\
            CREATE FUNCTION bump_counter()\n\
            RETURNS trigger AS $$\n\
            BEGIN\n\
              PERFORM 1;\n\
              RETURN NEW;\n\
            END;\n\
            $$ LANGUAGE plpgsql;\n\
            SELECT 1;";

        assert_eq!(
            split_sql_script(sql).unwrap(),
            vec![
                "CREATE FUNCTION bump_counter()\nRETURNS trigger AS $$\nBEGIN\nPERFORM 1;\nRETURN NEW;\nEND;\n$$ LANGUAGE plpgsql",
                "SELECT 1",
            ]
        );
    }

    #[test]
    fn keeps_mysql_executable_comments_as_statements() {
        assert_eq!(
            split_sql_script("/*!40101 SET @OLD_CHARACTER_SET_CLIENT=@@CHARACTER_SET_CLIENT */;\nSELECT 1;",).unwrap(),
            vec!["/*!40101 SET @OLD_CHARACTER_SET_CLIENT=@@CHARACTER_SET_CLIENT */", "SELECT 1",]
        );
    }

    #[test]
    fn detects_result_set_keyword_after_comments() {
        assert!(starts_with_executable_sql_keyword("-- comment\nselect * from users;", &["SELECT"]));
        assert!(starts_with_executable_sql_keyword(
            "/* comment */\nWITH rows AS (SELECT 1) SELECT * FROM rows;",
            &["WITH"]
        ));
        assert!(!starts_with_executable_sql_keyword("-- comment only\n", &["SELECT"]));
    }

    #[test]
    fn detects_mysql_executable_comment_keyword() {
        assert!(starts_with_executable_sql_keyword("/*!40101 SELECT 1 */", &["SELECT"]));
        assert!(starts_with_executable_sql_keyword("/*M! SELECT 1 */", &["SELECT"]));
    }

    #[test]
    fn describe_keyword_detection_accepts_desc_shorthand() {
        assert!(starts_with_executable_sql_keyword("DESC users", &["DESCRIBE"]));
        assert!(starts_with_executable_sql_keyword("-- comment\nDESC users", &["DESCRIBE"]));
    }

    #[test]
    fn detects_keyword_after_parentheses() {
        assert!(starts_with_executable_sql_keyword("(SELECT 1)", &["SELECT"]));
        assert!(starts_with_executable_sql_keyword("  (  SELECT 1  )", &["SELECT"]));
        assert!(starts_with_executable_sql_keyword("((SELECT 1))", &["SELECT"]));
        assert!(starts_with_executable_sql_keyword("(SELECT * FROM users)", &["SELECT"]));
        assert!(starts_with_executable_sql_keyword("(INSERT INTO users VALUES (1))", &["INSERT"]));
        assert!(starts_with_executable_sql_keyword("/* comment */(UPDATE users SET name = 'test')", &["UPDATE"]));
    }

    #[test]
    fn mysql_hash_comments_are_ignored_for_keyword_detection() {
        assert!(starts_with_executable_sql_keyword_for_database(
            "# comment only for mysql\nSELECT 1",
            &["SELECT"],
            DatabaseType::Mysql
        ));
        assert!(!starts_with_executable_sql_keyword("# comment only for mysql\nSELECT 1", &["SELECT"]));
    }

    #[test]
    fn prepares_mysql_executable_comments_for_mysql_compatible_imports() {
        assert_eq!(
            prepare_sql_file_statement("/*!40101 SET NAMES utf8mb4 */", &DatabaseType::Mysql, None),
            SqlFileStatementAction::Execute("SET NAMES utf8mb4".to_string())
        );
    }

    #[test]
    fn skips_mysql_key_toggle_comments_for_mysql_compatible_imports() {
        assert_eq!(
            prepare_sql_file_statement(" /*!40000 ALTER TABLE `dd_admin` ENABLE KEYS */", &DatabaseType::Mysql, None),
            SqlFileStatementAction::Skip
        );
        assert_eq!(
            prepare_sql_file_statement("/*!40000 ALTER TABLE `dd_admin` DISABLE KEYS */", &DatabaseType::Mysql, None),
            SqlFileStatementAction::Skip
        );
    }

    #[test]
    fn skips_mysql_lock_table_statements_for_mysql_compatible_imports() {
        assert_eq!(
            prepare_sql_file_statement("LOCK TABLES `dd_geo_json` WRITE", &DatabaseType::Mysql, None),
            SqlFileStatementAction::Skip
        );
        assert_eq!(
            prepare_sql_file_statement("UNLOCK TABLES", &DatabaseType::Mysql, None),
            SqlFileStatementAction::Skip
        );
        assert_eq!(
            prepare_sql_file_statement(
                "-- Dumping data for table `dd_geo_json`\nLOCK TABLES `dd_geo_json` WRITE",
                &DatabaseType::Mysql,
                None
            ),
            SqlFileStatementAction::Skip
        );
    }

    #[test]
    fn skips_mysql_session_restore_statements_for_mysql_compatible_imports() {
        assert_eq!(
            prepare_sql_file_statement(
                "/*!40101 SET character_set_client = @saved_cs_client */",
                &DatabaseType::Mysql,
                None
            ),
            SqlFileStatementAction::Skip
        );
        assert_eq!(
            prepare_sql_file_statement("/*!40103 SET TIME_ZONE=@OLD_TIME_ZONE */", &DatabaseType::Mysql, None),
            SqlFileStatementAction::Skip
        );
        assert_eq!(
            prepare_sql_file_statement("SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS", &DatabaseType::Mysql, None),
            SqlFileStatementAction::Skip
        );
        assert_eq!(
            prepare_sql_file_statement(
                "/*!40101 SET @saved_cs_client = @@character_set_client */",
                &DatabaseType::Mysql,
                None
            ),
            SqlFileStatementAction::Execute("SET @saved_cs_client = @@character_set_client".to_string())
        );
    }

    #[test]
    fn skips_mysql_executable_comments_for_non_mysql_imports() {
        assert_eq!(
            prepare_sql_file_statement(
                "/*!40101 SET character_set_client = @saved_cs_client */",
                &DatabaseType::Postgres,
                None
            ),
            SqlFileStatementAction::Skip
        );
    }

    #[test]
    fn prepares_postgres_pg_dump_restrict_guard_with_following_sql() {
        assert_eq!(
            prepare_sql_file_statement(
                "-- PostgreSQL database dump\n\n\\restrict PreICrqH3VX69RwvK06tauVFPoZ3tThfV0y2zIFL2uSfhfNPSu1pWtu1QTudUAc\n\nSET statement_timeout = 0",
                &DatabaseType::Postgres,
                None
            ),
            SqlFileStatementAction::Execute("-- PostgreSQL database dump\n\n\nSET statement_timeout = 0".to_string())
        );
    }

    #[test]
    fn skips_standalone_postgres_pg_dump_unrestrict_guard() {
        assert_eq!(
            prepare_sql_file_statement(
                "--\n-- PostgreSQL database dump complete\n--\n\n\\unrestrict PreICrqH3VX69RwvK06tauVFPoZ3tThfV0y2zIFL2uSfhfNPSu1pWtu1QTudUAc",
                &DatabaseType::Postgres,
                None
            ),
            SqlFileStatementAction::Skip
        );
    }

    #[test]
    fn keeps_other_postgres_psql_commands_unsupported() {
        assert_eq!(
            prepare_sql_file_statement("\\copy users FROM 'users.csv'", &DatabaseType::Postgres, None),
            SqlFileStatementAction::Execute("\\copy users FROM 'users.csv'".to_string())
        );
        assert_eq!(
            prepare_sql_file_statement("\\restrict invalid-key", &DatabaseType::Postgres, None),
            SqlFileStatementAction::Execute("\\restrict invalid-key".to_string())
        );
    }

    #[test]
    fn optimizes_adjacent_postgres_single_row_inserts_into_multi_row_insert() {
        let statements = vec![
            "INSERT INTO users (id, name) VALUES (1, 'Ada')".to_string(),
            "insert into users (id, name) values (2, 'Linus')".to_string(),
            "SELECT 1".to_string(),
        ];

        let optimized = optimize_sql_file_import_statements(&statements, Some(DatabaseType::Postgres), None);

        assert_eq!(optimized.len(), 2);
        assert_eq!(optimized[0].source_statement_count, 2);
        assert_eq!(optimized[0].sql, "INSERT INTO users (id, name) VALUES\n(1, 'Ada'),\n(2, 'Linus')");
        assert_eq!(optimized[1].sql, "SELECT 1");
    }

    #[test]
    fn optimizes_adjacent_oracle_family_inserts_into_insert_all() {
        let statements = vec![
            "Insert into SYS_QUESTION (ID, NAME) values ('001', '市场监管')".to_string(),
            "Insert into SYS_QUESTION (ID, NAME) values ('002', '网络交易')".to_string(),
        ];

        for db_type in [DatabaseType::Oracle, DatabaseType::OceanbaseOracle] {
            let optimized = optimize_sql_file_import_statements(&statements, Some(db_type), None);

            assert_eq!(optimized.len(), 1, "{db_type:?}");
            assert_eq!(optimized[0].source_statement_count, 2, "{db_type:?}");
            assert_eq!(
                optimized[0].sql,
                "INSERT ALL\n\
                 INTO SYS_QUESTION (ID, NAME) VALUES ('001', '市场监管')\n\
                 INTO SYS_QUESTION (ID, NAME) VALUES ('002', '网络交易')\n\
                 SELECT 1 FROM dual",
                "{db_type:?}"
            );
        }
    }

    #[test]
    fn keeps_single_oracle_insert_as_written() {
        let statements = vec!["INSERT INTO users (id) VALUES (1)".to_string()];

        let optimized = optimize_sql_file_import_statements(&statements, Some(DatabaseType::OceanbaseOracle), None);

        assert_eq!(optimized.len(), 1);
        assert_eq!(optimized[0].sql, statements[0]);
    }

    #[test]
    fn keeps_mysql_insert_statements_separate_to_preserve_session_semantics() {
        let statements = vec![
            "INSERT INTO parents (name) VALUES ('first')".to_string(),
            "INSERT INTO parents (name) VALUES ('second')".to_string(),
            "INSERT INTO children (parent_id) VALUES (LAST_INSERT_ID())".to_string(),
        ];

        for (db_type, driver_profile) in
            [(DatabaseType::Mysql, None), (DatabaseType::Jdbc, Some("mariadb")), (DatabaseType::Doris, None)]
        {
            let optimized = optimize_sql_file_import_statements(&statements, Some(db_type), driver_profile);

            assert_eq!(optimized.len(), 3, "{db_type:?}/{driver_profile:?}");
            assert!(
                optimized.iter().all(|statement| statement.source_statement_count == 1),
                "{db_type:?}/{driver_profile:?}"
            );
            assert_eq!(
                optimized.iter().map(|statement| statement.sql.as_str()).collect::<Vec<_>>(),
                statements,
                "{db_type:?}/{driver_profile:?}"
            );
        }
    }

    #[test]
    fn keeps_existing_mysql_multi_row_insert_unchanged() {
        let statements = vec!["INSERT INTO users (id) VALUES (1), (2)".to_string()];

        let optimized = optimize_sql_file_import_statements(&statements, Some(DatabaseType::Mysql), None);

        assert_eq!(optimized.len(), 1);
        assert_eq!(optimized[0].source_statement_count, 1);
        assert_eq!(optimized[0].sql, statements[0]);
    }

    #[test]
    fn keeps_insert_batches_separate_for_different_targets_or_suffixes() {
        let statements = vec![
            "INSERT INTO users (id) VALUES (1)".to_string(),
            "INSERT INTO teams (id) VALUES (1)".to_string(),
            "INSERT INTO users (id) VALUES (2) RETURNING id".to_string(),
        ];

        let optimized = optimize_sql_file_import_statements(&statements, Some(DatabaseType::Postgres), None);

        assert_eq!(optimized.len(), 3);
        assert!(optimized.iter().all(|statement| statement.source_statement_count == 1));
    }

    #[test]
    fn mysql_dump_import_keeps_skips_and_insert_statement_boundaries() {
        let statements = vec![
            "LOCK TABLES `users` WRITE".to_string(),
            "INSERT INTO `users` VALUES (1)".to_string(),
            "INSERT INTO `users` VALUES (2)".to_string(),
            "UNLOCK TABLES".to_string(),
        ];

        let optimized = optimize_sql_file_import_statements(&statements, Some(DatabaseType::Mysql), None);

        assert_eq!(optimized.len(), 4);
        assert_eq!(optimized[0].kind, super::SqlFileImportStatementKind::Skip);
        assert_eq!(optimized[1].source_statement_count, 1);
        assert_eq!(optimized[2].source_statement_count, 1);
        assert_eq!(optimized[3].kind, super::SqlFileImportStatementKind::Skip);
    }

    #[test]
    fn split_batches_by_go() {
        assert_eq!(super::split_sql_batches("SELECT 1\nGO\nSELECT 2"), vec!["SELECT 1", "SELECT 2"]);
    }

    #[test]
    fn split_batches_go_case_insensitive() {
        assert_eq!(
            super::split_sql_batches("SELECT 1\ngo\nSELECT 2\nGo\nSELECT 3"),
            vec!["SELECT 1", "SELECT 2", "SELECT 3"]
        );
    }

    #[test]
    fn split_batches_go_with_surrounding_whitespace() {
        assert_eq!(super::split_sql_batches("SELECT 1\n  GO  \nSELECT 2"), vec!["SELECT 1", "SELECT 2"]);
    }

    #[test]
    fn split_batches_no_go_returns_whole() {
        assert_eq!(
            super::split_sql_batches("DECLARE @x INT = 1;\nSELECT @x;"),
            vec!["DECLARE @x INT = 1;\nSELECT @x;"]
        );
    }

    #[test]
    fn split_batches_skips_empty_batches() {
        assert_eq!(super::split_sql_batches("SELECT 1\nGO\n\nGO\nSELECT 2"), vec!["SELECT 1", "SELECT 2"]);
    }

    #[test]
    fn split_batches_trailing_go() {
        assert_eq!(super::split_sql_batches("SELECT 1\nGO"), vec!["SELECT 1"]);
    }

    #[test]
    fn split_batches_keeps_go_inside_multiline_string() {
        assert_eq!(
            super::split_sql_batches("SELECT 'first line\nGO\nlast line';\nGO\nSELECT 2"),
            vec!["SELECT 'first line\nGO\nlast line';", "SELECT 2"]
        );
    }

    #[test]
    fn split_batches_keeps_go_inside_block_comment() {
        assert_eq!(
            super::split_sql_batches("SELECT 1;\n/*\nGO\n*/\nSELECT 2;\nGO\nSELECT 3;"),
            vec!["SELECT 1;\n/*\nGO\n*/\nSELECT 2;", "SELECT 3;"]
        );
    }

    // --- DELIMITER support ---

    #[test]
    fn delimiter_basic_procedure() {
        let sql = "\
DELIMITER //
CREATE PROCEDURE foo()
BEGIN
  SELECT 1;
  SELECT 2;
END //
DELIMITER ;
SELECT 3;";
        assert_eq!(
            super::split_sql_statements(sql),
            vec!["CREATE PROCEDURE foo()\nBEGIN\n  SELECT 1;\n  SELECT 2;\nEND", "SELECT 3",]
        );
    }

    #[test]
    fn delimiter_no_trailing_newline() {
        let sql = "DELIMITER //\nSELECT 1//";
        assert_eq!(super::split_sql_statements(sql), vec!["SELECT 1"]);
    }

    #[test]
    fn delimiter_no_space_before_delim() {
        let sql = "DELIMITER //\nCREATE PROCEDURE foo() BEGIN SELECT 1; END//\nDELIMITER ;";
        assert_eq!(super::split_sql_statements(sql), vec!["CREATE PROCEDURE foo() BEGIN SELECT 1; END"]);
    }

    #[test]
    fn delimiter_reset_without_whitespace() {
        let sql = "DELIMITER //\nCREATE PROCEDURE foo() BEGIN SELECT 1; END//\nDELIMITER;\nCALL foo();";
        assert_eq!(super::split_sql_statements(sql), vec!["CREATE PROCEDURE foo() BEGIN SELECT 1; END", "CALL foo()"]);
    }

    #[test]
    fn delimiter_case_insensitive() {
        let sql = "delimiter //\nSELECT 1//\ndelimiter ;\nSELECT 2;";
        assert_eq!(super::split_sql_statements(sql), vec!["SELECT 1", "SELECT 2"]);
    }

    #[test]
    fn delimiter_double_dollar() {
        let sql = "DELIMITER $$\nCREATE FUNCTION f() RETURNS INT BEGIN RETURN 1; END $$\nDELIMITER ;";
        assert_eq!(super::split_sql_statements(sql), vec!["CREATE FUNCTION f() RETURNS INT BEGIN RETURN 1; END"]);
    }

    #[test]
    fn delimiter_semicolons_preserved_inside_body() {
        let sql = "\
DELIMITER //
CREATE TRIGGER t BEFORE INSERT ON tbl FOR EACH ROW
BEGIN
  SET NEW.a = 1;
  SET NEW.b = 2;
END //
DELIMITER ;";
        let stmts = super::split_sql_statements(sql);
        assert_eq!(stmts.len(), 1);
        assert!(stmts[0].contains("SET NEW.a = 1;\n  SET NEW.b = 2;"));
    }

    #[test]
    fn delimiter_multiple_statements() {
        let sql = "\
DELIMITER //
CREATE PROCEDURE p1() BEGIN SELECT 1; END //
CREATE PROCEDURE p2() BEGIN SELECT 2; END //
DELIMITER ;";
        assert_eq!(
            super::split_sql_statements(sql),
            vec!["CREATE PROCEDURE p1() BEGIN SELECT 1; END", "CREATE PROCEDURE p2() BEGIN SELECT 2; END",]
        );
    }

    #[test]
    fn delimiter_after_comment_with_chinese() {
        let sql = "\
-- 判断字段是否存在
DELIMITER $$
DROP FUNCTION IF EXISTS isFieldExisting $$
CREATE FUNCTION isFieldExisting(s VARCHAR(100), t VARCHAR(100), f VARCHAR(100))
    RETURNS INT
    RETURN (SELECT COUNT(COLUMN_NAME)
            FROM INFORMATION_SCHEMA.columns
            WHERE TABLE_SCHEMA = s
              AND TABLE_NAME = t
              AND COLUMN_NAME = f)$$
DELIMITER ;";
        let stmts = super::split_sql_statements(sql);
        assert_eq!(stmts.len(), 2);
        assert!(stmts[0].starts_with("DROP FUNCTION"));
        assert!(stmts[1].starts_with("CREATE FUNCTION"));
    }

    #[test]
    fn delimiter_after_ascii_comment() {
        let sql = "\
-- check field existence
DELIMITER $$
SELECT 1 $$
DELIMITER ;";
        assert_eq!(super::split_sql_statements(sql), vec!["SELECT 1"]);
    }

    #[test]
    fn delimiter_after_statement() {
        let sql = "\
SELECT 1;
DELIMITER $$
SELECT 2 $$
DELIMITER ;";
        assert_eq!(super::split_sql_statements(sql), vec!["SELECT 1", "SELECT 2"]);
    }

    #[test]
    fn mysql_routine_without_delimiter_keeps_body_together() {
        let sql = "\
CREATE PROCEDURE p()
BEGIN
  SELECT 1;
  SELECT 2;
END;
SELECT 3;";
        assert_eq!(
            split_sql_statements_for_database(sql, DatabaseType::Mysql),
            vec!["CREATE PROCEDURE p()\nBEGIN\n  SELECT 1;\n  SELECT 2;\nEND", "SELECT 3"]
        );
    }

    #[test]
    fn mysql_routine_without_delimiter_handles_nested_end_suffixes() {
        let sql = "\
CREATE PROCEDURE p()
BEGIN
  IF 1 = 1 THEN
    SELECT 'ok';
  END IF;
END;
SELECT 2;";
        assert_eq!(
            split_sql_statements_for_database(sql, DatabaseType::Mysql),
            vec!["CREATE PROCEDURE p()\nBEGIN\n  IF 1 = 1 THEN\n    SELECT 'ok';\n  END IF;\nEND", "SELECT 2"]
        );
    }

    #[test]
    fn mysql_routine_without_delimiter_handles_loop_end_suffixes() {
        let sql = "\
CREATE PROCEDURE p_loop()
BEGIN
  WHILE 1 = 0 DO
    SELECT 'while; still body';
  END WHILE;
  REPEAT
    SELECT 'repeat; still body';
  UNTIL 1 = 1 END REPEAT;
END;
SELECT 2;";
        assert_eq!(
            split_sql_statements_for_database(sql, DatabaseType::Mysql),
            vec![
                "CREATE PROCEDURE p_loop()\nBEGIN\n  WHILE 1 = 0 DO\n    SELECT 'while; still body';\n  END WHILE;\n  REPEAT\n    SELECT 'repeat; still body';\n  UNTIL 1 = 1 END REPEAT;\nEND",
                "SELECT 2",
            ]
        );
    }

    #[test]
    fn mysql_routine_without_delimiter_handles_case_endings() {
        let expression = "\
CREATE PROCEDURE p_case()
BEGIN
  INSERT INTO audit_log (status_text)
  SELECT CASE WHEN active = 1 THEN 'active' ELSE 'inactive' END;
  DELETE FROM stale_rows WHERE expires_at < NOW();
END;
SELECT 2;";
        assert_eq!(
            split_sql_statements_for_database(expression, DatabaseType::Mysql),
            vec![
                "CREATE PROCEDURE p_case()\nBEGIN\n  INSERT INTO audit_log (status_text)\n  SELECT CASE WHEN active = 1 THEN 'active' ELSE 'inactive' END;\n  DELETE FROM stale_rows WHERE expires_at < NOW();\nEND",
                "SELECT 2",
            ]
        );

        let statement = "\
CREATE PROCEDURE p_case_statement()
BEGIN
  CASE WHEN active = 1 THEN SELECT 1; ELSE SELECT 0; END CASE;
  DELETE FROM stale_rows WHERE expires_at < NOW();
END;
SELECT 2;";
        assert_eq!(
            split_sql_statements_for_database(statement, DatabaseType::Mysql),
            vec![
                "CREATE PROCEDURE p_case_statement()\nBEGIN\n  CASE WHEN active = 1 THEN SELECT 1; ELSE SELECT 0; END CASE;\n  DELETE FROM stale_rows WHERE expires_at < NOW();\nEND",
                "SELECT 2",
            ]
        );
    }

    #[test]
    fn mysql_routine_without_delimiter_closes_nested_case_begin_blocks_in_order() {
        let sql = "\
CREATE PROCEDURE p_nested_case()
BEGIN
  CASE WHEN active = 1 THEN BEGIN SELECT 1; END; ELSE SELECT 0; END CASE;
  DELETE FROM stale_rows WHERE expires_at < NOW();
END;
SELECT 2;";
        assert_eq!(
            split_sql_statements_for_database(sql, DatabaseType::Mysql),
            vec![
                "CREATE PROCEDURE p_nested_case()\nBEGIN\n  CASE WHEN active = 1 THEN BEGIN SELECT 1; END; ELSE SELECT 0; END CASE;\n  DELETE FROM stale_rows WHERE expires_at < NOW();\nEND",
                "SELECT 2",
            ]
        );
    }

    #[test]
    fn mysql_regular_begin_transaction_still_splits_without_delimiter() {
        assert_eq!(
            split_sql_statements_for_database("BEGIN; INSERT INTO t VALUES (1); COMMIT;", DatabaseType::Mysql),
            vec!["BEGIN", "INSERT INTO t VALUES (1)", "COMMIT"]
        );
    }

    #[test]
    fn sql_dialect_profiles_map_database_types_to_parser_capabilities() {
        let default = SqlDialectProfile::default();
        assert!(default.supports_custom_delimiter_commands);
        assert!(default.supports_dollar_quoted_strings);
        assert!(!default.supports_hash_line_comments);
        assert!(default.supports_backslash_escaped_quotes);
        assert!(!default.supports_postgres_escape_strings);
        assert!(!default.supports_oracle_q_quotes);
        assert!(SqlDialectProfile::for_database_type(DatabaseType::Oracle).supports_oracle_q_quotes);
        assert!(SqlDialectProfile::for_database_type(DatabaseType::Dameng).supports_oracle_q_quotes);
        assert!(!default.supports_nested_block_comments);
        assert!(!default.supports_mysql_routine_blocks);
        assert!(!default.supports_oracle_plsql_blocks);
        assert!(!default.supports_oracle_style_routine_bodies);
        assert!(!default.supports_hana_script_blocks);
        assert!(!default.supports_firebird_routine_blocks);
        assert!(!default.supports_slash_line_block_delimiter);
        assert!(!default.supports_go_batch_separator);
        assert!(!default.keeps_sqlserver_module_batch_at_cursor);
        assert!(!default.preserves_tdsql_leading_directives);

        for db_type in [DatabaseType::Postgres, DatabaseType::OpenGauss] {
            let profile = SqlDialectProfile::for_database_type(db_type);
            assert_eq!(profile, SqlDialectProfile::postgres_family());
            assert!(!profile.supports_oracle_plsql_blocks);
            assert!(profile.supports_oracle_style_routine_bodies);
            assert!(profile.supports_postgres_escape_strings);
            assert!(profile.supports_nested_block_comments);
            assert!(!profile.supports_backslash_escaped_quotes);
            assert!(profile.supports_slash_line_block_delimiter);
        }

        let mysql = SqlDialectProfile::for_database_type(DatabaseType::Mysql);
        assert!(mysql.supports_hash_line_comments);
        assert!(mysql.supports_backslash_escaped_quotes);
        assert!(!mysql.supports_nested_block_comments);
        assert!(mysql.supports_mysql_routine_blocks);
        assert!(mysql.preserves_tdsql_leading_directives);
        assert!(SqlDialectProfile::for_database_type(DatabaseType::Doris).supports_hash_line_comments);
        assert!(!SqlDialectProfile::for_database_type(DatabaseType::Doris).preserves_tdsql_leading_directives);
        assert!(SqlDialectProfile::for_database_type(DatabaseType::StarRocks).supports_hash_line_comments);
        assert!(SqlDialectProfile::for_database_type(DatabaseType::ManticoreSearch).supports_hash_line_comments);
        assert!(SqlDialectProfile::for_database_type(DatabaseType::Goldendb).supports_hash_line_comments);
        assert!(SqlDialectProfile::for_database_type(DatabaseType::Gaussdb).supports_postgres_escape_strings);
        assert!(SqlDialectProfile::for_database_type(DatabaseType::SqlServer).supports_nested_block_comments);

        for db_type in [
            DatabaseType::Vastbase,
            DatabaseType::Kingbase,
            DatabaseType::Highgo,
            DatabaseType::Uxdb,
            DatabaseType::Kwdb,
        ] {
            let profile = SqlDialectProfile::for_database_type(db_type);
            assert!(!profile.supports_backslash_escaped_quotes);
            assert!(profile.supports_postgres_escape_strings);
        }

        let duckdb = SqlDialectProfile::for_database_type(DatabaseType::DuckDb);
        assert!(!duckdb.supports_backslash_escaped_quotes);
        assert!(duckdb.supports_postgres_escape_strings);
        assert!(SqlDialectProfile::for_database_type(DatabaseType::ClickHouse).supports_backslash_escaped_quotes);

        for db_type in [
            DatabaseType::Oracle,
            DatabaseType::Dameng,
            DatabaseType::Yashandb,
            DatabaseType::Oscar,
            DatabaseType::OceanbaseOracle,
        ] {
            let profile = SqlDialectProfile::for_database_type(db_type);
            assert!(profile.supports_oracle_q_quotes);
            assert!(!profile.supports_backslash_escaped_quotes);
            assert!(profile.supports_oracle_plsql_blocks);
            assert!(profile.supports_slash_line_block_delimiter);
            assert!(!profile.supports_postgres_dollar_quoted_routines);
        }

        let gaussdb = SqlDialectProfile::for_database_type(DatabaseType::Gaussdb);
        assert_eq!(gaussdb, SqlDialectProfile::gaussdb());
        assert!(gaussdb.supports_oracle_plsql_blocks);
        assert!(gaussdb.supports_slash_line_block_delimiter);
        assert!(gaussdb.supports_postgres_dollar_quoted_routines);

        let sql_server = SqlDialectProfile::for_database_type(DatabaseType::SqlServer);
        assert_eq!(sql_server, SqlDialectProfile::sql_server());
        assert!(sql_server.supports_go_batch_separator);
        assert!(sql_server.keeps_sqlserver_module_batch_at_cursor);

        let sap_hana = SqlDialectProfile::for_database_type(DatabaseType::SapHana);
        assert_eq!(sap_hana, SqlDialectProfile::sap_hana());
        assert!(sap_hana.supports_hana_script_blocks);

        let firebird = SqlDialectProfile::for_database_type(DatabaseType::Firebird);
        assert_eq!(firebird, SqlDialectProfile::firebird());
        assert!(firebird.supports_firebird_routine_blocks);
        assert!(!firebird.supports_backslash_escaped_quotes);

        for db_type in [DatabaseType::Jdbc, DatabaseType::Hive] {
            let profile = SqlDialectProfile::for_database_type(db_type);
            assert!(profile.supports_oracle_style_routine_bodies);
            assert!(!profile.supports_oracle_plsql_blocks);
            assert!(!profile.supports_mysql_routine_blocks);
            assert!(!profile.supports_slash_line_block_delimiter);
            assert!(profile.supports_backslash_escaped_quotes);
        }
    }

    #[test]
    fn sap_hana_split_keeps_do_block_together() {
        let sql = "\
DO
BEGIN
  SELECT 1 AS \"Result\" FROM DUMMY;
END;
SELECT 2 FROM DUMMY;";

        assert_eq!(
            split_sql_statements_for_database(sql, DatabaseType::SapHana),
            vec!["DO\nBEGIN\n  SELECT 1 AS \"Result\" FROM DUMMY;\nEND;", "SELECT 2 FROM DUMMY"]
        );
    }

    #[test]
    fn sap_hana_split_keeps_alter_procedure_body_together() {
        let sql = "ALTER PROCEDURE PUBLIC.P\nLANGUAGE SQLSCRIPT\nSQL SECURITY INVOKER\nAS\nBEGIN\n  DECLARE v INT;\n  SELECT 1 INTO v FROM DUMMY;\nEND;\nSELECT 2 FROM DUMMY;";

        assert_eq!(
            split_sql_statements_for_database(sql, DatabaseType::SapHana),
            vec![
                "ALTER PROCEDURE PUBLIC.P\nLANGUAGE SQLSCRIPT\nSQL SECURITY INVOKER\nAS\nBEGIN\n  DECLARE v INT;\n  SELECT 1 INTO v FROM DUMMY;\nEND;",
                "SELECT 2 FROM DUMMY"
            ]
        );
    }

    #[test]
    fn sap_hana_split_keeps_nested_case_group_by_inside_procedure_together() {
        let sql = "ALTER PROCEDURE PUBLIC.P\nLANGUAGE SQLSCRIPT\nSQL SECURITY INVOKER\nAS\nBEGIN\n  T = SELECT 1 FROM DUMMY\n  GROUP BY\n    CASE WHEN KHLX='老客' THEN CASE WHEN SCYEAR='0000' THEN NULL ELSE SCYEAR END ELSE LEFT(CASE WHEN SCDAT_OLD='00000000' THEN NULL ELSE SCDAT_OLD END,4) END,\n    CASE WHEN KHLX='老客' THEN CASE WHEN SCDAT='00000000' THEN NULL ELSE SCDAT END ELSE (CASE WHEN SCDAT_OLD='00000000' THEN NULL ELSE SCDAT_OLD END)END;\nEND;\nSELECT 2 FROM DUMMY;";

        assert_eq!(
            split_sql_statements_for_database(sql, DatabaseType::SapHana),
            vec![sql[..sql.rfind("\nSELECT 2").unwrap()].to_string(), "SELECT 2 FROM DUMMY".to_string()]
        );
    }

    #[test]
    fn sap_hana_split_handles_single_line_and_lowercase_end() {
        for sql in [
            "DO BEGIN T = SELECT CASE WHEN 1 = 1 THEN 1 ELSE 0 END FROM DUMMY; END;",
            "do begin t = select 1 from dummy; end;",
        ] {
            assert_eq!(split_sql_statements_for_database(sql, DatabaseType::SapHana), vec![sql.to_string()]);
        }
    }

    #[test]
    fn sap_hana_plain_alter_procedure_still_flushes_at_semicolon() {
        assert_eq!(
            split_sql_statements_for_database(
                "ALTER PROCEDURE PUBLIC.P RECOMPILE; SELECT 1 FROM DUMMY;",
                DatabaseType::SapHana
            ),
            vec!["ALTER PROCEDURE PUBLIC.P RECOMPILE", "SELECT 1 FROM DUMMY"]
        );
    }

    #[test]
    fn sap_hana_cursor_statement_keeps_nested_do_block_together() {
        let sql = "\
DO
BEGIN
  IF 1 = 1 THEN
    SELECT CASE WHEN 1 = 1 THEN 1 ELSE 0 END AS \"Result\" FROM DUMMY;
  END IF;
END;
SELECT 2 FROM DUMMY;";
        let cursor = sql.find("Result").unwrap();

        assert_eq!(
            find_statement_at_cursor_for_database(sql, cursor, DatabaseType::SapHana),
            "DO\nBEGIN\n  IF 1 = 1 THEN\n    SELECT CASE WHEN 1 = 1 THEN 1 ELSE 0 END AS \"Result\" FROM DUMMY;\n  END IF;\nEND;"
        );
    }

    #[test]
    fn firebird_split_keeps_trigger_block_together() {
        let sql = "\
CREATE OR ALTER TRIGGER \"WL_FYD_TP_AU\" FOR \"WL_FYD\" ACTIVE
AFTER UPDATE
as
begin
  /* Trigger text */
  IF ( COALESCE(NEW.QSTPS,0) <> COALESCE(OLD.QSTPS,0) ) THEN
  BEGIN
    UPDATE WL_FYD SET ZT='完成' WHERE ID= NEW.ID;
  END
end;
SELECT 2 FROM RDB$DATABASE;";

        assert_eq!(
            split_sql_statements_for_database(sql, DatabaseType::Firebird),
            vec![
                "CREATE OR ALTER TRIGGER \"WL_FYD_TP_AU\" FOR \"WL_FYD\" ACTIVE\nAFTER UPDATE\nas\nbegin\n  /* Trigger text */\n  IF ( COALESCE(NEW.QSTPS,0) <> COALESCE(OLD.QSTPS,0) ) THEN\n  BEGIN\n    UPDATE WL_FYD SET ZT='完成' WHERE ID= NEW.ID;\n  END\nend;",
                "SELECT 2 FROM RDB$DATABASE"
            ]
        );
    }

    #[test]
    fn firebird_split_keeps_procedure_with_declarations_together() {
        let sql = "\
CREATE OR ALTER PROCEDURE SP_GET_USER (USER_ID INT)
RETURNS (USERNAME VARCHAR(50), TOTAL_AMOUNT NUMERIC(18, 2))
AS
DECLARE VARIABLE V_TEMP NUMERIC(18, 2);
DECLARE VARIABLE V_STATUS INT;
BEGIN
  SELECT FIRST 1 NAME FROM USERS WHERE ID = :USER_ID INTO :USERNAME;
  V_TEMP = 100.50;
  TOTAL_AMOUNT = :V_TEMP;
  SUSPEND;
END;
SELECT 1 FROM RDB$DATABASE;";

        assert_eq!(
            split_sql_statements_for_database(sql, DatabaseType::Firebird),
            vec![
                "CREATE OR ALTER PROCEDURE SP_GET_USER (USER_ID INT)\nRETURNS (USERNAME VARCHAR(50), TOTAL_AMOUNT NUMERIC(18, 2))\nAS\nDECLARE VARIABLE V_TEMP NUMERIC(18, 2);\nDECLARE VARIABLE V_STATUS INT;\nBEGIN\n  SELECT FIRST 1 NAME FROM USERS WHERE ID = :USER_ID INTO :USERNAME;\n  V_TEMP = 100.50;\n  TOTAL_AMOUNT = :V_TEMP;\n  SUSPEND;\nEND;",
                "SELECT 1 FROM RDB$DATABASE"
            ]
        );
    }

    #[test]
    fn firebird_split_keeps_execute_block_together() {
        let sql = "\
EXECUTE BLOCK
RETURNS (OUT_ID INT)
AS
DECLARE VARIABLE I INT;
BEGIN
  I = 0;
  WHILE (I < 10) DO
  BEGIN
    I = I + 1;
  END
  OUT_ID = I;
  SUSPEND;
END;
SELECT 1 FROM RDB$DATABASE;";

        assert_eq!(
            split_sql_statements_for_database(sql, DatabaseType::Firebird),
            vec![
                "EXECUTE BLOCK\nRETURNS (OUT_ID INT)\nAS\nDECLARE VARIABLE I INT;\nBEGIN\n  I = 0;\n  WHILE (I < 10) DO\n  BEGIN\n    I = I + 1;\n  END\n  OUT_ID = I;\n  SUSPEND;\nEND;",
                "SELECT 1 FROM RDB$DATABASE"
            ]
        );
    }

    #[test]
    fn firebird_split_keeps_routine_with_case_expression_together() {
        let sql = "\
CREATE PROCEDURE P_CASE
AS
BEGIN
  UPDATE T SET FLAG = CASE WHEN X > 0 THEN 1 ELSE 0 END;
END;
SELECT 1 FROM RDB$DATABASE;";

        assert_eq!(
            split_sql_statements_for_database(sql, DatabaseType::Firebird),
            vec![
                "CREATE PROCEDURE P_CASE\nAS\nBEGIN\n  UPDATE T SET FLAG = CASE WHEN X > 0 THEN 1 ELSE 0 END;\nEND;",
                "SELECT 1 FROM RDB$DATABASE"
            ]
        );
    }

    #[test]
    fn firebird_plain_alter_trigger_still_flushes_at_semicolon() {
        assert_eq!(
            split_sql_statements_for_database(
                "ALTER TRIGGER TR_USERS INACTIVE; SELECT 1 FROM RDB$DATABASE;",
                DatabaseType::Firebird
            ),
            vec!["ALTER TRIGGER TR_USERS INACTIVE", "SELECT 1 FROM RDB$DATABASE"]
        );
    }

    #[test]
    fn firebird_cursor_statement_returns_whole_trigger() {
        let sql = "\
CREATE OR ALTER TRIGGER \"WL_FYD_TP_AU\" FOR \"WL_FYD\" ACTIVE
AFTER UPDATE
as
begin
  /* Trigger text */
  IF ( COALESCE(NEW.QSTPS,0) <> COALESCE(OLD.QSTPS,0) ) THEN
  BEGIN
    UPDATE WL_FYD SET ZT='完成' WHERE ID= NEW.ID;
  END
end;
SELECT 2 FROM RDB$DATABASE;";
        let cursor = sql.find("UPDATE WL_FYD").unwrap();

        assert_eq!(
            find_statement_at_cursor_for_database(sql, cursor, DatabaseType::Firebird),
            "CREATE OR ALTER TRIGGER \"WL_FYD_TP_AU\" FOR \"WL_FYD\" ACTIVE\nAFTER UPDATE\nas\nbegin\n  /* Trigger text */\n  IF ( COALESCE(NEW.QSTPS,0) <> COALESCE(OLD.QSTPS,0) ) THEN\n  BEGIN\n    UPDATE WL_FYD SET ZT='完成' WHERE ID= NEW.ID;\n  END\nend;"
        );
    }

    #[test]
    fn oracle_split_keeps_anonymous_block_with_local_routines_together() {
        let cases = [
            "DECLARE\nPROCEDURE local_proc IS\nBEGIN\n  NULL;\nEND;\n\nBEGIN\nlocal_proc;\nEND;",
            "DECLARE\n  v NUMBER;\n  PROCEDURE p1 IS BEGIN NULL; END;\n  FUNCTION f1 RETURN NUMBER IS BEGIN RETURN 1; END f1;\nBEGIN\n  p1;\n  v := f1;\nEND;",
            "DECLARE\n  PROCEDURE fwd(x NUMBER);\n  PROCEDURE fwd(x NUMBER) IS BEGIN NULL; END;\nBEGIN\n  fwd(1);\nEND;",
            "DECLARE\n  PROCEDURE outer_p IS\n    PROCEDURE inner_p IS BEGIN NULL; END;\n  BEGIN\n    inner_p;\n  END;\nBEGIN\n  outer_p;\nEND;",
        ];
        for sql in cases {
            assert_eq!(split_sql_statements_for_database(sql, DatabaseType::Oracle), vec![sql.to_string()], "{sql}");
        }
        let block = cases[0];
        let sql = format!("{block}\nSELECT 1 FROM dual;");
        assert_eq!(
            split_sql_statements_for_database(&sql, DatabaseType::Oracle),
            vec![block.to_string(), "SELECT 1 FROM dual".to_string()]
        );
    }

    // A stored routine declares its local subprograms right after its own IS/AS, with
    // no DECLARE keyword, so their END must not finish the routine.
    #[test]
    fn oracle_split_keeps_stored_routines_with_local_subprograms_together() {
        let cases = [
            "CREATE OR REPLACE EDITIONABLE PROCEDURE \"A\".\"P\" AS\n  PROCEDURE inner_p IS BEGIN NULL; END;\nBEGIN\n  inner_p;\nEND;",
            "CREATE PROCEDURE p(x NUMBER) IS\n  v NUMBER;\n  PROCEDURE inner_p IS\n  BEGIN\n    NULL;\n  END inner_p;\nBEGIN\n  inner_p;\nEND p;",
            "CREATE OR REPLACE FUNCTION f RETURN NUMBER AS\n  FUNCTION g RETURN NUMBER IS BEGIN RETURN 1; END g;\nBEGIN\n  RETURN g;\nEND;",
            "CREATE OR REPLACE PROCEDURE p AS\n  PROCEDURE fwd(x NUMBER);\n  PROCEDURE fwd(x NUMBER) IS BEGIN NULL; END;\nBEGIN\n  fwd(1);\nEND;",
            "CREATE OR REPLACE PROCEDURE p AS\n  CURSOR c IS SELECT 1 FROM dual;\nBEGIN\n  NULL;\nEND;",
        ];
        for routine in cases {
            for database in [DatabaseType::Oracle, DatabaseType::Dameng, DatabaseType::Xugu] {
                assert_eq!(
                    split_sql_statements_for_database(&format!("{routine}\nSELECT 1 FROM dual;"), database),
                    vec![routine.to_string(), "SELECT 1 FROM dual".to_string()],
                    "{database:?}: {routine}"
                );
            }
        }
    }

    #[test]
    fn oracle_split_ends_call_trigger_before_following_ddl() {
        let trigger = "CREATE OR REPLACE TRIGGER \"S\".\"TR\" BEFORE INSERT ON \"S\".\"T\" FOR EACH ROW CALL \"S\".\"P\"(:NEW.ID, 'a;b');";
        for database in [DatabaseType::Oracle, DatabaseType::OceanbaseOracle] {
            for separator in ["\n", "\n/\n"] {
                let sql = format!("{trigger}{separator}ALTER TRIGGER \"S\".\"TR\" DISABLE; COMMENT ON TABLE \"S\".\"T\" IS 'unchanged';");
                assert_eq!(
                    split_sql_statements_for_database(&sql, database),
                    vec![
                        trigger.to_string(),
                        "ALTER TRIGGER \"S\".\"TR\" DISABLE".to_string(),
                        "COMMENT ON TABLE \"S\".\"T\" IS 'unchanged'".to_string()
                    ]
                );
            }
        }
    }

    #[test]
    fn oracle_split_keeps_compound_trigger_together() {
        let trigger = "\
CREATE OR REPLACE EDITIONABLE TRIGGER \"A\".\"T\" FOR INSERT OR UPDATE ON \"A\".\"X\" COMPOUND TRIGGER
  total NUMBER := 0;
  BEFORE EACH ROW IS
  BEGIN
    IF :NEW.ID IS NULL THEN total := total + 1; END IF;
  END BEFORE EACH ROW;
  AFTER STATEMENT IS
  BEGIN
    NULL;
  END AFTER STATEMENT;
END \"T\";";
        assert_eq!(
            split_sql_statements_for_database(
                &format!("{trigger}\nALTER TRIGGER \"A\".\"T\" ENABLE;"),
                DatabaseType::Oracle
            ),
            vec![trigger.to_string(), "ALTER TRIGGER \"A\".\"T\" ENABLE".to_string()]
        );
        // A simple trigger still ends at its own END.
        let simple = "CREATE TRIGGER t BEFORE INSERT ON x FOR EACH ROW BEGIN NULL; END;";
        assert_eq!(
            split_sql_statements_for_database(&format!("{simple}\nSELECT 1 FROM dual;"), DatabaseType::Oracle),
            vec![simple.to_string(), "SELECT 1 FROM dual".to_string()]
        );
    }

    #[test]
    fn oracle_split_keeps_compound_trigger_sections_in_one_execution_unit() {
        let trigger = "CREATE OR REPLACE TRIGGER \"S\".\"tr\" FOR INSERT ON \"S\".\"t\" COMPOUND TRIGGER\nBEFORE STATEMENT IS BEGIN NULL; END BEFORE STATEMENT;\nAFTER EACH ROW IS BEGIN :NEW.x := q'[a;b]'; END AFTER EACH ROW;\nEND tr;";
        let state = "ALTER TRIGGER \"S\".\"tr\" DISABLE";
        for database in [DatabaseType::Oracle, DatabaseType::OceanbaseOracle] {
            assert_eq!(split_sql_statements_for_database(trigger, database), vec![trigger.to_string()]);
            assert_eq!(
                split_sql_statements_for_database(
                    &format!("{trigger}\n/\n{state};\nCREATE TABLE t2 (id NUMBER);"),
                    database
                ),
                vec![trigger.to_string(), state.to_string(), "CREATE TABLE t2 (id NUMBER)".to_string()]
            );
            let execution_units = [trigger.to_string(), format!("{state};")];
            let split_units: Vec<_> =
                execution_units.iter().flat_map(|unit| split_sql_statements_for_database(unit, database)).collect();
            assert_eq!(split_units, vec![trigger.to_string(), state.to_string()]);
        }
    }

    #[test]
    fn oracle_like_split_keeps_anonymous_plsql_block_together() {
        let sql = "\
DECLARE
V_EXISTS_FLAG NUMBER;
BEGIN
SELECT COUNT(1)
INTO V_EXISTS_FLAG
FROM SCHEMA_NAME.TABLE_NAME
WHERE UNIQUE_KEY_COLUMN = 'BUSINESS_UNIQUE_VALUE';
IF V_EXISTS_FLAG = 0 THEN
INSERT INTO SCHEMA_NAME.TABLE_NAME (UNIQUE_KEY_COLUMN, COLUMN_NAME_1)
VALUES ('BUSINESS_UNIQUE_VALUE', 'BUSINESS_VALUE_1');
END IF;
END;";

        assert_eq!(split_sql_statements_for_database(sql, DatabaseType::Oracle), vec![sql.to_string()]);
        assert_eq!(split_sql_statements_for_database(sql, DatabaseType::Dameng), vec![sql.to_string()]);
        assert_eq!(split_sql_statements_for_database(sql, DatabaseType::Gaussdb), vec![sql.to_string()]);
        assert_eq!(split_sql_statements_for_database(sql, DatabaseType::Xugu), vec![sql.to_string()]);
    }

    #[test]
    fn oracle_like_split_keeps_quoted_identifier_block_together_per_issue_10434() {
        // `BEGIN "SCHEMA"."PROCEDURE"(); END;` is what the DM (Dameng) routine dialog
        // generates. The double-quoted name used to be dropped from the token stream, so the
        // block tokenized exactly like a transaction `BEGIN;` and was cut at its inner
        // semicolon — the server then rejected the fragment with 42000 + vendorCode -2007
        // ("第 2 行, 第 32 列[]附近出现错误: 语法分析出错").
        let sql = "BEGIN\n  \"DLJPLAT\".\"用户表脱敏\"();\nEND;";
        for db_type in [DatabaseType::Dameng, DatabaseType::Oracle, DatabaseType::Xugu, DatabaseType::Gaussdb] {
            assert_eq!(split_sql_statements_for_database(sql, db_type), vec![sql.to_string()], "{db_type:?}");
        }

        // A quoted identifier that spells a block keyword is a name, not a block boundary.
        let keyword_named = "BEGIN\n  INSERT INTO \"END\" VALUES (1);\nEND;";
        assert_eq!(
            split_sql_statements_for_database(keyword_named, DatabaseType::Dameng),
            vec![keyword_named.to_string()]
        );

        // `BEGIN;` stays a transaction statement and still splits at its own terminator.
        assert_eq!(
            split_sql_statements_for_database("BEGIN; INSERT INTO t VALUES (1); COMMIT;", DatabaseType::Dameng),
            vec!["BEGIN", "INSERT INTO t VALUES (1)", "COMMIT"]
        );
    }

    #[test]
    fn oracle_like_split_keeps_with_function_declaration_and_main_query_together_per_issue_11275() {
        // DM8 accepts Oracle's `WITH [FUNCTION ...] <main query>` form and executes it as ONE
        // statement (the reporter's own client returned f = 1). Splitting at the first
        // declaration `;` sent the truncated `WITH FUNCTION ... v_start TIMESTAMP := SYSTIMESTAMP`
        // fragment, and DM rejected it with 42000 / vendorCode -2007
        // ("第 2 行, 第 39 列[]附近出现错误: 语法分析出错").
        let sql = "\
WITH FUNCTION f RETURN NUMBER IS
    v_start TIMESTAMP := SYSTIMESTAMP;
    v_delay_seconds NUMBER := MOD(TO_NUMBER(TO_CHAR(SYSDATE, 'SSSSS')), 10) + 1;
BEGIN
    WHILE (SYSTIMESTAMP - v_start) < (v_delay_seconds * INTERVAL '1' SECOND) LOOP
        NULL;
    END LOOP;
    RETURN 1;
END;
SELECT f FROM dual;";
        for db_type in [DatabaseType::Dameng, DatabaseType::Oracle, DatabaseType::Gaussdb, DatabaseType::Xugu] {
            assert_eq!(split_sql_statements_for_database(sql, db_type), vec![sql.to_string()], "{db_type:?}");
        }

        // The statement after the WITH query still splits at its own terminator.
        let script = format!("{sql}\nSELECT 2 FROM dual;");
        assert_eq!(
            split_sql_statements_for_database(&script, DatabaseType::Dameng),
            vec![sql.to_string(), "SELECT 2 FROM dual".to_string()]
        );

        // Multiple declarations stay in one statement until the main query's terminator.
        let two_declarations = "\
WITH FUNCTION f1 RETURN NUMBER IS
BEGIN
  RETURN 1;
END;
FUNCTION f2 RETURN NUMBER IS
  v NUMBER := 0;
BEGIN
  v := 2;
  RETURN v;
END;
SELECT f1 + f2 FROM dual;";
        assert_eq!(
            split_sql_statements_for_database(two_declarations, DatabaseType::Dameng),
            vec![two_declarations.to_string()]
        );

        // A plain CTE without PL/SQL declarations is ordinary SQL: the trailing `;` stays a
        // delimiter and the statement is emitted without it.
        let cte = "WITH t AS (SELECT 1 FROM dual) SELECT * FROM t;";
        assert_eq!(
            split_sql_statements_for_database(cte, DatabaseType::Dameng),
            vec!["WITH t AS (SELECT 1 FROM dual) SELECT * FROM t".to_string()]
        );
    }

    #[test]
    fn argo_split_keeps_create_procedure_body_together() {
        // ArgoDB (Transwarp) accepts PL/SQL-style procedure definitions whose body contains
        // semicolons. The statement splitter must keep those semicolons inside the body rather
        // than emitting one fragment per statement — otherwise the agent sends only the first
        // `CREATE ... IS BEGIN INSERT INTO ...` fragment and the server responds with
        // 42000 + vendorCode 1101 (see screenshots from the 2026-09-01 session).
        let sql = "\
CREATE OR REPLACE PROCEDURE SP_ETL_LOG
(
  II_DATDATE       IN INT,
  IV_SCHEMA_NAME   IN STRING,
  IV_PROCEDURE_NAME IN STRING,
  II_STEP_ID       IN INT,
  IV_STEP_DESC     IN STRING,
  II_STEP_FLAG     IN INT,
  II_START_TIME    IN TIMESTAMP
)
/****************************************
@AUTHOR:xiangxu
@CREATE-DATE:2015-09-06
@DESCRIPTION:处理执行信息插入日志表(ETL_LOG)
@MODIFICATION HISTORY:
#0.20150906-xiangxu-处理执行信息插入日志表
*****************************************/
IS
BEGIN
  INSERT INTO dws.ETL_LOG
  (
    DATA_DATE,
    SCHEMA_NAME,
    PROCEDURE_NAME,
    STEP_ID,
    STEP_DESC,
    STEP_FLAG,
    START_TIME
  )
  VALUES
  (
    II_DATDATE,
    IV_SCHEMA_NAME,
    IV_PROCEDURE_NAME,
    II_STEP_ID,
    IV_STEP_DESC,
    II_STEP_FLAG,
    II_START_TIME
  );
END;";

        assert_eq!(split_sql_statements_for_database(sql, DatabaseType::Argo), vec![sql.to_string()]);
        assert_eq!(split_sql_statements_for_database(sql, DatabaseType::Transwarp), vec![sql.to_string()]);
        assert_eq!(split_sql_statements_for_database(sql, DatabaseType::Jdbc), vec![sql.to_string()]);
        assert_eq!(split_sql_statements_for_database(sql, DatabaseType::Hive), vec![sql.to_string()]);
    }

    #[test]
    fn jdbc_and_hive_keep_procedure_statement_ranges_intact() {
        let sql = "\
CREATE OR REPLACE PROCEDURE pro_cbs_check_his(is_date IN VARCHAR(8))
IS
BEGIN
    DELETE FROM transwarp.tmp_cbs_t00_corp_cust_his
    WHERE data_date = is_date;

    INSERT INTO transwarp.tmp_cbs_t00_corp_cust_his
    SELECT * FROM transwarp.cbs_t00_corp_cust_his
    WHERE data_date = is_date;

    COMMIT;
END;";

        let sql_as = "\
CREATE OR REPLACE PROCEDURE pro_cbs_check_his(is_date IN VARCHAR(8))
AS
BEGIN
    DELETE FROM transwarp.tmp_cbs_t00_corp_cust_his
    WHERE data_date = is_date;

    COMMIT;
END;";

        for db_type in [DatabaseType::Jdbc, DatabaseType::Hive, DatabaseType::Argo, DatabaseType::Transwarp] {
            let statements = split_sql_statements_for_database(sql, db_type);
            assert_eq!(statements, vec![sql.to_string()], "failed for {db_type:?}");
            let statements_as = split_sql_statements_for_database(sql_as, db_type);
            assert_eq!(statements_as, vec![sql_as.to_string()], "failed for {db_type:?}");
        }
    }

    #[test]
    fn jdbc_and_hive_split_hiveql_functions_with_string_body() {
        let sql_basic = "\
CREATE FUNCTION my_udf AS 'com.example.Mask';
SELECT mask_fn(x) FROM t;";

        let sql_if_not_exists = "\
CREATE FUNCTION IF NOT EXISTS my_udf AS 'com.example.Mask';
SELECT mask_fn(x) FROM t;";

        let sql_temporary = "\
CREATE TEMPORARY FUNCTION my_udf AS 'com.example.Mask';
SELECT mask_fn(x) FROM t;";

        for db_type in [DatabaseType::Jdbc, DatabaseType::Hive] {
            assert_eq!(
                split_sql_statements_for_database(sql_basic, db_type),
                vec![
                    "CREATE FUNCTION my_udf AS 'com.example.Mask'".to_string(),
                    "SELECT mask_fn(x) FROM t".to_string(),
                ],
                "failed for {db_type:?}"
            );
            assert_eq!(
                split_sql_statements_for_database(sql_if_not_exists, db_type),
                vec![
                    "CREATE FUNCTION IF NOT EXISTS my_udf AS 'com.example.Mask'".to_string(),
                    "SELECT mask_fn(x) FROM t".to_string(),
                ],
                "failed for {db_type:?}"
            );
            assert_eq!(
                split_sql_statements_for_database(sql_temporary, db_type),
                vec![
                    "CREATE TEMPORARY FUNCTION my_udf AS 'com.example.Mask'".to_string(),
                    "SELECT mask_fn(x) FROM t".to_string(),
                ],
                "failed for {db_type:?}"
            );
        }
    }

    #[test]
    fn argo_split_keeps_procedure_with_dash_line_comments() {
        // Mirrors the SP_ETL_LOG definition in the 2026-09-01 screenshot where each
        // parameter row carries a trailing `--中文` line comment. The PL/SQL tokenizer must
        // still recognise the procedure as a block; otherwise the splitter emits the
        // parameter list, "COMMIT", and "END" as three separate statements (the failure
        // mode shown in the 21:22:59 screenshot).
        let sql = "\
CREATE OR REPLACE PROCEDURE SP_ETL_LOG
(
  II_DATDATE       IN INT, --数据日期
  IV_SCHEMA_NAME   IN STRING, --模式名
  IV_PROCEDURE_NAME IN STRING, --存储过程名称
  II_STEP_ID       IN INT, --任务号
  IV_STEP_DESC     IN STRING, --任务描述
  II_STEP_FLAG     IN INT, --执行状态
  II_START_TIME    IN TIMESTAMP --起始时间
);
END;";

        let statements = split_sql_statements_for_database(sql, DatabaseType::Argo);
        assert_eq!(statements, vec![sql.to_string()], "splitter produced: {statements:#?}");
    }

    #[test]
    fn argo_split_handles_full_user_procedure_with_block_comment_and_at_meta() {
        // Mirrors the EXACT procedure text shown in the 2026-09-01 21:22:59 screenshot:
        // - parameter list with trailing `--中文` comments
        // - block comment `/********...********/` containing `@AUTHOR:` and `#0.20150906-...`
        //   which are NOT standard SQL comment markers (ArgoDB/Hive ignores them, but the
        //   splitter must still treat them as part of the surrounding block comment)
        // - `IS BEGIN INSERT INTO ... ; END;`
        // The result panel showed three split fragments; if this test passes, the splitter
        // is fine and the issue is on the DBX.app side.
        let sql = "CREATE OR REPLACE PROCEDURE SP_ETL_LOG\n\
(\n\
  II_DATDATE       IN INT, --数据日期\n\
  IV_SCHEMA_NAME   IN STRING, --模式名\n\
  IV_PROCEDURE_NAME IN STRING, --存储过程名称\n\
  II_STEP_ID       IN INT, --任务号\n\
  IV_STEP_DESC     IN STRING, --任务描述\n\
  II_STEP_FLAG     IN INT, --执行状态\n\
  II_START_TIME    IN TIMESTAMP --起始时间\n\
)\n\
/****************************************\n\
@AUTHOR:xiangxu\n\
@CREATE-DATE:2015-09-06\n\
@DESCRIPTION:处理执行信息插入日志表(ETL_LOG)\n\
@MODIFICATION HISTORY:\n\
#0.20150906-xiangxu-处理执行信息插入日志表\n\
*****************************************/\n\
IS\n\
BEGIN INSERT INTO dws.ETL_LOG\n\
  (\n\
    DATA_DATE,           --数据日期\n\
    SCHEMA_NAME,           --模式名\n\
    PROCEDURE_NAME,           --存储过程名称\n\
    STEP_ID,           --任务号\n\
    STEP_DESC,           --任务描述\n\
    STEP_FLAG,           --执行状态\n\
    START_TIME            --起始时间\n\
  )\n\
  ;\n\
END;";

        let statements = split_sql_statements_for_database(sql, DatabaseType::Argo);
        assert_eq!(statements.len(), 1, "splitter produced {statements:#?}");
        assert_eq!(statements[0], sql);
    }

    #[test]
    fn argo_split_handles_minimal_user_procedure_no_body_semicolon() {
        // Mirrors the user's 2026-09-02 10:09 procedure: simple CREATE OR REPLACE PROCEDURE
        // body with no semicolon after INSERT INTO ... SELECT, only after the SELECT expression.
        let sql = "CREATE OR REPLACE PROCEDURE SP_TEST_PART_A\n\
 (\n\
   II_DATADATE IN INT\n\
 )\n\
 IS\n\
   I_DATADATE INT;\n\
 BEGIN\n\
   I_DATADATE := II_DATADATE;\n\
   INSERT INTO dws.TEST_PART_PROC\n\
   SELECT 1, 'testA1', I_DATADATE;\n\
 END;";

        let statements = split_sql_statements_for_database(sql, DatabaseType::Argo);
        assert_eq!(statements.len(), 1, "splitter produced {statements:#?}");
        assert_eq!(statements[0], sql);
    }

    #[test]
    fn gaussdb_split_ignores_psql_controls_before_anonymous_block_per_issue_6468() {
        let block = "\
/* 将逻辑放到匿名块中,便于捕获异常 pl/pgsql */
DECLARE
  v_date_str VARCHAR(20) := '20240824';
  v_date_dt DATE := TO_DATE(v_date_str, 'YYYYMMDD');
  v_eff_num NUMERIC := 0;
  v_start_time TIMESTAMP := CURRENT_TIMESTAMP;
  v_step TEXT := '';
  v_job_name VARCHAR := 'F_XY_DG_IBDISCOUNT_DET';
BEGIN
  RAISE NOTICE 'issue 6468';
END;";
        let sql = format!("\\set ON_ERROR_STOP on\n\\set VERBOSITY verbose\n\\timing\n\n{block}\n/");

        assert_eq!(split_sql_statements_for_database(&sql, DatabaseType::Gaussdb), vec![block]);

        let cursor = sql[..sql.find("RAISE NOTICE").unwrap()].encode_utf16().count();
        let executable_block = &block[block.find("DECLARE").unwrap()..];
        assert_eq!(find_statement_at_cursor_for_database(&sql, cursor, DatabaseType::Gaussdb), executable_block);
    }

    #[test]
    fn gaussdb_streaming_split_ignores_chunked_psql_controls() {
        let mut splitter =
            SqlStatementSplitter::with_options(SqlParsingOptions::for_database_type(DatabaseType::Gaussdb));

        assert!(splitter.push_chunk("\\set ON_ERROR_").is_empty());
        assert!(splitter.push_chunk("STOP on\n\\tim").is_empty());
        assert!(splitter.stop_on_error());
        assert_eq!(
            splitter.push_chunk("ing\nDECLARE\n  value NUMBER := 1;\nBEGIN\n  value := value + 1;\nEND;\n/\n"),
            vec!["DECLARE\n  value NUMBER := 1;\nBEGIN\n  value := value + 1;\nEND;"]
        );
        assert!(splitter.finish().is_empty());
    }

    #[test]
    fn gaussdb_streaming_split_tracks_on_error_stop_by_statement_position() {
        let mut splitter =
            SqlStatementSplitter::with_options(SqlParsingOptions::for_database_type(DatabaseType::Gaussdb));

        let mut statements = splitter.push_chunk_with_control("SELECT 0;\nSELECT\n\\set ON_ERROR_");
        statements.extend(splitter.push_chunk_with_control("STOP on\n  1;\nSELECT 2;"));
        statements.extend(splitter.finish_with_control());

        assert_eq!(
            statements,
            vec![
                super::SqlStatementWithControl { sql: "SELECT 0".to_string(), stop_on_error: false },
                super::SqlStatementWithControl { sql: "SELECT\n  1".to_string(), stop_on_error: true },
                super::SqlStatementWithControl { sql: "SELECT 2".to_string(), stop_on_error: true },
            ]
        );
    }

    #[test]
    fn gaussdb_psql_control_does_not_submit_unfinished_query_buffer() {
        let sql = "SELECT\n\\timing\n  1;\nSELECT 2;";
        let statements = split_sql_statements_for_database(sql, DatabaseType::Gaussdb);

        assert_eq!(statements.len(), 2);
        assert_eq!(statements[0].split_whitespace().collect::<Vec<_>>(), vec!["SELECT", "1"]);
        assert_eq!(statements[1], "SELECT 2");

        let mut splitter =
            SqlStatementSplitter::with_options(SqlParsingOptions::for_database_type(DatabaseType::Gaussdb));
        assert!(splitter.push_chunk("SELECT\n\\tim").is_empty());
        assert_eq!(splitter.push_chunk("ing\n  1;"), vec!["SELECT\n  1"]);
    }

    #[test]
    fn gaussdb_split_does_not_ignore_psql_variable_assignment() {
        for control in ["\\set tx_date 20240824", "\\set MY_ON_ERROR_STOP on", "\\set ON_ERROR_STOP_EXTRA on"] {
            let sql = format!("{control}\nDECLARE\n  value TEXT := '$tx_date';\nBEGIN\n  NULL;\nEND;\n/");
            let statements = split_sql_statements_for_database(&sql, DatabaseType::Gaussdb);
            assert!(statements[0].starts_with(control));
        }
    }

    #[test]
    fn gaussdb_ignores_only_safe_psql_controls() {
        assert_eq!(
            super::parse_ignorable_psql_control_command("\\set ON_ERROR_STOP on"),
            Some(super::PsqlControlCommand::OnErrorStop)
        );
        assert_eq!(
            super::parse_ignorable_psql_control_command("\\set VERBOSITY verbose"),
            Some(super::PsqlControlCommand::ClientDisplay)
        );
        assert_eq!(
            super::parse_ignorable_psql_control_command("\\timing"),
            Some(super::PsqlControlCommand::ClientDisplay)
        );
        assert_eq!(super::parse_ignorable_psql_control_command("\\set ON_ERROR_STOP off"), None);
        assert_eq!(super::parse_ignorable_psql_control_command("\\set tx_date 20240824"), None);
        assert_eq!(super::parse_ignorable_psql_control_command("\\set MY_ON_ERROR_STOP on"), None);
        assert_eq!(super::parse_ignorable_psql_control_command("\\set ON_ERROR_STOP_EXTRA on"), None);
        assert_eq!(super::parse_ignorable_psql_control_command("\\set ON_ERROR_STOP sometimes"), None);
    }

    #[test]
    fn gaussdb_execution_plan_preserves_on_error_stop() {
        let plan = super::sql_execution_plan_for_database(
            "\\set ON_ERROR_STOP on\nSELECT 1;\nSELECT 2;",
            DatabaseType::Gaussdb,
        );

        assert!(plan.stop_on_error);
        assert_eq!(plan.statements, vec!["SELECT 1", "SELECT 2"]);
    }

    #[test]
    fn postgres_family_accepts_display_controls_and_preserves_on_error_stop() {
        let sql = "\\set ON_ERROR_STOP on\r\n\\echo '开始; SELECT 99; -- output'\r\n\\timing on\n\\set VERBOSITY verbose\nSELECT 1;\n\\echo done; SELECT 99; /* output */\nSELECT 2;\n\\echo";
        for db_type in [DatabaseType::Postgres, DatabaseType::OpenGauss, DatabaseType::Gaussdb] {
            let plan = super::sql_execution_plan_for_database(sql, db_type);
            assert_eq!(plan.statements, vec!["SELECT 1", "SELECT 2"], "{db_type:?}");
            assert!(plan.stop_on_error);
            // Import parsing must agree regardless of where input chunks end.
            for chunk_size in 1..=sql.len() {
                let mut splitter = SqlStatementSplitter::with_options(SqlParsingOptions::for_database_type(db_type));
                let chars = sql.chars().collect::<Vec<_>>();
                let mut statements = Vec::new();
                for chunk in chars.chunks(chunk_size) {
                    statements.extend(splitter.push_chunk_with_control(&chunk.iter().collect::<String>()));
                }
                statements.extend(splitter.finish_with_control());
                assert_eq!(statements.iter().map(|s| s.sql.as_str()).collect::<Vec<_>>(), vec!["SELECT 1", "SELECT 2"]);
                assert!(statements.iter().all(|s| s.stop_on_error));
            }
        }
    }

    #[test]
    fn postgres_psql_controls_do_not_execute_unfinished_sql_buffer() {
        let sql = "SELECT\n\\echo progress; -- text\n  1;\nSELECT 2;";
        let plan = super::sql_execution_plan_for_database(sql, DatabaseType::Postgres);
        assert_eq!(plan.statements.len(), 2);
        assert_eq!(plan.statements[0].split_whitespace().collect::<Vec<_>>(), vec!["SELECT", "1"]);
        assert!(!plan.stop_on_error);
        let mut splitter =
            SqlStatementSplitter::with_options(SqlParsingOptions::for_database_type(DatabaseType::Postgres));
        assert!(splitter.push_chunk("SELECT\n\\echo progress; --").is_empty());
        assert_eq!(splitter.push_chunk(" text\n  1;\nSELECT 2;"), vec!["SELECT\n  1", "SELECT 2"]);
        assert!(splitter.finish().is_empty());
    }

    #[test]
    fn postgres_psql_controls_inside_sql_literals_and_comments_are_preserved() {
        for sql in [
            "SELECT 'before\n\\echo literal\nafter';",
            "SELECT \"before\n\\echo literal\nafter\";",
            "SELECT $$before\n\\set ON_ERROR_STOP on\nafter$$;",
            "SELECT $body$before\n\\echo literal\nafter$body$;",
            "/* before\n\\echo comment\nafter */\nSELECT 1;",
            "-- \\echo comment\nSELECT 1;",
            "SELECT 'unfinished\n\\echo literal",
            "SELECT $$unfinished\n\\set ON_ERROR_STOP on",
        ] {
            let plan = super::sql_execution_plan_for_database(sql, DatabaseType::Postgres);
            assert!(!plan.stop_on_error);
            assert_eq!(plan.statements, vec![sql.trim_end_matches(';')]);
            let mut splitter =
                SqlStatementSplitter::with_options(SqlParsingOptions::for_database_type(DatabaseType::Postgres));
            let mut statements = splitter.push_chunk(sql);
            statements.extend(splitter.finish());
            assert_eq!(statements, plan.statements);
        }
    }

    #[test]
    fn postgres_psql_display_text_preserves_editor_cursor_offsets() {
        let sql = "\\echo 🚀 开始\nSELECT 1;\nSELECT 2;";
        let cursor = sql[..sql.find("SELECT 2").unwrap() + "SELECT ".len()].encode_utf16().count();
        assert_eq!(find_statement_at_cursor_for_database(sql, cursor, DatabaseType::Postgres), "SELECT 2");
    }

    #[test]
    fn postgres_does_not_silently_ignore_variable_or_execution_commands() {
        for command in [
            "\\set target_schema private",
            "\\set ON_ERROR_STOP off",
            "\\set ON_ERROR_STOP on extra",
            "\\echo done \\\\ SELECT 99",
            "\\echo `touch should_not_run`",
            "\\copy users FROM 'users.csv'",
            "\\gexec",
            "\\i script.sql",
            "\\! echo shell",
        ] {
            let sql = format!("{command}\nSELECT 1;");
            let plan = super::sql_execution_plan_for_database(&sql, DatabaseType::Postgres);
            assert!(plan.statements[0].starts_with(command), "{command}");
            assert!(!plan.stop_on_error);
            let mut splitter =
                SqlStatementSplitter::with_options(SqlParsingOptions::for_database_type(DatabaseType::Postgres));
            let mut statements = splitter.push_chunk(&sql);
            statements.extend(splitter.finish());
            assert!(statements[0].starts_with(command), "{command}");
        }
        let sql = "\\echo message\nSELECT 1;";
        assert!(split_sql_statements_for_database(sql, DatabaseType::Mysql)[0].starts_with("\\echo"));
    }

    #[test]
    fn gaussdb_split_separates_dollar_quoted_function_from_following_statements() {
        let sql = "\
DROP FUNCTION IF EXISTS dbx_issue_4572_tmp_md5_uuid;

CREATE OR REPLACE FUNCTION dbx_issue_4572_tmp_md5_uuid (v_str IN TEXT) RETURNS varchar(36) LANGUAGE PLPGSQL IMMUTABLE AS $function$
DECLARE
    str1 TEXT;
BEGIN
    str1 := md5(v_str);
    RETURN CAST(str1 AS varchar(36));
END$function$;

DROP FUNCTION IF EXISTS dbx_issue_4572_tmp_missing;";

        let statements = split_sql_statements_for_database(sql, DatabaseType::Gaussdb);
        assert_eq!(statements.len(), 3);
        assert_eq!(statements[0], "DROP FUNCTION IF EXISTS dbx_issue_4572_tmp_md5_uuid");
        assert!(statements[1].starts_with("CREATE OR REPLACE FUNCTION dbx_issue_4572_tmp_md5_uuid"));
        assert!(statements[1].ends_with("END$function$"));
        assert_eq!(statements[2], "DROP FUNCTION IF EXISTS dbx_issue_4572_tmp_missing");
    }

    #[test]
    fn gaussdb_split_separates_issue_4573_procedure_from_following_statements() {
        let sql = "\
CREATE OR REPLACE PROCEDURE createIndex (
  dbName IN VARCHAR(32),
  tableName IN VARCHAR(64),
  indexInfo IN VARCHAR(64),
  indexColumns IN VARCHAR(128)
) AS
DECLARE STMT TEXT;

DECLARE flag int;

BEGIN
SELECT
  count(*) INTO flag
FROM
  PG_CATALOG.PG_INDEXES
WHERE
  schemaname = dbName
  AND TABLENAME = tableName
  AND INDEXNAME = indexInfo;

IF flag = 0 THEN STMT := 'CREATE INDEX ' || indexInfo || ' ON ' || dbName || '.' || tableName || '(' || indexColumns || ')';

EXECUTE STMT;

END IF;

END;

SELECT 1 AS after_procedure;
SELECT 2 AS final_statement;";

        let statements = split_sql_statements_for_database(sql, DatabaseType::Gaussdb);
        assert_eq!(statements.len(), 3);
        assert!(statements[0].starts_with("CREATE OR REPLACE PROCEDURE createIndex"));
        assert!(statements[0].ends_with("END;"));
        assert_eq!(statements[1], "SELECT 1 AS after_procedure");
        assert_eq!(statements[2], "SELECT 2 AS final_statement");
    }

    const POSTGRES_FAMILY_PROCEDURE_SCRIPT: &str = "\
CREATE OR REPLACE PROCEDURE sync_yxdyurl_and_flag()
AS  DECLARE
BEGIN

    update test_xm_20260913 set a = '23' where a = '1';

    COMMIT;
EXCEPTION
    WHEN OTHERS THEN
        ROLLBACK;
        RAISE;
END;
/
SELECT 1;";

    const POSTGRES_FAMILY_PROCEDURE_BODY: &str = "\
CREATE OR REPLACE PROCEDURE sync_yxdyurl_and_flag()
AS  DECLARE
BEGIN

    update test_xm_20260913 set a = '23' where a = '1';

    COMMIT;
EXCEPTION
    WHEN OTHERS THEN
        ROLLBACK;
        RAISE;
END;";

    /// Issue #8979: a GaussDB/openGauss Oracle-compatibility server reached through the plain
    /// PostgreSQL connection type must not split the PL/SQL body at its inner semicolons, or the
    /// server only receives an incomplete routine and answers with
    /// `subprogram body is not ended correctly at end of input`.
    #[test]
    fn postgres_family_keeps_oracle_style_procedure_body_in_one_statement() {
        for db_type in [DatabaseType::Postgres, DatabaseType::OpenGauss] {
            assert_eq!(
                split_sql_statements_for_database(POSTGRES_FAMILY_PROCEDURE_SCRIPT, db_type),
                vec![POSTGRES_FAMILY_PROCEDURE_BODY.to_string(), "SELECT 1".to_string()],
                "{db_type:?} must keep the procedure body whole and drop the slash terminator"
            );
        }
    }

    #[test]
    fn postgres_family_current_statement_keeps_oracle_style_procedure_body_together() {
        let sql = POSTGRES_FAMILY_PROCEDURE_SCRIPT;
        let body_cursors =
            [sql.find("update test_xm").unwrap(), sql.find("COMMIT").unwrap(), sql.find("RAISE").unwrap()];

        for db_type in [DatabaseType::Postgres, DatabaseType::OpenGauss] {
            for cursor in body_cursors {
                assert_eq!(
                    find_statement_at_cursor_for_database(sql, cursor, db_type),
                    POSTGRES_FAMILY_PROCEDURE_BODY,
                    "{db_type:?} must resolve the cursor inside the body to the whole procedure"
                );
            }
            assert_eq!(find_statement_at_cursor_for_database(sql, sql.len(), db_type), "SELECT 1");
        }
    }

    /// The reported scripts end with a bare `/` on the last line without a trailing newline, so the
    /// terminator has to be recognized at end of input too.
    #[test]
    fn postgres_family_drops_trailing_slash_line_without_trailing_newline() {
        for suffix in ["", "\n"] {
            let sql = format!("{POSTGRES_FAMILY_PROCEDURE_BODY}\n/{suffix}");
            for db_type in [DatabaseType::Postgres, DatabaseType::OpenGauss] {
                assert_eq!(
                    split_sql_statements_for_database(&sql, db_type),
                    vec![POSTGRES_FAMILY_PROCEDURE_BODY.to_string()],
                    "{db_type:?} must drop the trailing slash line (suffix {suffix:?})"
                );
                assert_eq!(
                    find_statement_at_cursor_for_database(&sql, sql.len(), db_type),
                    POSTGRES_FAMILY_PROCEDURE_BODY
                );
            }
        }
    }

    #[test]
    fn postgres_family_keeps_slash_terminated_routine_body_whole() {
        let sql = "\
CREATE OR REPLACE FUNCTION f_pg() RETURNS int AS $$
BEGIN
    RETURN 1;
END;
$$ LANGUAGE plpgsql;
/
SELECT f_pg();";

        for db_type in [DatabaseType::Postgres, DatabaseType::OpenGauss] {
            assert_eq!(
                split_sql_statements_for_database(sql, db_type),
                vec![
                    "CREATE OR REPLACE FUNCTION f_pg() RETURNS int AS $$
BEGIN
    RETURN 1;
END;
$$ LANGUAGE plpgsql",
                    "SELECT f_pg()",
                ],
                "{db_type:?} must treat the standalone slash line as a statement terminator"
            );
        }
    }

    #[test]
    fn postgres_family_current_statement_keeps_dollar_quoted_routine_whole() {
        let sql = "\
CREATE OR REPLACE FUNCTION f_pg() RETURNS int AS $$
BEGIN
    RETURN 1;
END;
$$ LANGUAGE plpgsql;
/
SELECT f_pg();";

        for db_type in [DatabaseType::Postgres, DatabaseType::OpenGauss] {
            let statement = find_statement_at_cursor_for_database(sql, sql.find("RETURN 1").unwrap(), db_type);
            assert!(statement.contains("LANGUAGE plpgsql"), "{db_type:?} resolved {statement:?}");
            assert!(!statement.contains("SELECT f_pg()"), "{db_type:?} resolved {statement:?}");
        }
    }

    #[test]
    fn postgres_family_still_splits_ordinary_postgres_statements() {
        let sql = "\
CREATE OR REPLACE FUNCTION f_pg() RETURNS int AS $$
BEGIN
    RETURN 1;
END;
$$ LANGUAGE plpgsql;
CREATE FUNCTION f_sql() RETURNS int AS 'SELECT 1' LANGUAGE sql;
CREATE TRIGGER t_pg AFTER INSERT ON t_pg FOR EACH ROW EXECUTE FUNCTION f_pg();
BEGIN;
SELECT f_pg();
COMMIT;";

        assert_eq!(
            split_sql_statements_for_database(sql, DatabaseType::Postgres),
            vec![
                "CREATE OR REPLACE FUNCTION f_pg() RETURNS int AS $$
BEGIN
    RETURN 1;
END;
$$ LANGUAGE plpgsql",
                "CREATE FUNCTION f_sql() RETURNS int AS 'SELECT 1' LANGUAGE sql",
                "CREATE TRIGGER t_pg AFTER INSERT ON t_pg FOR EACH ROW EXECUTE FUNCTION f_pg()",
                "BEGIN",
                "SELECT f_pg()",
                "COMMIT",
            ]
        );
    }

    #[test]
    fn postgres_family_does_not_enable_full_oracle_plsql_blocks() {
        assert!(!starts_with_oracle_style_routine_body("CREATE PROCEDURE p() LANGUAGE sql AS 'SELECT 1';"));
        assert!(!starts_with_oracle_style_routine_body(
            "CREATE TRIGGER t AFTER INSERT ON x FOR EACH ROW EXECUTE FUNCTION f();"
        ));
        assert!(!starts_with_oracle_style_routine_body("DECLARE c CURSOR FOR SELECT 1;"));
        assert!(!starts_with_oracle_style_routine_body(
            "CREATE FUNCTION f_pg() RETURNS int AS $$\nBEGIN\n    RETURN 1;\nEND;\n$$ LANGUAGE plpgsql;"
        ));
        assert!(!starts_with_oracle_style_routine_body(
            "CREATE OR REPLACE FUNCTION f_tag() RETURNS int AS $body$ BEGIN RETURN 1; END; $body$ LANGUAGE plpgsql"
        ));
        assert!(starts_with_oracle_style_routine_body("CREATE OR REPLACE PROCEDURE p()\nAS  DECLARE\nBEGIN"));
        assert!(starts_with_oracle_style_routine_body("CREATE PROCEDURE p() IS BEGIN"));
        assert!(starts_with_oracle_style_routine_body("CREATE OR REPLACE PACKAGE BODY pkg AS"));
    }

    #[test]
    fn oracle_like_split_keeps_issue_2405_anonymous_plsql_block_together() {
        let sql = "\
DECLARE
   PRE_TRD_DATE   INTEGER ;
BEGIN
   SELECT 1 + 2 INTO PRE_TRD_DATE FROM DUAL;
END;";

        assert_eq!(split_sql_statements_for_database(sql, DatabaseType::Oracle), vec![sql.to_string()]);
    }

    #[test]
    fn oracle_like_current_statement_keeps_issue_2405_anonymous_plsql_block_together() {
        let sql = "\
DECLARE
   PRE_TRD_DATE   INTEGER ;
BEGIN
   SELECT 1 + 2 INTO PRE_TRD_DATE FROM DUAL;
END;";
        let cursors = [
            sql[..sql.find("PRE_TRD_DATE").unwrap()].encode_utf16().count(),
            sql[..sql.find("SELECT 1 + 2").unwrap()].encode_utf16().count(),
            sql[..sql.find("END;").unwrap()].encode_utf16().count(),
        ];

        for cursor in cursors {
            assert_eq!(find_statement_at_cursor_for_database(sql, cursor, DatabaseType::Oracle), sql);
        }
    }

    #[test]
    fn oracle_like_split_treats_slash_line_as_plsql_delimiter() {
        let sql = "\
BEGIN
  NULL;
END;
/
SELECT 1;";

        assert_eq!(
            split_sql_statements_for_database(sql, DatabaseType::Oracle),
            vec!["BEGIN\n  NULL;\nEND;", "SELECT 1"]
        );
    }

    #[test]
    fn oracle_like_current_statement_keeps_plsql_block_together() {
        let sql = "\
DECLARE
  v_exists_flag NUMBER;
BEGIN
  IF v_exists_flag = 0 THEN
    NULL;
  END IF;
END;
/
SELECT 1;";
        let cursor = sql[..sql.find("NULL").unwrap()].encode_utf16().count();
        let next_cursor = sql[..sql.find("SELECT 1").unwrap()].encode_utf16().count();

        assert_eq!(
            find_statement_at_cursor_for_database(sql, cursor, DatabaseType::Oracle),
            "DECLARE\n  v_exists_flag NUMBER;\nBEGIN\n  IF v_exists_flag = 0 THEN\n    NULL;\n  END IF;\nEND;"
        );
        assert_eq!(find_statement_at_cursor_for_database(sql, next_cursor, DatabaseType::Oracle), "SELECT 1");
    }

    #[test]
    fn oracle_like_current_statement_keeps_nested_dml_plsql_block_together() {
        let sql = "\
DECLARE
  v_order_count NUMBER;
BEGIN
  SELECT COUNT(*) INTO v_order_count
  FROM \"DBX_TEST\".\"ORDERS_10K\";

  IF v_order_count = 0 THEN
    INSERT INTO \"DBX_TEST\".\"STORES\"
      (\"ID\", \"STORE_CODE\", \"STORE_NAME\", \"CITY\", \"OPENED_AT\")
    SELECT 10001, 'TEST_STORE_001', '测试门店', '上海', SYSDATE
    FROM DUAL
    WHERE NOT EXISTS (
      SELECT 1 FROM \"DBX_TEST\".\"STORES\" WHERE \"ID\" = 10001
    );

    INSERT INTO \"DBX_TEST\".\"PRODUCTS\"
      (\"ID\", \"SKU\", \"PRODUCT_NAME\", \"CATEGORY\", \"PRICE\")
    SELECT 10001, 'TEST_SKU_001', '测试商品', '测试分类', 99.90
    FROM DUAL
    WHERE NOT EXISTS (
      SELECT 1 FROM \"DBX_TEST\".\"PRODUCTS\" WHERE \"ID\" = 10001
    );

    INSERT INTO \"DBX_TEST\".\"ORDERS_10K\"
      (\"ID\", \"ORDER_NO\", \"STORE_ID\", \"PRODUCT_ID\", \"CUSTOMER_NAME\", \"QUANTITY\", \"AMOUNT\", \"ORDER_STATUS\", \"CREATED_AT\")
    SELECT 10001, 'TEST_ORDER_001', 10001, 10001, '测试客户', 2, 199.80, 'PAID', SYSDATE
    FROM DUAL
    WHERE NOT EXISTS (
      SELECT 1 FROM \"DBX_TEST\".\"ORDERS_10K\" WHERE \"ORDER_NO\" = 'TEST_ORDER_001'
    );

    COMMIT;
  END IF;
END;
/
SELECT 1;";
        let expected = sql.split("\n/").next().unwrap();
        let cursor = sql[..sql.find("ORDERS_10K").unwrap()].encode_utf16().count();
        let next_cursor = sql[..sql.find("SELECT 1;").unwrap()].encode_utf16().count();

        assert_eq!(
            split_sql_statements_for_database(sql, DatabaseType::Oracle),
            vec![expected.to_string(), "SELECT 1".to_string()]
        );
        assert_eq!(find_statement_at_cursor_for_database(sql, cursor, DatabaseType::Oracle), expected);
        assert_eq!(find_statement_at_cursor_for_database(sql, next_cursor, DatabaseType::Oracle), "SELECT 1");
    }

    #[test]
    fn oracle_like_split_keeps_transaction_begin_as_statement() {
        assert_eq!(
            split_sql_statements_for_database("BEGIN; INSERT INTO t VALUES (1); COMMIT;", DatabaseType::Gaussdb),
            vec!["BEGIN", "INSERT INTO t VALUES (1)", "COMMIT"]
        );
    }

    #[test]
    fn oracle_like_split_keeps_create_function_together() {
        let sql = "\
CREATE OR REPLACE FUNCTION number_tochar(nums VARCHAR(20))
RETURN VARCHAR(20)
AS
    res VARCHAR(20);
BEGIN
    RETURN '一';
END;
/
SELECT 1;";

        assert_eq!(
            split_sql_statements_for_database(sql, DatabaseType::Oracle),
            vec!["CREATE OR REPLACE FUNCTION number_tochar(nums VARCHAR(20))\nRETURN VARCHAR(20)\nAS\n    res VARCHAR(20);\nBEGIN\n    RETURN '一';\nEND;", "SELECT 1"]
        );
        assert_eq!(
            split_sql_statements_for_database(sql, DatabaseType::Xugu),
            vec!["CREATE OR REPLACE FUNCTION number_tochar(nums VARCHAR(20))\nRETURN VARCHAR(20)\nAS\n    res VARCHAR(20);\nBEGIN\n    RETURN '一';\nEND;", "SELECT 1"]
        );
        assert_eq!(
            split_sql_statements_for_database(sql, DatabaseType::Dameng),
            vec!["CREATE OR REPLACE FUNCTION number_tochar(nums VARCHAR(20))\nRETURN VARCHAR(20)\nAS\n    res VARCHAR(20);\nBEGIN\n    RETURN '一';\nEND;", "SELECT 1"]
        );
    }

    #[test]
    fn oracle_like_split_keeps_create_procedure_together() {
        let sql = "\
CREATE OR REPLACE PROCEDURE update_salary(p_id NUMBER, p_amount NUMBER)
AS
BEGIN
    UPDATE employees SET salary = salary + p_amount WHERE id = p_id;
    COMMIT;
END;
/
SELECT 1;";

        assert_eq!(
            split_sql_statements_for_database(sql, DatabaseType::Oracle),
            vec![
                "CREATE OR REPLACE PROCEDURE update_salary(p_id NUMBER, p_amount NUMBER)\nAS\nBEGIN\n    UPDATE employees SET salary = salary + p_amount WHERE id = p_id;\n    COMMIT;\nEND;",
                "SELECT 1"
            ]
        );
        assert_eq!(
            split_sql_statements_for_database(sql, DatabaseType::Xugu),
            vec![
                "CREATE OR REPLACE PROCEDURE update_salary(p_id NUMBER, p_amount NUMBER)\nAS\nBEGIN\n    UPDATE employees SET salary = salary + p_amount WHERE id = p_id;\n    COMMIT;\nEND;",
                "SELECT 1"
            ]
        );
    }

    #[test]
    fn oracle_like_split_keeps_create_trigger_together() {
        let sql = "\
CREATE TRIGGER trg_audit
BEFORE INSERT ON employees
FOR EACH ROW
BEGIN
    INSERT INTO audit_log VALUES (:NEW.id, 'INSERT');
END;
/
SELECT 1;";

        assert_eq!(
            split_sql_statements_for_database(sql, DatabaseType::Oracle),
            vec![
                "CREATE TRIGGER trg_audit\nBEFORE INSERT ON employees\nFOR EACH ROW\nBEGIN\n    INSERT INTO audit_log VALUES (:NEW.id, 'INSERT');\nEND;",
                "SELECT 1"
            ]
        );
        assert_eq!(
            split_sql_statements_for_database(sql, DatabaseType::Xugu),
            vec![
                "CREATE TRIGGER trg_audit\nBEFORE INSERT ON employees\nFOR EACH ROW\nBEGIN\n    INSERT INTO audit_log VALUES (:NEW.id, 'INSERT');\nEND;",
                "SELECT 1"
            ]
        );
    }

    #[test]
    fn yashandb_split_keeps_create_trigger_with_slash_delimiter_together() {
        let sql = "\
CREATE TRIGGER \"TB_SC_UPDATE_TIME_TRI\"
BEFORE UPDATE ON \"TB_SC\"
FOR EACH ROW
 BEGIN
   IF NOT UPDATING('UPDATE_TIME')  THEN
   \t\t:NEW.\"UPDATE_TIME\" := CURRENT_TIMESTAMP;
   END IF;
END;
/
SELECT 1;";

        assert_eq!(
            split_sql_statements_for_database(sql, DatabaseType::Yashandb),
            vec![
                "CREATE TRIGGER \"TB_SC_UPDATE_TIME_TRI\"\nBEFORE UPDATE ON \"TB_SC\"\nFOR EACH ROW\n BEGIN\n   IF NOT UPDATING('UPDATE_TIME')  THEN\n   \t\t:NEW.\"UPDATE_TIME\" := CURRENT_TIMESTAMP;\n   END IF;\nEND;",
                "SELECT 1"
            ]
        );
    }

    #[test]
    fn oracle_like_split_keeps_create_package_together() {
        let sql = "\
CREATE OR REPLACE PACKAGE pkg_utils AS
    FUNCTION get_version RETURN VARCHAR2;
    PROCEDURE log_message(msg VARCHAR2);
END pkg_utils;
/
SELECT 1;";

        assert_eq!(
            split_sql_statements_for_database(sql, DatabaseType::Oracle),
            vec![
                "CREATE OR REPLACE PACKAGE pkg_utils AS\n    FUNCTION get_version RETURN VARCHAR2;\n    PROCEDURE log_message(msg VARCHAR2);\nEND pkg_utils;",
                "SELECT 1"
            ]
        );
        assert_eq!(
            split_sql_statements_for_database(sql, DatabaseType::Xugu),
            vec![
                "CREATE OR REPLACE PACKAGE pkg_utils AS\n    FUNCTION get_version RETURN VARCHAR2;\n    PROCEDURE log_message(msg VARCHAR2);\nEND pkg_utils;",
                "SELECT 1"
            ]
        );
    }

    #[test]
    fn opengauss_a_mode_split_keeps_create_package_together() {
        let sql = "CREATE OR REPLACE PACKAGE pkg_utils AS\n    FUNCTION get_version RETURN VARCHAR2;\n    PROCEDURE log_message(msg VARCHAR2);\nEND pkg_utils;\n/\nSELECT 1;";

        assert_eq!(
            super::split_sql_statements_for_database_with_compatibility(sql, DatabaseType::OpenGauss, Some("A")),
            vec![
                "CREATE OR REPLACE PACKAGE pkg_utils AS\n    FUNCTION get_version RETURN VARCHAR2;\n    PROCEDURE log_message(msg VARCHAR2);\nEND pkg_utils;",
                "SELECT 1"
            ]
        );
        assert_ne!(
            super::split_sql_statements_for_database_with_compatibility(sql, DatabaseType::OpenGauss, Some("PG")),
            super::split_sql_statements_for_database_with_compatibility(sql, DatabaseType::OpenGauss, Some("A"))
        );
    }

    #[test]
    fn xugu_split_keeps_create_package_body_together() {
        let sql = "\
CREATE OR REPLACE PACKAGE BODY dbx_pkg AS
    PROCEDURE ping AS
    BEGIN
        NULL;
    END ping;
END dbx_pkg;
/
SELECT 1;";

        assert_eq!(
            split_sql_statements_for_database(sql, DatabaseType::Xugu),
            vec![
                "CREATE OR REPLACE PACKAGE BODY dbx_pkg AS\n    PROCEDURE ping AS\n    BEGIN\n        NULL;\n    END ping;\nEND dbx_pkg;",
                "SELECT 1"
            ]
        );
    }

    #[test]
    fn xugu_split_keeps_routines_without_or_replace_together() {
        let cases = [
            "CREATE PROCEDURE dbx_proc_without_replace AS BEGIN NULL; END;",
            "CREATE FUNCTION dbx_func_without_replace RETURN INTEGER AS BEGIN RETURN 1; END;",
            "CREATE TRIGGER dbx_trigger_without_replace BEFORE INSERT ON dbx_events FOR EACH ROW BEGIN NULL; END;",
        ];

        for statement in cases {
            assert_eq!(
                split_sql_statements_for_database(&format!("{statement}\nSELECT 1;"), DatabaseType::Xugu),
                vec![statement.to_owned(), "SELECT 1".to_owned()],
                "failed for {statement}"
            );
        }
    }

    #[test]
    fn xugu_split_keeps_force_package_body_together() {
        let sql = "\
CREATE OR REPLACE FORCE PACKAGE BODY dbx_pkg AS
    PROCEDURE ping AS
    BEGIN
        NULL;
    END ping;
END dbx_pkg;
SELECT 1;";

        assert_eq!(
            split_sql_statements_for_database(sql, DatabaseType::Xugu),
            vec![
                "CREATE OR REPLACE FORCE PACKAGE BODY dbx_pkg AS\n    PROCEDURE ping AS\n    BEGIN\n        NULL;\n    END ping;\nEND dbx_pkg;",
                "SELECT 1"
            ]
        );
        assert_eq!(
            split_sql_statements_for_database(
                "CREATE OR REPLACE NOFORCE PACKAGE BODY dbx_pkg AS\n    PROCEDURE ping AS\n    BEGIN\n        NULL;\n    END ping;\nEND dbx_pkg;\nSELECT 1;",
                DatabaseType::Xugu
            ),
            vec![
                "CREATE OR REPLACE NOFORCE PACKAGE BODY dbx_pkg AS\n    PROCEDURE ping AS\n    BEGIN\n        NULL;\n    END ping;\nEND dbx_pkg;",
                "SELECT 1"
            ]
        );
        assert_eq!(
            split_sql_statements_for_database(
                "CREATE PACKAGE BODY dbx_pkg_without_replace AS\n    PROCEDURE ping AS\n    BEGIN\n        NULL;\n    END ping;\nEND dbx_pkg_without_replace;\nSELECT 1;",
                DatabaseType::Xugu
            ),
            vec![
                "CREATE PACKAGE BODY dbx_pkg_without_replace AS\n    PROCEDURE ping AS\n    BEGIN\n        NULL;\n    END ping;\nEND dbx_pkg_without_replace;",
                "SELECT 1"
            ]
        );
    }

    #[test]
    fn xugu_split_package_spec_without_slash_does_not_consume_following_sql() {
        let sql = "\
CREATE OR REPLACE PACKAGE pkg_utils AS
    FUNCTION get_version RETURN VARCHAR2;
    PROCEDURE log_message(msg VARCHAR2);
END pkg_utils;
SELECT 1;";

        assert_eq!(
            split_sql_statements_for_database(sql, DatabaseType::Xugu),
            vec![
                "CREATE OR REPLACE PACKAGE pkg_utils AS\n    FUNCTION get_version RETURN VARCHAR2;\n    PROCEDURE log_message(msg VARCHAR2);\nEND pkg_utils;",
                "SELECT 1"
            ]
        );
        assert_eq!(
            split_sql_statements_for_database(
                "CREATE OR REPLACE PACKAGE pkg_utils AS\n    FUNCTION get_version RETURN VARCHAR2;\n    PROCEDURE log_message(msg VARCHAR2);\nEND pkg_utils;\n/\nSELECT 1;",
                DatabaseType::Xugu
            ),
            vec![
                "CREATE OR REPLACE PACKAGE pkg_utils AS\n    FUNCTION get_version RETURN VARCHAR2;\n    PROCEDURE log_message(msg VARCHAR2);\nEND pkg_utils;",
                "SELECT 1"
            ]
        );
        assert_eq!(
            split_sql_statements_for_database(
                "CREATE OR REPLACE FORCE PACKAGE pkg_utils AS\n    PROCEDURE ping;\nEND pkg_utils;\nSELECT 1;",
                DatabaseType::Xugu
            ),
            vec!["CREATE OR REPLACE FORCE PACKAGE pkg_utils AS\n    PROCEDURE ping;\nEND pkg_utils;", "SELECT 1"]
        );
        assert_eq!(
            split_sql_statements_for_database(
                "CREATE PACKAGE pkg_utils_without_replace AS\n    PROCEDURE ping;\nEND pkg_utils_without_replace;\nSELECT 1;",
                DatabaseType::Xugu
            ),
            vec![
                "CREATE PACKAGE pkg_utils_without_replace AS\n    PROCEDURE ping;\nEND pkg_utils_without_replace;",
                "SELECT 1"
            ]
        );
    }

    #[test]
    fn oracle_like_split_declaration_only_package_body_before_following_dml() {
        let package_body = "CREATE OR REPLACE PACKAGE BODY packageName IS\nnull;\nEND packageName;";
        assert_eq!(
            split_sql_statements_for_database(&format!("{package_body}\nSELECT * FROM goods;"), DatabaseType::Oracle),
            vec![package_body, "SELECT * FROM goods"]
        );
        assert_eq!(
            split_sql_statements_for_database(
                &format!("{package_body}\n/\nSELECT * FROM goods;"),
                DatabaseType::Oracle
            ),
            vec![package_body, "SELECT * FROM goods"]
        );
    }

    #[test]
    fn oracle_like_split_large_package_body_in_linear_time() {
        // Every inner `;` used to re-tokenize the whole body so far, so a few hundred KB
        // DM8 package body spent minutes in the splitter before reaching the server (#13450).
        let routines = (0..300)
            .map(|i| {
                format!(
                    "  PROCEDURE p{i}(p_id INT) IS\n    v_name VARCHAR2(100) := 'x;y';\n  BEGIN\n    IF p_id > 0 THEN\n      INSERT INTO orders VALUES (p_id);\n    END IF;\n    FOR r IN (SELECT id FROM orders WHERE id = p_id) LOOP\n      UPDATE orders SET name = v_name WHERE id = r.id;\n    END LOOP;\n  END p{i};\n"
                )
            })
            .collect::<String>();
        let package_body = format!("CREATE OR REPLACE PACKAGE BODY pkg_orders AS\n{routines}END pkg_orders;");
        let sql = format!("{package_body}\nSELECT 1 FROM dual;");

        let started = std::time::Instant::now();
        let statements = split_sql_statements_for_database(&sql, DatabaseType::Dameng);
        let cursor_statement = find_statement_at_cursor_for_database(&sql, 1, DatabaseType::Dameng);
        let elapsed = started.elapsed();

        assert_eq!(statements, vec![package_body.as_str(), "SELECT 1 FROM dual"]);
        assert_eq!(cursor_statement, package_body);
        assert!(elapsed < std::time::Duration::from_secs(2), "splitting took {elapsed:?}");
    }

    #[test]
    fn xugu_split_keeps_create_type_body_together() {
        let sql = "\
CREATE OR REPLACE TYPE BODY obj_t AS
    MEMBER PROCEDURE ping IS
    BEGIN
        NULL;
    END;
END;
SELECT 1;";

        assert_eq!(
            split_sql_statements_for_database(sql, DatabaseType::Xugu),
            vec![
                "CREATE OR REPLACE TYPE BODY obj_t AS\n    MEMBER PROCEDURE ping IS\n    BEGIN\n        NULL;\n    END;\nEND;",
                "SELECT 1"
            ]
        );
        assert_eq!(
            split_sql_statements_for_database(
                "CREATE TYPE BODY obj_t_without_replace AS\n    MEMBER PROCEDURE ping IS\n    BEGIN\n        NULL;\n    END;\nEND;\nSELECT 1;",
                DatabaseType::Xugu
            ),
            vec![
                "CREATE TYPE BODY obj_t_without_replace AS\n    MEMBER PROCEDURE ping IS\n    BEGIN\n        NULL;\n    END;\nEND;",
                "SELECT 1"
            ]
        );
    }

    #[test]
    fn xugu_split_plain_create_type_object_on_semicolon() {
        // Plain CREATE TYPE ends with ");" and must not wait for a nonexistent outer END.
        let sql = "CREATE OR REPLACE TYPE address_t AS OBJECT (id INT);\nSELECT 1;";
        assert_eq!(
            split_sql_statements_for_database(sql, DatabaseType::Xugu),
            vec!["CREATE OR REPLACE TYPE address_t AS OBJECT (id INT)", "SELECT 1"]
        );
        assert_eq!(
            split_sql_statements_for_database(
                "CREATE TYPE address_t_without_replace AS OBJECT (id INT);\nSELECT 1;",
                DatabaseType::Xugu
            ),
            vec!["CREATE TYPE address_t_without_replace AS OBJECT (id INT)", "SELECT 1"]
        );
    }

    #[test]
    fn oracle_like_split_keeps_case_expressions_inside_routines() {
        let function = "CREATE OR REPLACE FUNCTION dbx_case_expr RETURN NUMBER AS\nBEGIN\n  RETURN CASE WHEN 1 = 1 THEN CASE WHEN 2 = 2 THEN 1 ELSE 2 END ELSE 0 END;\nEND;\nSELECT 1;";
        let procedure = "CREATE OR REPLACE PROCEDURE dbx_case_statement AS\nBEGIN\n  CASE WHEN 1 = 1 THEN NULL; ELSE NULL; END CASE;\nEND;\nSELECT 1;";

        for database in [DatabaseType::Xugu, DatabaseType::Oracle] {
            assert_eq!(
                split_sql_statements_for_database(function, database),
                vec![
                    "CREATE OR REPLACE FUNCTION dbx_case_expr RETURN NUMBER AS\nBEGIN\n  RETURN CASE WHEN 1 = 1 THEN CASE WHEN 2 = 2 THEN 1 ELSE 2 END ELSE 0 END;\nEND;",
                    "SELECT 1"
                ]
            );
            assert_eq!(
                split_sql_statements_for_database(procedure, database),
                vec![
                    "CREATE OR REPLACE PROCEDURE dbx_case_statement AS\nBEGIN\n  CASE WHEN 1 = 1 THEN NULL; ELSE NULL; END CASE;\nEND;",
                    "SELECT 1"
                ]
            );
        }
    }

    #[test]
    fn oracle_like_split_keeps_decode_consecutive_case_expressions_inside_procedure() {
        // Punctuation between `end` and the next `case` must not look like PL/SQL `END CASE`,
        // or CREATE PROCEDURE is truncated at the INSERT terminator (OceanBase OBE-00900 near insert).
        let procedure = "\
CREATE OR REPLACE PROCEDURE dm.sp_demo IS
BEGIN
  INSERT INTO t(c)
  SELECT decode(
    company_no,
    'A', (case when x = 1 then 'one' else 'other' end),
    'B', (case when y = 2 then 'two' else 'other' end)
  ) as business_type_name
  FROM src;
  COMMIT;
EXCEPTION
  WHEN OTHERS THEN
    NULL;
END sp_demo;";

        for database in [DatabaseType::Oracle, DatabaseType::OceanbaseOracle] {
            assert_eq!(split_sql_statements_for_database(procedure, database), vec![procedure.to_string()]);
        }
    }

    #[test]
    fn oracle_like_split_ignores_end_tokens_inside_q_quoted_strings() {
        let sql = "\
BEGIN
    v_text := q'[not really END;]';
    NULL;
END;
SELECT 1;";

        assert_eq!(
            split_sql_statements_for_database(sql, DatabaseType::Oracle),
            vec!["BEGIN\n    v_text := q'[not really END;]';\n    NULL;\nEND;", "SELECT 1"]
        );
    }

    #[test]
    fn oracle_plsql_tokenizer_falls_back_when_sqlparser_rejects_partial_literals() {
        let sql = "\
BEGIN
    NULL;
    v_text := 'partial";
        let tokens = super::oracle_plsql_tokens(sql);

        assert!(tokens.iter().any(|token| token.is_word("BEGIN")));
        assert!(tokens.iter().any(super::OraclePlSqlToken::is_semicolon));
    }

    #[test]
    fn oracle_like_split_does_not_affect_create_table() {
        let sql = "\
CREATE TABLE users (id NUMBER PRIMARY KEY, name VARCHAR2(100));
CREATE OR REPLACE VIEW v_users AS SELECT id, name FROM users;";

        assert_eq!(
            split_sql_statements_for_database(sql, DatabaseType::Oracle),
            vec![
                "CREATE TABLE users (id NUMBER PRIMARY KEY, name VARCHAR2(100))",
                "CREATE OR REPLACE VIEW v_users AS SELECT id, name FROM users"
            ]
        );
    }

    #[test]
    fn oracle_like_split_does_not_treat_backslash_as_quote_escape() {
        let sql = "SELECT TO_CLOB('a\\') || TO_CLOB('n};\\n}') FROM dual;\nSELECT 2 FROM dual;";
        for db_type in [
            DatabaseType::OceanbaseOracle,
            DatabaseType::Oracle,
            DatabaseType::Dameng,
            DatabaseType::Yashandb,
            DatabaseType::Oscar,
        ] {
            assert_eq!(
                split_sql_statements_for_database(sql, db_type),
                vec!["SELECT TO_CLOB('a\\') || TO_CLOB('n};\\n}') FROM dual", "SELECT 2 FROM dual"],
                "{db_type:?}"
            );
        }
    }

    #[test]
    fn finds_statement_at_cursor() {
        let sql = "SELECT 1; SELECT 2";

        assert_eq!(super::find_statement_at_cursor(sql, 3), "SELECT 1");
        assert_eq!(super::find_statement_at_cursor(sql, 12), "SELECT 2");
        assert_eq!(super::find_statement_at_cursor(sql, 18), "SELECT 2");
    }

    #[test]
    fn finds_statement_at_cursor_after_unicode_comment() {
        let sql = "-- 判断字段是否存在\nSELECT 1; SELECT 2";
        let cursor_byte = sql.find("SELECT 2").unwrap();
        let cursor = sql[..cursor_byte].encode_utf16().count();

        assert_eq!(super::find_statement_at_cursor(sql, cursor), "SELECT 2");
    }

    #[test]
    fn finds_statement_at_cursor_after_semicolon_with_blank_line_stays_on_previous_statement() {
        let sql = "SELECT 1;\n\nSELECT 2;";
        let cursor = sql[..sql.find(';').unwrap() + 1].encode_utf16().count();
        assert_eq!(super::find_statement_at_cursor(sql, cursor), "SELECT 1");
    }

    #[test]
    fn finds_statement_at_cursor_after_semicolon_same_line_moves_to_next_statement() {
        let sql = "SELECT 1; SELECT 2;";
        let cursor = sql[..sql.find("SELECT 2").unwrap()].encode_utf16().count();

        assert_eq!(super::find_statement_at_cursor(sql, cursor), "SELECT 2");
    }

    #[test]
    fn finds_statement_at_cursor_after_double_blank_line_without_semicolon() {
        let sql = "SELECT * FROM old_table\n\n\nCREATE VIEW v AS SELECT 1";
        let cursor = sql[..sql.find("CREATE VIEW").unwrap()].encode_utf16().count();

        assert_eq!(super::find_statement_at_cursor(sql, cursor), "CREATE VIEW v AS SELECT 1");
    }

    #[test]
    fn keeps_create_view_statement_together_across_double_blank_line() {
        let sql = "CREATE VIEW v AS\n\n\nSELECT 1";
        let cursor = sql[..sql.find("SELECT 1").unwrap()].encode_utf16().count();

        assert_eq!(super::find_statement_at_cursor(sql, cursor), "CREATE VIEW v AS\n\n\nSELECT 1");
    }

    #[test]
    fn finds_statement_with_dollar_quote() {
        let sql = "SELECT $$a;b$$; SELECT 2";

        assert_eq!(super::find_statement_at_cursor(sql, 3), "SELECT $$a;b$$");
        assert_eq!(super::find_statement_at_cursor(sql, 17), "SELECT 2");
    }

    #[test]
    fn finds_statement_with_custom_delimiter() {
        let sql = "\
DELIMITER //
CREATE PROCEDURE foo()
BEGIN
  SELECT 1;
END //
DELIMITER ;
SELECT 2;";
        let cursor = sql.find("SELECT 1").unwrap();
        let next_cursor = sql.rfind("SELECT 2").unwrap();

        assert_eq!(super::find_statement_at_cursor(sql, cursor), "CREATE PROCEDURE foo()\nBEGIN\n  SELECT 1;\nEND");
        assert_eq!(super::find_statement_at_cursor(sql, next_cursor), "SELECT 2");
    }

    #[test]
    fn sqlserver_current_statement_keeps_procedure_batch_with_inner_semicolons() {
        let sql = "\
CREATE OR ALTER PROCEDURE dbo.usp_demo
AS
BEGIN
  SELECT 1;
  SELECT 2;
END
GO
SELECT 3;";
        let cursor = sql[..sql.find("SELECT 2").unwrap()].encode_utf16().count();
        let next_cursor = sql[..sql.rfind("SELECT 3").unwrap()].encode_utf16().count();

        assert_eq!(
            super::find_statement_at_cursor_for_database(sql, cursor, DatabaseType::SqlServer),
            "CREATE OR ALTER PROCEDURE dbo.usp_demo\nAS\nBEGIN\n  SELECT 1;\n  SELECT 2;\nEND"
        );
        assert_eq!(super::find_statement_at_cursor_for_database(sql, next_cursor, DatabaseType::SqlServer), "SELECT 3");
    }

    #[test]
    fn sqlserver_current_statement_keeps_alter_procedure_batch() {
        let sql = "\
ALTER PROC dbo.usp_demo
AS
BEGIN
  UPDATE dbo.users SET name = name;
END";
        let cursor = sql[..sql.find("UPDATE").unwrap()].encode_utf16().count();

        assert_eq!(
            super::find_statement_at_cursor_for_database(sql, cursor, DatabaseType::SqlServer),
            "ALTER PROC dbo.usp_demo\nAS\nBEGIN\n  UPDATE dbo.users SET name = name;\nEND"
        );
    }

    #[test]
    fn sqlserver_current_statement_keeps_if_else_control_flow_batch() {
        let sql = "\
IF EXISTS (SELECT 1 FROM ::fn_listextendedproperty('MS_Description','USER','dbo','TABLE','Categories','COLUMN','CategoryID'))
BEGIN
  EXEC sp_updateextendedproperty @name=N'MS_Description', @value=N'test', @level0type=N'USER', @level0name=N'dbo', @level1type=N'TABLE', @level1name=N'Categories', @level2type=N'COLUMN', @level2name=N'CategoryID'
END
ELSE
BEGIN
  EXEC sp_addextendedproperty @name=N'MS_Description', @value=N'test', @level0type=N'USER', @level0name=N'dbo', @level1type=N'TABLE', @level1name=N'Categories', @level2type=N'COLUMN', @level2name=N'CategoryID'
END";
        let update_cursor = sql[..sql.find("sp_updateextendedproperty").unwrap()].encode_utf16().count();
        let add_cursor = sql[..sql.find("sp_addextendedproperty").unwrap()].encode_utf16().count();

        assert_eq!(super::find_statement_at_cursor_for_database(sql, update_cursor, DatabaseType::SqlServer), sql);
        assert_eq!(super::find_statement_at_cursor_for_database(sql, add_cursor, DatabaseType::SqlServer), sql);
    }

    // #13051: a top-level BEGIN TRY ... END TRY BEGIN CATCH ... END CATCH
    // script is one batch, the same as an IF/ELSE control-flow batch.
    #[test]
    fn sqlserver_current_statement_keeps_top_level_try_catch_batch() {
        let sql = "\
BEGIN TRY
    BEGIN TRANSACTION;
    UPDATE dbo.Documents SET Deleted = 0 WHERE Deleted = 1;
    COMMIT TRANSACTION;
END TRY
BEGIN CATCH
    IF @@TRANCOUNT > 0 ROLLBACK TRANSACTION;
    THROW;
END CATCH";
        let update_cursor = sql[..sql.find("UPDATE dbo.Documents").unwrap()].encode_utf16().count();
        let rollback_cursor = sql[..sql.find("ROLLBACK").unwrap()].encode_utf16().count();

        assert_eq!(super::find_statement_at_cursor_for_database(sql, update_cursor, DatabaseType::SqlServer), sql);
        assert_eq!(super::find_statement_at_cursor_for_database(sql, rollback_cursor, DatabaseType::SqlServer), sql);
    }

    #[test]
    fn sqlserver_current_statement_keeps_top_level_plain_begin_block() {
        let sql = "BEGIN\n  SELECT 1;\n  SELECT 2;\nEND";
        let cursor = sql[..sql.find("SELECT 2").unwrap()].encode_utf16().count();

        assert_eq!(super::find_statement_at_cursor_for_database(sql, cursor, DatabaseType::SqlServer), sql);
    }

    #[test]
    fn sqlserver_current_statement_still_splits_begin_transaction_batches() {
        let sql = "BEGIN TRANSACTION;\nUPDATE dbo.T SET x = 1;\nCOMMIT;";
        let cursor = sql[..sql.find("UPDATE").unwrap()].encode_utf16().count();

        assert_eq!(
            super::find_statement_at_cursor_for_database(sql, cursor, DatabaseType::SqlServer),
            "UPDATE dbo.T SET x = 1"
        );
    }

    // #13051: the reported script begins with `SET XACT_ABORT ON;`, so the batch
    // does not start with the block. The statement at the cursor is still found
    // by the enclosing top-level BEGIN TRY ... END CATCH block instead of being
    // `;`-split into a lone `BEGIN TRANSACTION`.
    #[test]
    fn sqlserver_current_statement_keeps_try_catch_after_leading_statement() {
        let sql = "\
SET XACT_ABORT ON;

BEGIN TRY
    BEGIN TRANSACTION;

    UPDATE [dbo].[Documents]
    SET [Deleted] = 0
    WHERE [Deleted] = 1;

    DECLARE @Updated int = @@ROWCOUNT;

    IF EXISTS (SELECT 1 FROM [dbo].[Documents] WHERE [Deleted] = 1)
        THROW 50001, N'Rows with Deleted = 1 still exist.', 1;

    COMMIT TRANSACTION;

    SELECT N'OK' AS Result, @Updated AS RowsUpdated;
END TRY
BEGIN CATCH
    IF @@TRANCOUNT > 0 ROLLBACK TRANSACTION;
    THROW;
END CATCH;";
        let block = sql[sql.find("BEGIN TRY").unwrap()..].trim_end_matches(';');
        let transaction_cursor = sql[..sql.find("BEGIN TRANSACTION").unwrap()].encode_utf16().count();
        let update_cursor = sql[..sql.find("UPDATE [dbo].[Documents]").unwrap()].encode_utf16().count();
        let catch_cursor = sql[..sql.find("BEGIN CATCH").unwrap()].encode_utf16().count();
        let rollback_cursor = sql[..sql.find("ROLLBACK").unwrap()].encode_utf16().count();

        assert_eq!(
            super::find_statement_at_cursor_for_database(sql, transaction_cursor, DatabaseType::SqlServer),
            block
        );
        assert_eq!(super::find_statement_at_cursor_for_database(sql, update_cursor, DatabaseType::SqlServer), block);
        assert_eq!(super::find_statement_at_cursor_for_database(sql, catch_cursor, DatabaseType::SqlServer), block);
        assert_eq!(super::find_statement_at_cursor_for_database(sql, rollback_cursor, DatabaseType::SqlServer), block);
    }

    // The block boundary must not be capped by a token budget: a block whose
    // END is far past the first words still keeps every statement inside it.
    #[test]
    fn sqlserver_current_statement_keeps_long_top_level_block() {
        let body = (0..200).map(|index| format!("    SELECT {index};")).collect::<Vec<_>>().join("\n");
        let sql = format!("SET XACT_ABORT ON;\nBEGIN\n{body}\nEND");
        let cursor = sql[..sql.find("SELECT 199").unwrap()].encode_utf16().count();
        let block = &sql[sql.find("BEGIN").unwrap()..];

        assert_eq!(super::find_statement_at_cursor_for_database(&sql, cursor, DatabaseType::SqlServer), block);

        let plain = format!("BEGIN\n{body}\nEND");
        let cursor = plain[..plain.find("SELECT 199").unwrap()].encode_utf16().count();

        assert_eq!(super::find_statement_at_cursor_for_database(&plain, cursor, DatabaseType::SqlServer), plain);
    }

    #[test]
    fn mysql_hash_comments_split_statements_per_issue_428() {
        let sql = "SELECT 1; # mysql comment\n\nSELECT 2 # trailing comment";
        assert_eq!(
            split_sql_statements_for_database(sql, DatabaseType::Mysql),
            vec!["SELECT 1", "# mysql comment\n\nSELECT 2 # trailing comment"]
        );
    }

    // #13514: a JDBC SQL Server connection splits with the SQL Server profile
    // (the mapped `statement_split_database_type`), so the reported script keeps
    // its TRY/CATCH batch whole while the leading `SET` stays its own statement.
    #[test]
    fn sqlserver_statement_splitter_keeps_try_catch_batch_after_leading_statement() {
        let sql = "\
SET XACT_ABORT ON;

BEGIN TRY
    BEGIN TRANSACTION;

    UPDATE [dbo].[Documents]
    SET [Deleted] = 0
    WHERE [Deleted] = 1;

    DECLARE @Updated int = @@ROWCOUNT;

    IF EXISTS (SELECT 1 FROM [dbo].[Documents] WHERE [Deleted] = 1)
        THROW 50001, N'Rows with Deleted = 1 still exist.', 1;

    COMMIT TRANSACTION;

    SELECT N'OK' AS Result, @Updated AS RowsUpdated;
END TRY
BEGIN CATCH
    IF @@TRANCOUNT > 0 ROLLBACK TRANSACTION;
    THROW;
END CATCH;";
        let block = &sql[sql.find("BEGIN TRY").unwrap()..];

        assert_eq!(
            split_sql_statements_for_database(sql, DatabaseType::SqlServer),
            vec!["SET XACT_ABORT ON".to_string(), block.to_string()]
        );
    }

    // The same script through the generic JDBC profile (no SQL Server signals)
    // keeps its historical split shape: the Oracle-style routine-body handling
    // glues the block opener to the first inner statement, and the rest splits
    // per statement. The `statement_split_database_type` mapping is what opts a
    // connection into the SQL Server rules instead.
    #[test]
    fn jdbc_statement_splitter_still_splits_try_catch_batches() {
        let sql = "BEGIN TRY\n    BEGIN TRANSACTION;\n    UPDATE dbo.T SET x = 1;\nEND TRY\nBEGIN CATCH\n    THROW;\nEND CATCH;";

        assert_eq!(
            split_sql_statements_for_database(sql, DatabaseType::Jdbc),
            vec![
                "BEGIN TRY\n    BEGIN TRANSACTION",
                "UPDATE dbo.T SET x = 1",
                "END TRY\nBEGIN CATCH\n    THROW",
                "END CATCH",
            ]
        );
    }

    #[test]
    fn sqlserver_statement_splitter_keeps_if_block_batch_whole() {
        let sql = "IF NOT EXISTS (SELECT 1 FROM sys.databases WHERE name = N'demo')\nBEGIN\n    CREATE DATABASE demo;\nEND;\nSELECT 1;";

        assert_eq!(
            split_sql_statements_for_database(sql, DatabaseType::SqlServer),
            vec![
                "IF NOT EXISTS (SELECT 1 FROM sys.databases WHERE name = N'demo')\nBEGIN\n    CREATE DATABASE demo;\nEND;",
                "SELECT 1",
            ]
        );
    }

    #[test]
    fn sqlserver_statement_splitter_still_splits_begin_transaction_batches() {
        let sql = "BEGIN TRANSACTION;\nUPDATE dbo.T SET x = 1;\nCOMMIT TRANSACTION;";

        assert_eq!(
            split_sql_statements_for_database(sql, DatabaseType::SqlServer),
            vec!["BEGIN TRANSACTION", "UPDATE dbo.T SET x = 1", "COMMIT TRANSACTION"]
        );
    }

    // The four specs below mirror `sqlStatementRanges.spec.ts` so the backend
    // splitter and the editor range scanner agree on where a control-flow
    // batch ends when its final `END` has no semicolon of its own.
    #[test]
    fn sqlserver_statement_splitter_ends_single_line_if_batch_before_next_statement() {
        let sql = "IF @x = 1 BEGIN SELECT 1; END\nSELECT 999;";

        assert_eq!(
            split_sql_statements_for_database(sql, DatabaseType::SqlServer),
            vec!["IF @x = 1 BEGIN SELECT 1; END", "SELECT 999"]
        );
    }

    #[test]
    fn sqlserver_statement_splitter_ends_try_batch_without_catch_at_end_try() {
        let sql = "BEGIN TRY\n    SELECT 1;\nEND TRY\nSELECT 999;";

        assert_eq!(
            split_sql_statements_for_database(sql, DatabaseType::SqlServer),
            vec!["BEGIN TRY\n    SELECT 1;\nEND TRY", "SELECT 999"]
        );
    }

    #[test]
    fn sqlserver_statement_splitter_ends_if_else_batch_before_next_statement() {
        let batch = "\
IF NOT EXISTS (SELECT 1 FROM dbo.T WHERE n = N'x')
BEGIN
    SELECT 1;
END
ELSE
BEGIN
    SELECT 2;
END";

        assert_eq!(
            split_sql_statements_for_database(&format!("{batch}\nSELECT 999;"), DatabaseType::SqlServer),
            vec![batch.to_string(), "SELECT 999".to_string()]
        );
    }

    #[test]
    fn sqlserver_statement_splitter_ends_if_else_batch_at_else_branch_end_without_semicolon() {
        let batch = "\
IF @x = 1
BEGIN
    SELECT 1;
END
ELSE
BEGIN
    SELECT 2
END";

        assert_eq!(
            split_sql_statements_for_database(&format!("{batch}\nSELECT 999;"), DatabaseType::SqlServer),
            vec![batch.to_string(), "SELECT 999".to_string()]
        );
    }

    #[test]
    fn sqlserver_statement_splitter_keeps_case_end_inside_if_batch() {
        // `CASE ... END` must not close the surrounding `BEGIN` block, so the
        // batch still ends at its own `END`, before the next statement.
        let sql = "IF @x = 1 BEGIN SELECT CASE WHEN 1 = 1 THEN 'a' ELSE 'b' END AS v; END\nSELECT 999;";

        assert_eq!(
            split_sql_statements_for_database(sql, DatabaseType::SqlServer),
            vec!["IF @x = 1 BEGIN SELECT CASE WHEN 1 = 1 THEN 'a' ELSE 'b' END AS v; END", "SELECT 999",]
        );
    }

    #[test]
    fn sqlserver_statement_splitter_ignores_end_conversation_in_batches() {
        let sql = "IF @x = 1 BEGIN SELECT 1; END\nEND CONVERSATION @handle;\nSELECT 999;";

        assert_eq!(
            split_sql_statements_for_database(sql, DatabaseType::SqlServer),
            vec!["IF @x = 1 BEGIN SELECT 1; END", "END CONVERSATION @handle", "SELECT 999",]
        );
    }

    #[test]
    fn sqlserver_statement_splitter_keeps_nested_try_catch_batch_whole() {
        let batch = "\
WHILE @i < 10
BEGIN
    BEGIN TRY
        SELECT 1;
    END TRY
    BEGIN CATCH
        SET @i = @i + 1;
    END CATCH
END";
        let sql = format!("{batch}\nSELECT 999;");

        assert_eq!(
            split_sql_statements_for_database(&sql, DatabaseType::SqlServer),
            vec![batch.to_string(), "SELECT 999".to_string()]
        );
    }

    #[test]
    fn mysql_delimiter_command_keeps_procedure_body_together_per_issue_1978() {
        let sql = "\
-- ----------------------------
-- Procedure structure for fix_collation
-- ----------------------------
DROP PROCEDURE IF EXISTS `fix_collation`;
delimiter ;;
CREATE PROCEDURE `fix_collation`()
BEGIN
DECLARE done INT DEFAULT FALSE;
DECLARE tbl_name VARCHAR(255);
DECLARE cur CURSOR FOR
SELECT TABLE_NAME FROM information_schema.TABLES
WHERE TABLE_SCHEMA = DATABASE() AND TABLE_COLLATION = 'utf8mb4_0900_ai_ci';
DECLARE CONTINUE HANDLER FOR NOT FOUND SET done = TRUE;

    OPEN cur;
    read_loop: LOOP
        FETCH cur INTO tbl_name;
        IF done THEN LEAVE read_loop; END IF;
        SET @sql = CONCAT('ALTER TABLE `', tbl_name, '` CONVERT TO CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci');
        PREPARE stmt FROM @sql;
        EXECUTE stmt;
        DEALLOCATE PREPARE stmt;
    END LOOP;
    CLOSE cur;
END
;;
delimiter ;";

        assert_eq!(
            split_sql_statements_for_database(sql, DatabaseType::Mysql),
            vec![
                "-- ----------------------------\n-- Procedure structure for fix_collation\n-- ----------------------------\nDROP PROCEDURE IF EXISTS `fix_collation`",
                "CREATE PROCEDURE `fix_collation`()\nBEGIN\nDECLARE done INT DEFAULT FALSE;\nDECLARE tbl_name VARCHAR(255);\nDECLARE cur CURSOR FOR\nSELECT TABLE_NAME FROM information_schema.TABLES\nWHERE TABLE_SCHEMA = DATABASE() AND TABLE_COLLATION = 'utf8mb4_0900_ai_ci';\nDECLARE CONTINUE HANDLER FOR NOT FOUND SET done = TRUE;\n\n    OPEN cur;\n    read_loop: LOOP\n        FETCH cur INTO tbl_name;\n        IF done THEN LEAVE read_loop; END IF;\n        SET @sql = CONCAT('ALTER TABLE `', tbl_name, '` CONVERT TO CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci');\n        PREPARE stmt FROM @sql;\n        EXECUTE stmt;\n        DEALLOCATE PREPARE stmt;\n    END LOOP;\n    CLOSE cur;\nEND",
            ]
        );
    }

    #[test]
    fn mysql_current_statement_ignores_delimiter_command_semicolon_per_issue_1978() {
        let sql = "\
delimiter ;;
CREATE PROCEDURE `fix_collation`()
BEGIN
    SET @sql = CONCAT('ALTER TABLE `', 't', '` CONVERT TO CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci');
    PREPARE stmt FROM @sql;
    EXECUTE stmt;
END
;;
delimiter ;";
        let cursor = sql[..sql.find("PREPARE").unwrap()].encode_utf16().count();

        assert_eq!(
            find_statement_at_cursor_for_database(sql, cursor, DatabaseType::Mysql),
            "CREATE PROCEDURE `fix_collation`()\nBEGIN\n    SET @sql = CONCAT('ALTER TABLE `', 't', '` CONVERT TO CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci');\n    PREPARE stmt FROM @sql;\n    EXECUTE stmt;\nEND"
        );
    }

    #[test]
    fn mysql_repeated_delimiter_command_does_not_emit_directive_or_panic() {
        let sql = r#"DELIMITER ;;
drop procedure if exists p_ludp_data_table_scripts;;
delimiter ;;
create procedure p_ludp_data_table_scripts()
begin
    -- 定义变量,存储表及字段存在状态
   declare filedExist INT DEFAULT 0;
   declare currentDatabaseName VARCHAR(200) DEFAULT '';
   declare tableCount INT DEFAULT 0;

end ;;
call p_ludp_data_table_scripts();"#;

        let expected = vec![
            "drop procedure if exists p_ludp_data_table_scripts",
            "create procedure p_ludp_data_table_scripts()\nbegin\n    -- 定义变量,存储表及字段存在状态\n   declare filedExist INT DEFAULT 0;\n   declare currentDatabaseName VARCHAR(200) DEFAULT '';\n   declare tableCount INT DEFAULT 0;\n\nend",
            "call p_ludp_data_table_scripts();",
        ];
        assert_eq!(split_sql_statements_for_database(sql, DatabaseType::Mysql), expected);

        let ranges =
            split_sql_statement_ranges_with_options(sql, SqlParsingOptions::for_database_type(DatabaseType::Mysql));
        assert_eq!(ranges.iter().map(|range| range.text.as_str()).collect::<Vec<_>>(), expected);

        let cursor = sql[..sql.find("declare currentDatabaseName").unwrap()].encode_utf16().count();
        assert_eq!(find_statement_at_cursor_for_database(sql, cursor, DatabaseType::Mysql), expected[1]);

        let mut splitter =
            SqlStatementSplitter::with_options(SqlParsingOptions::for_database_type(DatabaseType::Mysql));
        let mut streamed = Vec::new();
        for ch in sql.chars() {
            streamed.extend(splitter.push_chunk(&ch.to_string()));
        }
        streamed.extend(splitter.finish());
        assert_eq!(streamed, expected);
    }

    #[test]
    fn mysql_delimiter_command_skips_empty_custom_delimiter_statement_per_issue_1988() {
        let sql = "\
select COUNT(1) FROM your_table;
delimiter ;;
select COUNT(1) FROM your_table;

;;
delimiter ;";

        assert_eq!(
            split_sql_statements_for_database(sql, DatabaseType::Mysql),
            vec!["select COUNT(1) FROM your_table", "select COUNT(1) FROM your_table;"]
        );
    }

    #[test]
    fn mysql_delimiter_command_ranges_skip_empty_custom_delimiter_statement_per_issue_1988() {
        let sql = "\
select COUNT(1) FROM your_table;
delimiter ;;
select COUNT(1) FROM your_table;

;;
delimiter ;";

        let ranges =
            split_sql_statement_ranges_with_options(sql, SqlParsingOptions::for_database_type(DatabaseType::Mysql));

        assert_eq!(
            ranges.iter().map(|range| range.text.as_str()).collect::<Vec<_>>(),
            vec!["select COUNT(1) FROM your_table", "select COUNT(1) FROM your_table;"]
        );
    }

    #[test]
    fn mysql_current_statement_keeps_inline_hash_comment_per_issue_428() {
        let sql = "SELECT 1; # mysql comment\n\nSELECT 2 # trailing comment";
        let cursor = sql[..sql.find("SELECT 2").unwrap()].encode_utf16().count();
        assert_eq!(
            find_statement_at_cursor_for_database(sql, cursor, DatabaseType::Mysql),
            "SELECT 2 # trailing comment"
        );
    }

    #[test]
    fn mysql_current_statement_preserves_only_exact_tdsql_proxy_directive() {
        let sql = "SELECT 1;\n/*proxy*/ \n\tSHOW PROXY STATUS;\nSELECT 2;";
        let cursor = sql[..sql.find("STATUS").unwrap()].encode_utf16().count();

        assert_eq!(
            find_statement_at_cursor_for_database(sql, cursor, DatabaseType::Mysql),
            "/*proxy*/ \n\tSHOW PROXY STATUS"
        );
        assert_eq!(
            split_sql_statements_for_database(sql, DatabaseType::Mysql),
            vec!["SELECT 1", "/*proxy*/ \n\tSHOW PROXY STATUS", "SELECT 2"]
        );
        for inline in [
            "/*proxy*/SHOW PROXY STATUS",
            "/* ordinary */\n/*proxy*/SHOW PROXY STATUS",
            "/*+ route */\n/*proxy*/SHOW PROXY STATUS",
        ] {
            let cursor = inline[..inline.find("STATUS").unwrap()].encode_utf16().count();
            assert_eq!(
                find_statement_at_cursor_for_database(inline, cursor, DatabaseType::Mysql),
                "/*proxy*/SHOW PROXY STATUS"
            );
        }
        assert!(split_sql_statements_for_database("/*proxy*/", DatabaseType::Mysql).is_empty());
    }

    #[test]
    fn mysql_current_statement_preserves_same_line_tdsql_directives_without_an_allowlist() {
        for directive in ["/*sets:allsets */", "/*master*/", "/*slave:set_1781591902_7*/", "/*future-route:anywhere*/"]
        {
            let sql = format!("{directive} SELECT count(*) FROM tenant_table");
            let cursor = sql[..sql.find("tenant_table").unwrap()].encode_utf16().count();

            assert_eq!(find_statement_at_cursor_for_database(&sql, cursor, DatabaseType::Mysql), sql);
            assert_eq!(split_sql_statements_for_database(&sql, DatabaseType::Mysql), vec![sql]);
        }
    }

    #[test]
    fn mysql_current_statement_strips_generic_tdsql_style_directive_on_a_separate_line() {
        let sql = "/*sets:allsets */\nSELECT count(*) FROM tenant_table";
        let cursor = sql[..sql.find("tenant_table").unwrap()].encode_utf16().count();

        assert_eq!(
            find_statement_at_cursor_for_database(sql, cursor, DatabaseType::Mysql),
            "SELECT count(*) FROM tenant_table"
        );
    }

    #[test]
    fn other_databases_strip_same_line_tdsql_style_directives() {
        let sql = "/*sets:allsets */ SELECT count(*) FROM tenant_table";
        let cursor = sql[..sql.find("tenant_table").unwrap()].encode_utf16().count();

        assert_eq!(
            find_statement_at_cursor_for_database(sql, cursor, DatabaseType::Postgres),
            "SELECT count(*) FROM tenant_table"
        );
    }

    #[test]
    fn db2_current_statement_skips_complete_nested_comments() {
        let sql = "/* outer /* inner */ trailing */ SELECT IBMREQD FROM SYSIBM.SYSDUMMY1;";
        let cursor = sql.encode_utf16().count();
        assert_eq!(
            find_statement_at_cursor_for_database(sql, cursor, DatabaseType::Db2),
            "SELECT IBMREQD FROM SYSIBM.SYSDUMMY1"
        );
        let script = "/* outer /* SELECT 99; */ DELETE FROM hidden; */ VALUES 1; VALUES 2;";
        assert_eq!(
            split_sql_statements_for_database(script, DatabaseType::Db2),
            vec!["/* outer /* SELECT 99; */ DELETE FROM hidden; */ VALUES 1", "VALUES 2"]
        );
    }
    #[test]
    fn mysql_current_statement_strips_other_leading_block_comments() {
        for comment in ["/* ordinary */", "/*unknown*/", "/* proxy */", "/*PROXY*/"] {
            let sql = format!("{comment}\nSHOW PROXY STATUS");
            let cursor = sql[..sql.find("STATUS").unwrap()].encode_utf16().count();

            assert_eq!(find_statement_at_cursor_for_database(&sql, cursor, DatabaseType::Mysql), "SHOW PROXY STATUS");
        }

        for separated in ["/*proxy*/\n/* audit */\nSHOW PROXY STATUS", "/*proxy*/\n-- audit\nSHOW PROXY STATUS"] {
            let cursor = separated[..separated.find("STATUS").unwrap()].encode_utf16().count();
            assert_eq!(
                find_statement_at_cursor_for_database(separated, cursor, DatabaseType::Mysql),
                "SHOW PROXY STATUS"
            );
        }

        let postgres = "/*proxy*/\nSHOW PROXY STATUS";
        let cursor = postgres[..postgres.find("STATUS").unwrap()].encode_utf16().count();
        assert_eq!(
            find_statement_at_cursor_for_database(postgres, cursor, DatabaseType::Postgres),
            "SHOW PROXY STATUS"
        );

        let followed_by_hint = "/*proxy*/\n/*+ route */\nSHOW PROXY STATUS";
        let cursor = followed_by_hint[..followed_by_hint.find("STATUS").unwrap()].encode_utf16().count();
        assert_eq!(
            find_statement_at_cursor_for_database(followed_by_hint, cursor, DatabaseType::Mysql),
            "SHOW PROXY STATUS"
        );
    }

    #[test]
    fn mysql_single_statement_with_inline_comment_stays_executable_per_issue_428() {
        let sql = "SELECT 1 # mysql comment";
        let cursor = sql.encode_utf16().count();
        assert_eq!(find_statement_at_cursor_for_database(sql, cursor, DatabaseType::Mysql), "SELECT 1 # mysql comment");
    }
}

#[cfg(test)]
mod editor_encoding_tests {
    use super::*;
    #[test]
    fn utf16_bytes_and_round_trip() {
        for (encoding, expected) in [
            ("utf16le", vec![0xff, 0xfe, 0x41, 0, 0x2d, 0x4e, 0x3d, 0xd8, 0, 0xde]),
            ("utf16be", vec![0xfe, 0xff, 0, 0x41, 0x4e, 0x2d, 0xd8, 0x3d, 0xde, 0]),
        ] {
            let bytes = encode_sql_file_text("A中😀", encoding).unwrap();
            assert_eq!(bytes, expected);
            assert_eq!(decode_sql_file_bytes_with_encoding(&bytes, encoding).unwrap(), "A中😀");
        }
    }
}