package gudusoft.gsqlparser.sqlcmds;

import gudusoft.gsqlparser.EDbVendor;
import gudusoft.gsqlparser.EFindSqlStateType;
import gudusoft.gsqlparser.ESqlStatementType;
import gudusoft.gsqlparser.TBaseType;
import gudusoft.gsqlparser.TCustomSqlStatement;
import gudusoft.gsqlparser.TSourceToken;
import gudusoft.gsqlparser.stmt.TUnknownSqlStatement;
import gudusoft.gsqlparser.stmt.oceanbase.TAlterOutlineSqlStatement;
import gudusoft.gsqlparser.stmt.oceanbase.TAlterResourcePoolSqlStatement;
import gudusoft.gsqlparser.stmt.oceanbase.TAlterSystemSqlStatement;
import gudusoft.gsqlparser.stmt.oceanbase.TAlterResourceUnitSqlStatement;
import gudusoft.gsqlparser.stmt.oceanbase.TAlterTablegroupSqlStatement;
import gudusoft.gsqlparser.stmt.oceanbase.TAlterTenantSqlStatement;
import gudusoft.gsqlparser.stmt.oceanbase.TCreateOutlineSqlStatement;
import gudusoft.gsqlparser.stmt.oceanbase.TCreateResourcePoolSqlStatement;
import gudusoft.gsqlparser.stmt.oceanbase.TCreateResourceUnitSqlStatement;
import gudusoft.gsqlparser.stmt.oceanbase.TCreateTablegroupSqlStatement;
import gudusoft.gsqlparser.stmt.oceanbase.TCreateTenantSqlStatement;
import gudusoft.gsqlparser.stmt.oceanbase.TDropOutlineSqlStatement;
import gudusoft.gsqlparser.stmt.oceanbase.TDropResourcePoolSqlStatement;
import gudusoft.gsqlparser.stmt.oceanbase.TDropResourceUnitSqlStatement;
import gudusoft.gsqlparser.stmt.oceanbase.TDropTablegroupSqlStatement;
import gudusoft.gsqlparser.stmt.oceanbase.TDropTenantSqlStatement;
import gudusoft.gsqlparser.stmt.oceanbase.TFlashbackSqlStatement;
import gudusoft.gsqlparser.stmt.oceanbase.TPurgeSqlStatement;
import gudusoft.gsqlparser.stmt.oceanbase.TShowTenantSqlStatement;
import gudusoft.gsqlparser.stmt.oceanbase.TCreateDblinkSqlStatement;
import gudusoft.gsqlparser.stmt.oceanbase.TDropDblinkSqlStatement;
import gudusoft.gsqlparser.stmt.oceanbase.TCreateRestorePointSqlStatement;
import gudusoft.gsqlparser.stmt.oceanbase.TDropRestorePointSqlStatement;
import gudusoft.gsqlparser.stmt.oceanbase.TXaSqlStatement;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * OceanBase SQL command resolver — Phase 1 skeleton.
 *
 * <p>OceanBase user tenants in MySQL mode and the {@code sys} system tenant
 * share the MySQL command surface, so this resolver inherits all MySQL
 * command patterns from {@link TSqlCmdsMysql} via subclassing. The
 * vendor field is then re-tagged to {@link EDbVendor#dbvoceanbase} so any
 * statement constructed via the inherited resolver carries OceanBase
 * vendor identity.
 *
 * <p>For Phase 1 we additionally register a small set of unmistakable
 * OceanBase administrative DDL prefixes ({@code CREATE TENANT},
 * {@code ALTER TENANT}, {@code DROP TENANT}, {@code ALTER SYSTEM},
 * {@code CREATE/ALTER RESOURCE POOL}, {@code CREATE/ALTER RESOURCE UNIT})
 * so the splitter recognizes them as statement boundaries in multi-statement
 * admin scripts. These statements are tagged {@link ESqlStatementType#sstunknown}
 * because Phase 1 has no AST nodes for them yet — Phase 4 will add proper
 * AST classes and replace {@code sstunknown} with vendor-specific types
 * such as {@code sstoceanbase_create_tenant}.
 *
 * <h2>Mode awareness</h2>
 *
 * <p>This class is constructed once per {@link gudusoft.gsqlparser.TGSqlParser}
 * instance via {@link SqlCmdsFactory}, before the user has had a chance to
 * call {@code setOBTenantMode}. So a single {@code TSqlCmdsOceanbase}
 * cannot select between MySQL-family and Oracle-family command sets at
 * construction time. Phase 1 deliberately accepts a MySQL-family command
 * surface here because:
 * <ul>
 *   <li>The Oracle delegate ({@link gudusoft.gsqlparser.parser.OracleSqlParser})
 *       used by {@code OceanBaseSqlParser} for {@code ORACLE} mode has its
 *       own internal {@link TSqlCmdsOracle} that handles PL/SQL boundary
 *       detection independently of this class.</li>
 *   <li>The {@code TGSqlParser}-level {@code sqlcmds} field is consulted
 *       primarily for validation and post-processing of MySQL-family
 *       statements; ORACLE-mode dbvoceanbase scripts that exercise this
 *       class are a Phase 4 concern.</li>
 * </ul>
 *
 * <p>Phase 4 will revisit whether {@code TSqlCmdsOceanbase} should grow
 * mode-awareness via a separate factory dispatch path or whether it should
 * be split into {@code TSqlCmdsOceanbaseMysql} / {@code TSqlCmdsOceanbaseOracle}
 * with the active instance selected from {@code EOBTenantMode}.
 *
 * @see TSqlCmdsMysql
 * @see SqlCmdsFactory
 * @see gudusoft.gsqlparser.EOBTenantMode
 * @since 4.0.1.4
 */
public class TSqlCmdsOceanbase extends TSqlCmdsMysql {

    public TSqlCmdsOceanbase() {
        super();
        // Re-tag the inherited vendor field so statements constructed via
        // the inherited resolver carry OceanBase identity rather than MySQL.
        // AbstractSqlCmds#vendor is protected and non-final.
        this.vendor = EDbVendor.dbvoceanbase;
    }

    @Override
    protected void initializeCommands() {
        // Step 1 — inherit the MySQL command surface verbatim.
        super.initializeCommands();

        // Step 2 — register OceanBase administrative DDL prefixes for
        // boundary detection only. These are tagged sstunknown for Phase 1;
        // Phase 4 will replace with proper sstoceanbase_* statement types
        // and dedicated AST classes.
        //
        // Per ADR-7 and AskUserQuestion #3 (D12), the scope is intentionally
        // narrow: only unmistakable system-tenant verbs that cannot conflict
        // with MySQL DDL of the same shape. We do NOT auto-promote the
        // tenant mode based on these prefixes; that is the caller's
        // responsibility via TGSqlParser.setOBTenantMode(SYSTEM).

        // CREATE TENANT / ALTER TENANT / DROP TENANT
        // Phase 4 Batch 1: boundary tags now reflect the real statement
        // types constructed by the oceanbasemysql grammar.
        addCmd(TBaseType.rrw_create, "tenant", " ", " ", " ", " ", " ",
                ESqlStatementType.sstoceanbase_create_tenant);
        addCmd(TBaseType.rrw_alter,  "tenant", " ", " ", " ", " ", " ",
                ESqlStatementType.sstoceanbase_alter_tenant);
        addCmd(TBaseType.rrw_drop,   "tenant", " ", " ", " ", " ", " ",
                ESqlStatementType.sstoceanbase_drop_tenant);

        // ALTER SYSTEM (Phase 4 Batch 3 + 10)
        addCmd(TBaseType.rrw_alter, "system", " ", " ", " ", " ", " ",
                ESqlStatementType.sstoceanbase_alter_system);

        // CREATE/ALTER/DROP RESOURCE POOL
        // Phase 4 Batch 2: boundary tags now reflect the real statement
        // types constructed by the oceanbasemysql grammar.
        addCmd(TBaseType.rrw_create, "resource", "pool", " ", " ", " ", " ",
                ESqlStatementType.sstoceanbase_create_resource_pool);
        addCmd(TBaseType.rrw_alter,  "resource", "pool", " ", " ", " ", " ",
                ESqlStatementType.sstoceanbase_alter_resource_pool);
        addCmd(TBaseType.rrw_drop,   "resource", "pool", " ", " ", " ", " ",
                ESqlStatementType.sstoceanbase_drop_resource_pool);

        // CREATE/ALTER/DROP RESOURCE UNIT
        addCmd(TBaseType.rrw_create, "resource", "unit", " ", " ", " ", " ",
                ESqlStatementType.sstoceanbase_create_resource_unit);
        addCmd(TBaseType.rrw_alter,  "resource", "unit", " ", " ", " ", " ",
                ESqlStatementType.sstoceanbase_alter_resource_unit);
        addCmd(TBaseType.rrw_drop,   "resource", "unit", " ", " ", " ", " ",
                ESqlStatementType.sstoceanbase_drop_resource_unit);

        // CREATE/ALTER/DROP TABLEGROUP (Phase 4 Batch 6)
        addCmd(TBaseType.rrw_create, "tablegroup", " ", " ", " ", " ", " ",
                ESqlStatementType.sstoceanbase_create_tablegroup);
        addCmd(TBaseType.rrw_alter,  "tablegroup", " ", " ", " ", " ", " ",
                ESqlStatementType.sstoceanbase_alter_tablegroup);
        addCmd(TBaseType.rrw_drop,   "tablegroup", " ", " ", " ", " ", " ",
                ESqlStatementType.sstoceanbase_drop_tablegroup);

        // CREATE [GLOBAL|LOCAL] INDEX (Phase 4 Batch 7)
        // MySQL base knows CREATE INDEX but not CREATE GLOBAL/LOCAL INDEX.
        // Map the OceanBase adjective-prefixed forms to the same
        // sstmysqlcreateindex type so existing index tooling keeps working.
        addCmd(TBaseType.rrw_create, "global", "index", " ", " ", " ", " ",
                ESqlStatementType.sstmysqlcreateindex);
        addCmd(TBaseType.rrw_create, "local",  "index", " ", " ", " ", " ",
                ESqlStatementType.sstmysqlcreateindex);
        addCmd(TBaseType.rrw_create, "unique", "global", "index", " ", " ", " ",
                ESqlStatementType.sstmysqlcreateindex);
        addCmd(TBaseType.rrw_create, "unique", "local",  "index", " ", " ", " ",
                ESqlStatementType.sstmysqlcreateindex);

        // OceanBase documented syntax gaps — system-tenant SHOW family.
        // SHOW TENANT / SHOW TENANT LIKE 'pattern' / SHOW CREATE TENANT
        // name / SHOW RESOURCE POOL are OB-only variants that the
        // inherited MySQL splitter does not know about, so the splitter
        // falls through with "Error when tokenize near SHOW" before the
        // grammar ever gets a chance to run. Register them here under a
        // single umbrella enum; the grammar production
        // showOceanBaseTenantStmt builds a distinct AST that carries the
        // variant discriminator and any captured tenant name / LIKE
        // pattern.
        addCmd(TBaseType.rrw_show, "tenant", " ", " ", " ", " ", " ",
                ESqlStatementType.sstoceanbase_show_tenant);
        addCmd(TBaseType.rrw_show, "create", "tenant", " ", " ", " ", " ",
                ESqlStatementType.sstoceanbase_show_tenant);
        addCmd(TBaseType.rrw_show, "resource", "pool", " ", " ", " ", " ",
                ESqlStatementType.sstoceanbase_show_tenant);

        // US-007 — SHOW extensions
        addCmd(TBaseType.rrw_show, "tenants", " ", " ", " ", " ", " ",
                ESqlStatementType.sstoceanbase_show_tenant);
        addCmd(TBaseType.rrw_show, "recyclebin", " ", " ", " ", " ", " ",
                ESqlStatementType.sstoceanbase_show_tenant);
        addCmd(TBaseType.rrw_show, "tablegroups", " ", " ", " ", " ", " ",
                ESqlStatementType.sstoceanbase_show_tenant);
        addCmd(TBaseType.rrw_show, "parameters", " ", " ", " ", " ", " ",
                ESqlStatementType.sstoceanbase_show_tenant);

        // MERGE INTO (US-002) — boundary tag for MERGE statement
        addCmd(TBaseType.rrw_merge, ESqlStatementType.sstmerge);

        // FLASHBACK TABLE / FLASHBACK DATABASE / FLASHBACK TENANT (US-003, US-001 Round 3)
        addCmd(TBaseType.rrw_flashback, "table", " ", " ", " ", " ", " ",
                ESqlStatementType.sstoceanbase_flashback);
        addCmd(TBaseType.rrw_flashback, "database", " ", " ", " ", " ", " ",
                ESqlStatementType.sstoceanbase_flashback);
        addCmd(TBaseType.rrw_flashback, "tenant", " ", " ", " ", " ", " ",
                ESqlStatementType.sstoceanbase_flashback);

        // PURGE TABLE / PURGE DATABASE / PURGE RECYCLEBIN (US-003)
        addCmd(TBaseType.rrw_purge, "table", " ", " ", " ", " ", " ",
                ESqlStatementType.sstoceanbase_purge);
        addCmd(TBaseType.rrw_purge, "database", " ", " ", " ", " ", " ",
                ESqlStatementType.sstoceanbase_purge);
        addCmd(TBaseType.rrw_purge, "recyclebin", " ", " ", " ", " ", " ",
                ESqlStatementType.sstoceanbase_purge);
        // PURGE INDEX / PURGE TENANT (US-001 Round 2)
        addCmd(TBaseType.rrw_purge, "index", " ", " ", " ", " ", " ",
                ESqlStatementType.sstoceanbase_purge);
        addCmd(TBaseType.rrw_purge, "tenant", " ", " ", " ", " ", " ",
                ESqlStatementType.sstoceanbase_purge);

        // CREATE TABLESPACE / DROP TABLESPACE (US-001 Round 2).
        // The MySQL base now registers these heads too (with sstmysql* types),
        // so override the inherited entries in place instead of appending
        // duplicates that lose the first-registered tie.
        overrideCmd(TBaseType.rrw_create, "tablespace", "",
                ESqlStatementType.sstcreateTablespace);
        overrideCmd(TBaseType.rrw_drop, "tablespace", "",
                ESqlStatementType.sstcreateTablespace);

        // ALTER USER / CREATE ROLE / DROP ROLE (US-002 Round 2)
        overrideCmd(TBaseType.rrw_alter, "user", "",
                ESqlStatementType.sstalteruser);
        addCmd(TBaseType.rrw_create, "role", " ", " ", " ", " ", " ",
                ESqlStatementType.sstcreaterole);
        addCmd(TBaseType.rrw_drop, "role", " ", " ", " ", " ", " ",
                ESqlStatementType.sstdroprole);

        // ALTER SEQUENCE (US-009) — MySQL base has CREATE/DROP SEQUENCE
        // but not ALTER SEQUENCE. OceanBase supports ALTER SEQUENCE for
        // modifying sequence properties (INCREMENT BY, MAXVALUE, etc.).
        addCmd(TBaseType.rrw_alter, "sequence", " ", " ", " ", " ", " ",
                ESqlStatementType.sstaltersequence);

        // CREATE/ALTER/DROP OUTLINE (Phase 4 Batch 8)
        // Reuse Oracle's existing sstoracle*outline enum values per ADR-8
        // — OUTLINE is not a MySQL construct, so the base MySQL resolver
        // knows nothing about these types. Our issql override maps them
        // to the OceanBase statement classes.
        addCmd(TBaseType.rrw_create, "outline", " ", " ", " ", " ", " ",
                ESqlStatementType.sstoraclecreateoutline);
        addCmd(TBaseType.rrw_create, "or", "replace", "outline", " ", " ", " ",
                ESqlStatementType.sstoraclecreateoutline);
        addCmd(TBaseType.rrw_alter,  "outline", " ", " ", " ", " ", " ",
                ESqlStatementType.sstoraclealteroutline);
        addCmd(TBaseType.rrw_drop,   "outline", " ", " ", " ", " ", " ",
                ESqlStatementType.sstoracledropoutline);

        // XA transaction statements (US-004 Round 3)
        // XA START/END/PREPARE/COMMIT/ROLLBACK/RECOVER 'xid'
        addCmd(TBaseType.rrw_oceanbase_xa, " ", " ", " ", " ", " ", " ",
                ESqlStatementType.sstoceanbase_xa);

        // CREATE/DROP DBLINK (US-005 Round 3)
        addCmd(TBaseType.rrw_create, "dblink", " ", " ", " ", " ", " ",
                ESqlStatementType.sstoceanbase_create_dblink);
        addCmd(TBaseType.rrw_drop, "dblink", " ", " ", " ", " ", " ",
                ESqlStatementType.sstoceanbase_drop_dblink);

        // CREATE/DROP RESTORE POINT (US-006 Round 3)
        addCmd(TBaseType.rrw_create, "restore", "point", " ", " ", " ", " ",
                ESqlStatementType.sstoceanbase_create_restore_point);
        addCmd(TBaseType.rrw_drop, "restore", "point", " ", " ", " ", " ",
                ESqlStatementType.sstoceanbase_drop_restore_point);
    }

    @Override
    protected String getToken1Str(int token1) {
        if (token1 == TBaseType.rrw_oceanbase_xa) {
            return "XA";
        }
        return super.getToken1Str(token1);
    }

    // ================================================================
    // Statement construction override — Phase 4 Batch 1
    // ================================================================

    /**
     * {@inheritDoc}
     *
     * <p>The inherited {@link TSqlCmdsMysql#issql} switch statement does not
     * know about {@code sstoceanbase_*} enum values and routes them to its
     * {@code default} branch, which produces a {@link TUnknownSqlStatement}.
     * This override intercepts the result and swaps in the proper OceanBase
     * statement class when a tenant-family type is detected, preserving the
     * splitter's tag on the returned instance.
     */
    @Override
    public TCustomSqlStatement issql(TSourceToken pcst,
                                     EFindSqlStateType pstate,
                                     TCustomSqlStatement psqlstatement) {
        TCustomSqlStatement ret = super.issql(pcst, pstate, psqlstatement);
        if (ret instanceof TUnknownSqlStatement) {
            switch (ret.sqlstatementtype) {
                case sstoceanbase_create_tenant:
                    return new TCreateTenantSqlStatement(vendor);
                case sstoceanbase_alter_tenant:
                    return new TAlterTenantSqlStatement(vendor);
                case sstoceanbase_drop_tenant:
                    return new TDropTenantSqlStatement(vendor);
                case sstoceanbase_create_resource_pool:
                    return new TCreateResourcePoolSqlStatement(vendor);
                case sstoceanbase_alter_resource_pool:
                    return new TAlterResourcePoolSqlStatement(vendor);
                case sstoceanbase_drop_resource_pool:
                    return new TDropResourcePoolSqlStatement(vendor);
                case sstoceanbase_create_resource_unit:
                    return new TCreateResourceUnitSqlStatement(vendor);
                case sstoceanbase_alter_resource_unit:
                    return new TAlterResourceUnitSqlStatement(vendor);
                case sstoceanbase_drop_resource_unit:
                    return new TDropResourceUnitSqlStatement(vendor);
                case sstoceanbase_create_tablegroup:
                    return new TCreateTablegroupSqlStatement(vendor);
                case sstoceanbase_alter_tablegroup:
                    return new TAlterTablegroupSqlStatement(vendor);
                case sstoceanbase_drop_tablegroup:
                    return new TDropTablegroupSqlStatement(vendor);
                // Phase 4 Batch 8 — OUTLINE DDL reuses Oracle's existing
                // enums per ADR-8
                case sstoraclecreateoutline:
                    return new TCreateOutlineSqlStatement(vendor);
                case sstoraclealteroutline:
                    return new TAlterOutlineSqlStatement(vendor);
                case sstoracledropoutline:
                    return new TDropOutlineSqlStatement(vendor);
                // Phase 4 Batch 3 + 10 — ALTER SYSTEM
                case sstoceanbase_alter_system:
                    return new TAlterSystemSqlStatement(vendor);
                // OceanBase documented syntax gaps — SHOW TENANT family
                case sstoceanbase_show_tenant:
                    return new TShowTenantSqlStatement(vendor);
                // US-003 — FLASHBACK / PURGE
                case sstoceanbase_flashback:
                    return new TFlashbackSqlStatement(vendor);
                case sstoceanbase_purge:
                    return new TPurgeSqlStatement(vendor);
                // US-004 Round 3 — XA transaction
                case sstoceanbase_xa:
                    return new TXaSqlStatement(vendor);
                // US-005 Round 3 — DBLINK DDL
                case sstoceanbase_create_dblink:
                    return new TCreateDblinkSqlStatement(vendor);
                case sstoceanbase_drop_dblink:
                    return new TDropDblinkSqlStatement(vendor);
                // US-006 Round 3 — RESTORE POINT
                case sstoceanbase_create_restore_point:
                    return new TCreateRestorePointSqlStatement(vendor);
                case sstoceanbase_drop_restore_point:
                    return new TDropRestorePointSqlStatement(vendor);
                default:
                    break;
            }
        }
        return ret;
    }

    // ================================================================
    // System-tenant prefix diagnostic (used by OceanBaseSqlParser when
    // the active tenant mode is ORACLE)
    // ================================================================

    /**
     * Regex anchored at a statement boundary ({@code ^} or {@code ;}) that
     * matches only OceanBase system-tenant DDL forms that have no Oracle
     * equivalent.
     *
     * <p><b>Why this list is strictly smaller than the splitter list.</b>
     * {@code initializeCommands()} registers {@code ALTER SYSTEM} as a
     * boundary prefix because the splitter just uses it to split raw
     * statements and never promotes the tenant mode. But {@code ALTER
     * SYSTEM} is also legitimate Oracle DBA syntax ({@code ALTER SYSTEM
     * KILL SESSION}, {@code ALTER SYSTEM FLUSH SHARED_POOL}, etc.), and
     * OceanBase Oracle-mode tenants accept a subset of those forms too.
     * Flagging {@code ALTER SYSTEM} from ORACLE mode would produce false
     * positives on perfectly legal scripts. Only the verbs that do not
     * exist in Oracle at all — {@code CREATE/ALTER/DROP TENANT} and
     * {@code CREATE/ALTER/DROP RESOURCE POOL|UNIT} — are safe to flag.
     *
     * <p>The regex is case-insensitive and requires a word boundary after
     * the prefix so {@code CREATE TENANTS_VIEW} (hypothetical) would not
     * false-match.
     */
    private static final Pattern SYSTEM_DDL_PREFIX_PATTERN = Pattern.compile(
            "(?i)(?:^|;)\\s*(" +
                    "create\\s+tenant|" +
                    "alter\\s+tenant|" +
                    "drop\\s+tenant|" +
                    "(?:create|alter|drop)\\s+resource\\s+(?:pool|unit)" +
            ")\\b"
    );

    private static final Pattern BLOCK_COMMENT_PATTERN =
            Pattern.compile("/\\*[\\s\\S]*?\\*/");
    private static final Pattern LINE_COMMENT_PATTERN =
            Pattern.compile("--[^\\n]*");
    private static final Pattern SINGLE_QUOTE_STRING_PATTERN =
            Pattern.compile("'(?:''|[^'])*'");
    private static final Pattern DOUBLE_QUOTE_IDENT_PATTERN =
            Pattern.compile("\"(?:\"\"|[^\"])*\"");

    /**
     * Scan {@code sqltext} for an unmistakable OceanBase system-tenant DDL
     * prefix at a statement boundary. Comments and string literals are
     * masked before the scan so text inside them cannot trigger a false
     * positive.
     *
     * <p>This helper exists so {@code OceanBaseSqlParser} can emit a
     * targeted error when a user submits system-tenant DDL while the
     * parser is in {@code EOBTenantMode.ORACLE}, matching the real
     * OceanBase server's "wrong tenant" rejection with a clearer
     * message than a raw Oracle yacc syntax error at the {@code TENANT}
     * token.
     *
     * <p>Per ADR-7 the check is narrow by design and the caller still
     * owns mode selection — this helper reports; it never promotes.
     *
     * @param sqltext the raw SQL script to scan; may be null
     * @return a canonical uppercase prefix name (for example
     *         {@code "CREATE TENANT"}) when a system-only prefix is
     *         found, or {@code null} when the script contains no such
     *         prefix (or the input is null / empty)
     * @since 4.0.1.4
     */
    public static String detectSystemPrefixConflict(String sqltext) {
        if (sqltext == null || sqltext.isEmpty()) {
            return null;
        }
        // Mask comments and string / double-quoted-identifier literals.
        // Positions are preserved (masks are runs of spaces) so that any
        // future line/column reporting remains accurate; newlines inside
        // masked runs are retained so line counting still works.
        String cleaned = maskRuns(sqltext, BLOCK_COMMENT_PATTERN);
        cleaned = maskRuns(cleaned, LINE_COMMENT_PATTERN);
        cleaned = maskRuns(cleaned, SINGLE_QUOTE_STRING_PATTERN);
        cleaned = maskRuns(cleaned, DOUBLE_QUOTE_IDENT_PATTERN);

        Matcher m = SYSTEM_DDL_PREFIX_PATTERN.matcher(cleaned);
        if (m.find()) {
            // Collapse internal whitespace and uppercase for a canonical
            // prefix name in the error message (for example "create\ttenant"
            // becomes "CREATE TENANT").
            return m.group(1).replaceAll("\\s+", " ").toUpperCase();
        }
        return null;
    }

    /**
     * Replace every match of {@code pattern} in {@code s} with a run of
     * ASCII spaces of the same length. Newlines and carriage returns
     * inside the match are preserved so line/column positions computed
     * from the masked string stay consistent with the original text.
     */
    private static String maskRuns(String s, Pattern pattern) {
        Matcher m = pattern.matcher(s);
        if (!m.find()) {
            return s;
        }
        StringBuilder sb = new StringBuilder(s);
        do {
            for (int i = m.start(); i < m.end(); i++) {
                char c = sb.charAt(i);
                if (c != '\n' && c != '\r') {
                    sb.setCharAt(i, ' ');
                }
            }
        } while (m.find());
        return sb.toString();
    }
}