rawsql-ts 0.11.42-beta → 0.11.44-beta

package/dist/esm/src/parsers/CreateTableParser.js

@@ -0,0 +1,734 @@
+import { SqlTokenizer } from "./SqlTokenizer";
+import { SelectQueryParser } from "./SelectQueryParser";
+import { CreateTableQuery, TableColumnDefinition, TableConstraintDefinition, ColumnConstraintDefinition, ReferenceDefinition } from "../models/CreateTableQuery";
+import { TokenType } from "../models/Lexeme";
+import { FullNameParser } from "./FullNameParser";
+import { FunctionExpressionParser } from "./FunctionExpressionParser";
+import { ValueParser } from "./ValueParser";
+import { RawString, QualifiedName } from "../models/ValueComponent";
+import { joinLexemeValues } from "../utils/ParserStringUtils";
+/**
+ * Parses CREATE TABLE statements (DDL or AS SELECT) into CreateTableQuery models.
+ */
+export class CreateTableParser {
+    /**
+     * Parse SQL string to CreateTableQuery AST.
+     */
+    static parse(query) {
+        const tokenizer = new SqlTokenizer(query);
+        const lexemes = tokenizer.readLexemes();
+        const result = this.parseFromLexeme(lexemes, 0);
+        if (result.newIndex < lexemes.length) {
+            throw new Error(`Syntax error: Unexpected token "${lexemes[result.newIndex].value}" at position ${result.newIndex}. The CREATE TABLE statement is complete but there are additional tokens.`);
+        }
+        return result.value;
+    }
+    /**
+     * Parse from lexeme array (for internal use and tests).
+     */
+    static parseFromLexeme(lexemes, index) {
+        var _a;
+        let idx = index;
+        // Guard against unexpected end of input before parsing begins.
+        if (idx >= lexemes.length) {
+            throw new Error(`[CreateTableParser] Unexpected end of input at position ${idx}.`);
+        }
+        const commandLexeme = lexemes[idx];
+        // Capture comments that precede the CREATE TABLE keyword so they can be re-applied later.
+        const leadingCreateComments = this.popLexemeComments(commandLexeme, 'before');
+        const commandToken = commandLexeme.value.toLowerCase();
+        const isTemporary = commandToken === "create temporary table";
+        if (commandToken !== "create table" && !isTemporary) {
+            throw new Error(`[CreateTableParser] Syntax error at position ${idx}: expected 'CREATE TABLE' but found '${lexemes[idx].value}'.`);
+        }
+        idx++;
+        // Handle optional IF NOT EXISTS clause.
+        const tokenAt = (offset) => { var _a; return (_a = lexemes[idx + offset]) === null || _a === void 0 ? void 0 : _a.value.toLowerCase(); };
+        let ifNotExists = false;
+        if (tokenAt(0) === "if not exists") {
+            idx++;
+            ifNotExists = true;
+        }
+        // Parse qualified table name.
+        const tableNameResult = this.parseQualifiedName(lexemes, idx);
+        idx = tableNameResult.newIndex;
+        const tableName = tableNameResult.name;
+        const tableNamespaces = tableNameResult.namespaces;
+        // Place captured comments from the identifier on the CreateTableQuery after instantiation.
+        const positionedComments = tableName.positionedComments ? [...tableName.positionedComments] : null;
+        const legacyComments = tableName.comments ? [...tableName.comments] : null;
+        let columns = [];
+        let tableConstraints = [];
+        let tableOptions = null;
+        let asSelectQuery;
+        let withDataOption = null;
+        // Parse DDL column definitions when present.
+        if (((_a = lexemes[idx]) === null || _a === void 0 ? void 0 : _a.type) === TokenType.OpenParen) {
+            ({ columns, tableConstraints, newIndex: idx } = this.parseDefinitionList(lexemes, idx));
+        }
+        // Capture trailing table options that appear before an AS SELECT clause.
+        if (idx < lexemes.length) {
+            const nextValue = tokenAt(0);
+            if (!this.isSelectKeyword(nextValue, lexemes[idx + 1])) {
+                const optionsEnd = this.findClauseBoundary(lexemes, idx);
+                if (optionsEnd > idx) {
+                    tableOptions = new RawString(joinLexemeValues(lexemes, idx, optionsEnd));
+                    idx = optionsEnd;
+                }
+            }
+        }
+        // Parse optional AS SELECT / SELECT clause.
+        const nextToken = tokenAt(0);
+        if (nextToken === "as") {
+            idx++;
+            const selectResult = SelectQueryParser.parseFromLexeme(lexemes, idx);
+            asSelectQuery = selectResult.value;
+            idx = selectResult.newIndex;
+        }
+        else if (nextToken === "select" || nextToken === "with" || nextToken === "values") {
+            const selectResult = SelectQueryParser.parseFromLexeme(lexemes, idx);
+            asSelectQuery = selectResult.value;
+            idx = selectResult.newIndex;
+        }
+        if (asSelectQuery) {
+            // Allow optional PostgreSQL-style WITH [NO] DATA clause after AS SELECT bodies.
+            const withResult = this.parseWithDataOption(lexemes, idx);
+            if (withResult) {
+                withDataOption = withResult.value;
+                idx = withResult.newIndex;
+            }
+        }
+        const query = new CreateTableQuery({
+            tableName: tableName.name,
+            namespaces: tableNamespaces,
+            isTemporary,
+            ifNotExists,
+            columns,
+            tableConstraints,
+            tableOptions,
+            asSelectQuery,
+            withDataOption
+        });
+        // Re-attach positioned comments captured on the identifier.
+        if (positionedComments) {
+            query.tableName.positionedComments = positionedComments.map(pc => ({
+                position: pc.position,
+                comments: [...pc.comments]
+            }));
+        }
+        if (legacyComments) {
+            query.tableName.comments = [...legacyComments];
+        }
+        if (leadingCreateComments.length > 0) {
+            // Keep top-level comments aligned with the CREATE TABLE statement.
+            query.addPositionedComments('before', leadingCreateComments);
+        }
+        return { value: query, newIndex: idx };
+    }
+    static parseQualifiedName(lexemes, index) {
+        const { namespaces, name, newIndex } = FullNameParser.parseFromLexeme(lexemes, index);
+        return {
+            namespaces: namespaces ? [...namespaces] : null,
+            name,
+            newIndex
+        };
+    }
+    static parseDefinitionList(lexemes, index) {
+        var _a, _b;
+        let idx = index;
+        const columns = [];
+        const constraints = [];
+        const openParenLexeme = lexemes[idx];
+        // Convert comments placed immediately after '(' into leading comments for the first entry.
+        let pendingLeading = this.toOptionalComments(this.popLexemeComments(openParenLexeme, 'after'));
+        // Skip opening parenthesis.
+        idx++;
+        // Parse individual column or constraint entries until closing parenthesis.
+        while (idx < lexemes.length) {
+            const lexeme = lexemes[idx];
+            if (lexeme.type === TokenType.CloseParen) {
+                // When comments sit right before ')', keep them with the preceding entry.
+                const closingLeading = this.popLexemeComments(lexeme, 'before');
+                if (closingLeading.length > 0) {
+                    const target = (_a = (constraints.length > 0 ? constraints[constraints.length - 1] : columns[columns.length - 1])) !== null && _a !== void 0 ? _a : null;
+                    if (target) {
+                        target.addPositionedComments('after', closingLeading);
+                    }
+                }
+                idx++;
+                break;
+            }
+            const tokenValue = lexeme.value.toLowerCase();
+            const isConstraint = this.TABLE_CONSTRAINT_STARTERS.has(tokenValue);
+            const entryResult = isConstraint
+                ? this.parseTableConstraint(lexemes, idx)
+                : this.parseColumnDefinition(lexemes, idx);
+            let entry = entryResult.value;
+            if (pendingLeading && pendingLeading.length > 0) {
+                // Reattach comments that belonged between comma/parenthesis and the entry itself.
+                entry.addPositionedComments('before', pendingLeading);
+                pendingLeading = null;
+            }
+            const trailingComments = this.popLexemeComments(lexemes[Math.max(entryResult.newIndex - 1, idx)], 'after');
+            if (trailingComments.length > 0) {
+                // Preserve inline comments that appeared after the entry tokens.
+                entry.addPositionedComments('after', trailingComments);
+            }
+            if (isConstraint) {
+                constraints.push(entry);
+            }
+            else {
+                columns.push(entry);
+            }
+            idx = entryResult.newIndex;
+            // Consume delimiter comma between definitions.
+            if (idx < lexemes.length && (lexemes[idx].type & TokenType.Comma)) {
+                const commaLexeme = lexemes[idx];
+                const commaTrailing = this.popLexemeComments(commaLexeme, 'after');
+                pendingLeading = this.toOptionalComments(commaTrailing);
+                idx++;
+                continue;
+            }
+            // Break when encountering the closing parenthesis.
+            if (idx < lexemes.length && lexemes[idx].type === TokenType.CloseParen) {
+                const closingLexeme = lexemes[idx];
+                const closingLeading = this.popLexemeComments(closingLexeme, 'before');
+                if (closingLeading.length > 0) {
+                    const target = (_b = (constraints.length > 0 ? constraints[constraints.length - 1] : columns[columns.length - 1])) !== null && _b !== void 0 ? _b : null;
+                    if (target) {
+                        target.addPositionedComments('after', closingLeading);
+                    }
+                }
+                idx++;
+                break;
+            }
+            pendingLeading = null;
+        }
+        return { columns, tableConstraints: constraints, newIndex: idx };
+    }
+    static parseColumnDefinition(lexemes, index) {
+        let idx = index;
+        // Parse the column name as a qualified identifier.
+        const columnNameResult = this.parseQualifiedName(lexemes, idx);
+        idx = columnNameResult.newIndex;
+        if (columnNameResult.namespaces && columnNameResult.namespaces.length > 0) {
+            const qualified = [...columnNameResult.namespaces, columnNameResult.name.name].join(".");
+            throw new Error(`[CreateTableParser] Column name '${qualified}' must not include a schema or namespace qualifier.`);
+        }
+        const columnName = columnNameResult.name;
+        // Parse optional data type immediately following the column name.
+        let dataType;
+        if (idx < lexemes.length && !this.isColumnConstraintStart(lexemes[idx]) && !this.isColumnTerminator(lexemes[idx])) {
+            const typeResult = this.parseColumnType(lexemes, idx);
+            dataType = typeResult.value;
+            idx = typeResult.newIndex;
+        }
+        // Collect column constraints until termination.
+        const constraints = [];
+        while (idx < lexemes.length && !this.isColumnTerminator(lexemes[idx])) {
+            const constraintResult = this.parseColumnConstraint(lexemes, idx);
+            constraints.push(constraintResult.value);
+            idx = constraintResult.newIndex;
+        }
+        const columnDef = new TableColumnDefinition({
+            name: columnName,
+            dataType,
+            constraints
+        });
+        return { value: columnDef, newIndex: idx };
+    }
+    static parseColumnType(lexemes, index) {
+        try {
+            const result = FunctionExpressionParser.parseTypeValue(lexemes, index);
+            return { value: result.value, newIndex: result.newIndex };
+        }
+        catch (_a) {
+            const typeEnd = this.findFirstConstraintIndex(lexemes, index);
+            const rawText = joinLexemeValues(lexemes, index, typeEnd);
+            return { value: new RawString(rawText), newIndex: typeEnd };
+        }
+    }
+    static parseColumnConstraint(lexemes, index) {
+        var _a;
+        let idx = index;
+        let constraintName;
+        // Handle optional CONSTRAINT <name> prefix.
+        if (((_a = lexemes[idx]) === null || _a === void 0 ? void 0 : _a.value.toLowerCase()) === "constraint") {
+            idx++;
+            const nameResult = this.parseQualifiedName(lexemes, idx);
+            constraintName = nameResult.name;
+            idx = nameResult.newIndex;
+        }
+        const token = lexemes[idx];
+        if (!token) {
+            throw new Error(`[CreateTableParser] Expected constraint definition at index ${idx}.`);
+        }
+        const value = token.value.toLowerCase();
+        // Parse NOT NULL / NULL constraints.
+        if (value === "not null" || value === "null") {
+            idx++;
+            return {
+                value: new ColumnConstraintDefinition({
+                    kind: value === "not null" ? "not-null" : "null",
+                    constraintName
+                }),
+                newIndex: idx
+            };
+        }
+        // Parse DEFAULT constraint with arbitrary expressions.
+        if (value === "default") {
+            idx++;
+            const exprResult = ValueParser.parseFromLexeme(lexemes, idx);
+            idx = exprResult.newIndex;
+            return {
+                value: new ColumnConstraintDefinition({
+                    kind: "default",
+                    constraintName,
+                    defaultValue: exprResult.value
+                }),
+                newIndex: idx
+            };
+        }
+        // Parse PRIMARY KEY constraint.
+        if (value === "primary key") {
+            idx++;
+            return {
+                value: new ColumnConstraintDefinition({
+                    kind: "primary-key",
+                    constraintName
+                }),
+                newIndex: idx
+            };
+        }
+        // Parse UNIQUE / UNIQUE KEY constraint.
+        if (value === "unique" || value === "unique key") {
+            idx++;
+            return {
+                value: new ColumnConstraintDefinition({
+                    kind: "unique",
+                    constraintName
+                }),
+                newIndex: idx
+            };
+        }
+        // Parse REFERENCES clause.
+        if (value === "references") {
+            const referenceResult = this.parseReferenceDefinition(lexemes, idx);
+            idx = referenceResult.newIndex;
+            return {
+                value: new ColumnConstraintDefinition({
+                    kind: "references",
+                    constraintName,
+                    reference: referenceResult.value
+                }),
+                newIndex: idx
+            };
+        }
+        // Parse CHECK constraint.
+        if (value === "check") {
+            idx++;
+            const checkExpression = this.parseParenExpression(lexemes, idx);
+            idx = checkExpression.newIndex;
+            return {
+                value: new ColumnConstraintDefinition({
+                    kind: "check",
+                    constraintName,
+                    checkExpression: checkExpression.value
+                }),
+                newIndex: idx
+            };
+        }
+        // Parse identity-style generated clauses.
+        if (value.startsWith("generated")) {
+            const clauseEnd = this.findFirstConstraintIndex(lexemes, idx + 1);
+            const text = joinLexemeValues(lexemes, idx, clauseEnd);
+            idx = clauseEnd;
+            const kind = value.startsWith("generated always")
+                ? "generated-always-identity"
+                : "generated-by-default-identity";
+            return {
+                value: new ColumnConstraintDefinition({
+                    kind,
+                    constraintName,
+                    rawClause: new RawString(text)
+                }),
+                newIndex: idx
+            };
+        }
+        // Fallback to raw clause capture for unsupported constraints.
+        const rawEnd = this.findFirstConstraintIndex(lexemes, idx + 1);
+        const rawText = joinLexemeValues(lexemes, idx, rawEnd);
+        return {
+            value: new ColumnConstraintDefinition({
+                kind: "raw",
+                constraintName,
+                rawClause: new RawString(rawText)
+            }),
+            newIndex: rawEnd
+        };
+    }
+    static parseTableConstraint(lexemes, index) {
+        var _a;
+        let idx = index;
+        let constraintName;
+        // Capture optional CONSTRAINT <name> prefix.
+        if (((_a = lexemes[idx]) === null || _a === void 0 ? void 0 : _a.value.toLowerCase()) === "constraint") {
+            idx++;
+            const nameResult = this.parseQualifiedName(lexemes, idx);
+            constraintName = nameResult.name;
+            idx = nameResult.newIndex;
+        }
+        const token = lexemes[idx];
+        if (!token) {
+            throw new Error(`[CreateTableParser] Expected table constraint at index ${idx}.`);
+        }
+        const value = token.value.toLowerCase();
+        if (value === "primary key") {
+            idx++;
+            const { identifiers, newIndex } = this.parseIdentifierList(lexemes, idx);
+            idx = newIndex;
+            return {
+                value: new TableConstraintDefinition({
+                    kind: "primary-key",
+                    constraintName,
+                    columns: identifiers
+                }),
+                newIndex: idx
+            };
+        }
+        if (value === "unique" || value === "unique key") {
+            idx++;
+            let inlineKeyName;
+            if (idx < lexemes.length &&
+                lexemes[idx].value !== "(" &&
+                !(lexemes[idx].type & TokenType.Command)) {
+                const inlineNameResult = this.parseQualifiedName(lexemes, idx);
+                inlineKeyName = inlineNameResult.name;
+                idx = inlineNameResult.newIndex;
+            }
+            const { identifiers, newIndex } = this.parseIdentifierList(lexemes, idx);
+            idx = newIndex;
+            return {
+                value: new TableConstraintDefinition({
+                    kind: "unique",
+                    constraintName: constraintName !== null && constraintName !== void 0 ? constraintName : inlineKeyName,
+                    columns: identifiers
+                }),
+                newIndex: idx
+            };
+        }
+        if (value === "foreign key") {
+            idx++;
+            let inlineKeyName;
+            if (idx < lexemes.length &&
+                lexemes[idx].value !== "(" &&
+                !(lexemes[idx].type & TokenType.Command)) {
+                const inlineNameResult = this.parseQualifiedName(lexemes, idx);
+                inlineKeyName = inlineNameResult.name;
+                idx = inlineNameResult.newIndex;
+            }
+            const { identifiers, newIndex } = this.parseIdentifierList(lexemes, idx);
+            idx = newIndex;
+            const referenceResult = this.parseReferenceDefinition(lexemes, idx);
+            idx = referenceResult.newIndex;
+            return {
+                value: new TableConstraintDefinition({
+                    kind: "foreign-key",
+                    constraintName: constraintName !== null && constraintName !== void 0 ? constraintName : inlineKeyName,
+                    columns: identifiers,
+                    reference: referenceResult.value,
+                    deferrable: referenceResult.value.deferrable,
+                    initially: referenceResult.value.initially
+                }),
+                newIndex: idx
+            };
+        }
+        if (value === "check") {
+            idx++;
+            const checkExpression = this.parseParenExpression(lexemes, idx);
+            idx = checkExpression.newIndex;
+            return {
+                value: new TableConstraintDefinition({
+                    kind: "check",
+                    constraintName,
+                    checkExpression: checkExpression.value
+                }),
+                newIndex: idx
+            };
+        }
+        // Fallback to capturing the raw text when the constraint is not recognized.
+        const rawEnd = this.findFirstConstraintIndex(lexemes, idx + 1);
+        const rawText = joinLexemeValues(lexemes, idx, rawEnd);
+        return {
+            value: new TableConstraintDefinition({
+                kind: "raw",
+                constraintName,
+                rawClause: new RawString(rawText)
+            }),
+            newIndex: rawEnd
+        };
+    }
+    static parseIdentifierList(lexemes, index) {
+        var _a, _b, _c;
+        let idx = index;
+        const identifiers = [];
+        if (((_a = lexemes[idx]) === null || _a === void 0 ? void 0 : _a.type) !== TokenType.OpenParen) {
+            throw new Error(`[CreateTableParser] Expected '(' to start identifier list at index ${idx}.`);
+        }
+        idx++;
+        while (idx < lexemes.length) {
+            const nameResult = this.parseQualifiedName(lexemes, idx);
+            identifiers.push(nameResult.name);
+            idx = nameResult.newIndex;
+            if (((_b = lexemes[idx]) === null || _b === void 0 ? void 0 : _b.type) === TokenType.Comma) {
+                idx++;
+                continue;
+            }
+            if (((_c = lexemes[idx]) === null || _c === void 0 ? void 0 : _c.type) === TokenType.CloseParen) {
+                idx++;
+                break;
+            }
+        }
+        return { identifiers, newIndex: idx };
+    }
+    static parseReferenceDefinition(lexemes, index) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+        let idx = index;
+        if (((_a = lexemes[idx]) === null || _a === void 0 ? void 0 : _a.value.toLowerCase()) !== "references") {
+            throw new Error(`[CreateTableParser] Expected REFERENCES clause at index ${idx}.`);
+        }
+        idx++;
+        const tableNameResult = this.parseQualifiedName(lexemes, idx);
+        idx = tableNameResult.newIndex;
+        const targetTable = new QualifiedName(tableNameResult.namespaces, tableNameResult.name);
+        // Parse optional column list in the REFERENCES clause.
+        let columns = null;
+        if (((_b = lexemes[idx]) === null || _b === void 0 ? void 0 : _b.type) === TokenType.OpenParen) {
+            const listResult = this.parseIdentifierList(lexemes, idx);
+            columns = listResult.identifiers;
+            idx = listResult.newIndex;
+        }
+        let matchType = null;
+        let onDelete = null;
+        let onUpdate = null;
+        let deferrable = null;
+        let initially = null;
+        // Parse optional trailing reference options.
+        while (idx < lexemes.length) {
+            const current = lexemes[idx].value.toLowerCase();
+            if (this.MATCH_KEYWORDS.has(current)) {
+                matchType = this.MATCH_KEYWORDS.get(current);
+                idx++;
+                continue;
+            }
+            if (current === "match") {
+                idx++;
+                const descriptor = (_d = (_c = lexemes[idx]) === null || _c === void 0 ? void 0 : _c.value.toLowerCase()) !== null && _d !== void 0 ? _d : "";
+                matchType = descriptor;
+                idx++;
+                continue;
+            }
+            if (current === "on delete") {
+                idx++;
+                const action = (_f = (_e = lexemes[idx]) === null || _e === void 0 ? void 0 : _e.value.toLowerCase()) !== null && _f !== void 0 ? _f : "";
+                onDelete = (_g = this.REFERENTIAL_ACTIONS.get(action)) !== null && _g !== void 0 ? _g : null;
+                idx++;
+                continue;
+            }
+            if (current === "on update") {
+                idx++;
+                const action = (_j = (_h = lexemes[idx]) === null || _h === void 0 ? void 0 : _h.value.toLowerCase()) !== null && _j !== void 0 ? _j : "";
+                onUpdate = (_k = this.REFERENTIAL_ACTIONS.get(action)) !== null && _k !== void 0 ? _k : null;
+                idx++;
+                continue;
+            }
+            if (this.DEFERRABILITY_KEYWORDS.has(current)) {
+                deferrable = this.DEFERRABILITY_KEYWORDS.get(current);
+                idx++;
+                continue;
+            }
+            if (this.INITIALLY_KEYWORDS.has(current)) {
+                initially = this.INITIALLY_KEYWORDS.get(current);
+                idx++;
+                continue;
+            }
+            break;
+        }
+        return {
+            value: new ReferenceDefinition({
+                targetTable,
+                columns,
+                matchType,
+                onDelete,
+                onUpdate,
+                deferrable,
+                initially
+            }),
+            newIndex: idx
+        };
+    }
+    static parseParenExpression(lexemes, index) {
+        var _a, _b;
+        let idx = index;
+        if (((_a = lexemes[idx]) === null || _a === void 0 ? void 0 : _a.type) !== TokenType.OpenParen) {
+            throw new Error(`[CreateTableParser] Expected '(' introducing expression at index ${idx}.`);
+        }
+        idx++;
+        const expressionResult = ValueParser.parseFromLexeme(lexemes, idx);
+        idx = expressionResult.newIndex;
+        if (((_b = lexemes[idx]) === null || _b === void 0 ? void 0 : _b.type) !== TokenType.CloseParen) {
+            throw new Error(`[CreateTableParser] Expected ')' terminating expression at index ${idx}.`);
+        }
+        idx++;
+        return { value: expressionResult.value, newIndex: idx };
+    }
+    static isColumnConstraintStart(lexeme) {
+        if (!lexeme) {
+            return false;
+        }
+        const lower = lexeme.value.toLowerCase();
+        return this.COLUMN_CONSTRAINT_STARTERS.has(lower);
+    }
+    static isColumnTerminator(lexeme) {
+        if (!lexeme) {
+            return true;
+        }
+        if (lexeme.type & (TokenType.Comma | TokenType.CloseParen)) {
+            return true;
+        }
+        return false;
+    }
+    static isSelectKeyword(value, nextLexeme) {
+        if (!value) {
+            return false;
+        }
+        if (value === 'with' && (nextLexeme === null || nextLexeme === void 0 ? void 0 : nextLexeme.type) === TokenType.OpenParen) {
+            return false;
+        }
+        return value === "as" || value === "select" || value === "with" || value === "values";
+    }
+    static findClauseBoundary(lexemes, index) {
+        let idx = index;
+        while (idx < lexemes.length) {
+            const lower = lexemes[idx].value.toLowerCase();
+            if (this.isSelectKeyword(lower, lexemes[idx + 1])) {
+                break;
+            }
+            idx++;
+        }
+        return idx;
+    }
+    static findFirstConstraintIndex(lexemes, index) {
+        let idx = index;
+        while (idx < lexemes.length && !this.isColumnConstraintStart(lexemes[idx]) && !this.isColumnTerminator(lexemes[idx])) {
+            idx++;
+        }
+        return idx;
+    }
+    static parseWithDataOption(lexemes, index) {
+        // Detect PostgreSQL-style WITH [NO] DATA phrases that follow CREATE TABLE ... AS SELECT.
+        const current = lexemes[index];
+        if (!current) {
+            return null;
+        }
+        const value = current.value.toLowerCase();
+        if (value === "with data") {
+            return { value: "with-data", newIndex: index + 1 };
+        }
+        if (value === "with no data") {
+            return { value: "with-no-data", newIndex: index + 1 };
+        }
+        if (value !== "with") {
+            return null;
+        }
+        const next = lexemes[index + 1];
+        const nextValue = next === null || next === void 0 ? void 0 : next.value.toLowerCase();
+        if (nextValue === "data") {
+            return { value: "with-data", newIndex: index + 2 };
+        }
+        if (nextValue === "data") {
+            return { value: "with-data", newIndex: index + 2 };
+        }
+        if (nextValue === "no data") {
+            return { value: "with-no-data", newIndex: index + 2 };
+        }
+        if (nextValue === "no") {
+            const following = lexemes[index + 2];
+            if (following && following.value.toLowerCase() === "data") {
+                return { value: "with-no-data", newIndex: index + 3 };
+            }
+        }
+        return null;
+    }
+    static popLexemeComments(lexeme, position) {
+        if (!lexeme) {
+            return [];
+        }
+        let collected = [];
+        // Extract positioned comments first so they are not reused downstream.
+        if (lexeme.positionedComments && lexeme.positionedComments.length > 0) {
+            const matchIndex = lexeme.positionedComments.findIndex(pc => pc.position === position);
+            if (matchIndex >= 0) {
+                collected = [...lexeme.positionedComments[matchIndex].comments];
+                const remaining = lexeme.positionedComments.filter((_, idx) => idx !== matchIndex);
+                lexeme.positionedComments = remaining.length > 0 ? remaining : undefined;
+            }
+        }
+        if (collected.length > 0) {
+            return collected;
+        }
+        if (lexeme.comments && lexeme.comments.length > 0) {
+            const legacy = [...lexeme.comments];
+            lexeme.comments = null;
+            return legacy;
+        }
+        return [];
+    }
+    static toOptionalComments(comments) {
+        return comments.length > 0 ? comments : null;
+    }
+}
+CreateTableParser.TABLE_CONSTRAINT_STARTERS = new Set([
+    "constraint",
+    "primary key",
+    "unique",
+    "unique key",
+    "foreign key",
+    "check"
+]);
+CreateTableParser.COLUMN_CONSTRAINT_STARTERS = new Set([
+    "constraint",
+    "not null",
+    "null",
+    "default",
+    "primary key",
+    "unique",
+    "unique key",
+    "references",
+    "check",
+    "generated always",
+    "generated always as identity",
+    "generated by default",
+    "generated by default as identity"
+]);
+CreateTableParser.MATCH_KEYWORDS = new Map([
+    ["match full", "full"],
+    ["match partial", "partial"],
+    ["match simple", "simple"]
+]);
+CreateTableParser.REFERENTIAL_ACTIONS = new Map([
+    ["cascade", "cascade"],
+    ["restrict", "restrict"],
+    ["no action", "no action"],
+    ["set null", "set null"],
+    ["set default", "set default"]
+]);
+CreateTableParser.DEFERRABILITY_KEYWORDS = new Map([
+    ["deferrable", "deferrable"],
+    ["not deferrable", "not deferrable"]
+]);
+CreateTableParser.INITIALLY_KEYWORDS = new Map([
+    ["initially immediate", "immediate"],
+    ["initially deferred", "deferred"]
+]);
+//# sourceMappingURL=CreateTableParser.js.map