@dineug/erd-editor 4.2.0 → 5.0.1

package/dist/schema-sql-parser/dist/parser/index.js

@@ -0,0 +1,70 @@
+import { tokenizer } from "./tokenizer.js";
+import { isAddExtendedProperty, isAlterTableAdd, isAlterTableAddDefault, isAlterTableAddForeignKey, isAlterTableAddPrimaryKey, isAlterTableAlter, isCommentOnColumn, isCommentOnTable, isCreateIndex, isCreateTable } from "./helper.js";
+import { addExtendedPropertyParser } from "./statement/add.extended.property.js";
+import { alterTableAddDefaultParser } from "./statement/alter.table.add.default.js";
+import { createTableParser } from "./statement/create.table.js";
+import { alterTableAddForeignKeyParser } from "./statement/alter.table.add.foreignKey.js";
+import { alterTableAddPrimaryKeyParser } from "./statement/alter.table.add.primaryKey.js";
+import { alterTableAddUniqueParser } from "./statement/alter.table.add.unique.js";
+import { alterTableAlterColumnParser } from "./statement/alter.table.alter.column.js";
+import { commentOnColumnParser } from "./statement/comment.on.column.js";
+import { commentOnTableParser } from "./statement/comment.on.table.js";
+import { createIndexParser } from "./statement/create.index.js";
+//#region ../schema-sql-parser/dist/parser/index.js
+function parser(tokens, database) {
+	const ast = [];
+	const $pos = { value: 0 };
+	const isToken = () => $pos.value < tokens.length;
+	const createTable = isCreateTable(tokens);
+	const createIndex = isCreateIndex(tokens);
+	const alterTableAddPrimaryKey = isAlterTableAddPrimaryKey(tokens);
+	const alterTableAddForeignKey = isAlterTableAddForeignKey(tokens);
+	const alterTableAddDefault = isAlterTableAddDefault(tokens);
+	const alterTableAdd = isAlterTableAdd(tokens);
+	const alterTableAlter = isAlterTableAlter(tokens);
+	const commentOnTable = isCommentOnTable(tokens);
+	const commentOnColumn = isCommentOnColumn(tokens);
+	const addExtendedProperty = isAddExtendedProperty(tokens);
+	while (isToken()) {
+		if (createTable($pos.value)) {
+			ast.push(createTableParser(tokens, $pos, database));
+			continue;
+		}
+		if (createIndex($pos.value)) {
+			ast.push(createIndexParser(tokens, $pos));
+			continue;
+		}
+		if (alterTableAdd($pos.value)) {
+			const start = $pos.value;
+			if (alterTableAddPrimaryKey(start)) ast.push(alterTableAddPrimaryKeyParser(tokens, $pos));
+			else if (alterTableAddForeignKey(start)) ast.push(alterTableAddForeignKeyParser(tokens, $pos));
+			else if (alterTableAddDefault(start)) ast.push(alterTableAddDefaultParser(tokens, $pos, database));
+			const $unique = { value: start };
+			ast.push(...alterTableAddUniqueParser(tokens, $unique));
+			$pos.value = Math.max($pos.value, $unique.value);
+			continue;
+		}
+		if (alterTableAlter($pos.value)) {
+			ast.push(...alterTableAlterColumnParser(tokens, $pos));
+			continue;
+		}
+		if (commentOnTable($pos.value)) {
+			ast.push(commentOnTableParser(tokens, $pos));
+			continue;
+		}
+		if (commentOnColumn($pos.value)) {
+			ast.push(commentOnColumnParser(tokens, $pos));
+			continue;
+		}
+		if (addExtendedProperty($pos.value)) {
+			const comment = addExtendedPropertyParser(tokens, $pos);
+			if (comment) ast.push(comment);
+			continue;
+		}
+		$pos.value++;
+	}
+	return ast;
+}
+var schemaSQLParser = (source, { database } = {}) => parser(tokenizer(source, database), database);
+//#endregion
+export { schemaSQLParser };

package/dist/schema-sql-parser/dist/parser/statement/add.extended.property.js

@@ -0,0 +1,73 @@
+import { StatementType } from "./index.js";
+import { isCommaToken, isDefaultValue, isEqualToken, isGoValue, isNewStatement, isNullValue, isSemicolonToken, isStringToken, matchAddExtendedProperty } from "../helper.js";
+//#region ../schema-sql-parser/dist/parser/statement/add.extended.property.js
+var Parameters = [
+	"@NAME",
+	"@VALUE",
+	"@LEVEL0TYPE",
+	"@LEVEL0NAME",
+	"@LEVEL1TYPE",
+	"@LEVEL1NAME",
+	"@LEVEL2TYPE",
+	"@LEVEL2NAME"
+];
+var ReadParameters = Parameters.filter((parameter) => !parameter.startsWith("@LEVEL0"));
+var isVariable = (token) => !!token && !token.quoted && token.value[0] === "@";
+var isOperator = (token) => !!token && !token.quoted && /^[-+*/%&|^]/.test(token.value);
+function addExtendedPropertyParser(tokens, $pos) {
+	const isString = isStringToken(tokens);
+	const isEqual = isEqualToken(tokens);
+	const isComma = isCommaToken(tokens);
+	const isSemicolon = isSemicolonToken(tokens);
+	const isNull = isNullValue(tokens);
+	const isDefault = isDefaultValue(tokens);
+	const isGo = isGoValue(tokens);
+	const newStatement = isNewStatement(tokens);
+	const isArgument = (pos) => isString(pos) && !isGo(pos) && !newStatement(pos);
+	const args = /* @__PURE__ */ new Map();
+	const call = matchAddExtendedProperty(tokens)($pos.value);
+	if (!call) {
+		$pos.value++;
+		return null;
+	}
+	$pos.value += call;
+	for (let index = 0; isArgument($pos.value); index++) {
+		const token = tokens[$pos.value];
+		let parameter = Parameters[index] ?? "";
+		if (isVariable(token) && isEqual($pos.value + 1)) {
+			parameter = token.value.toUpperCase();
+			$pos.value += 2;
+			if (!isArgument($pos.value)) break;
+		}
+		if (!isNull($pos.value) && !isDefault($pos.value)) args.set(parameter, tokens[$pos.value]);
+		$pos.value++;
+		if (isOperator(tokens[$pos.value])) return null;
+		if (!isComma($pos.value)) break;
+		$pos.value++;
+	}
+	if (isSemicolon($pos.value)) $pos.value++;
+	return toComment(args);
+}
+function toComment(args) {
+	if (ReadParameters.some((parameter) => isVariable(args.get(parameter)))) return null;
+	const nameOf = (parameter) => args.get(parameter)?.value ?? "";
+	const value = args.get("@VALUE");
+	const tableName = nameOf("@LEVEL1NAME");
+	const level2type = nameOf("@LEVEL2TYPE").toUpperCase();
+	const columnName = nameOf("@LEVEL2NAME");
+	if (nameOf("@NAME").toUpperCase() !== "MS_DESCRIPTION" || value?.quoted !== "'" || nameOf("@LEVEL1TYPE").toUpperCase() !== "TABLE" || !tableName) return null;
+	if (!level2type) return {
+		type: StatementType.commentOnTable,
+		name: tableName,
+		comment: value.value
+	};
+	if (level2type !== "COLUMN" || !columnName) return null;
+	return {
+		type: StatementType.commentOnColumn,
+		tableName,
+		columnName,
+		comment: value.value
+	};
+}
+//#endregion
+export { addExtendedPropertyParser };

package/dist/schema-sql-parser/dist/parser/statement/alter.table.add.default.js

@@ -0,0 +1,75 @@
+import { StatementType } from "./index.js";
+import { isAlterTableAddOnly, isCommaToken, isDefaultValue, isForValue, isLeftParentToken, isNewStatement, isPeriodToken, isRightParentToken, isSemicolonToken, isStringToken, isTableValue } from "../helper.js";
+import { isNextValueFor, writeDefaultExpression } from "./default.expression.js";
+//#region ../schema-sql-parser/dist/parser/statement/alter.table.add.default.js
+function alterTableAddDefaultParser(tokens, $pos, database) {
+	const newStatement = isNewStatement(tokens);
+	const isSemicolon = isSemicolonToken(tokens);
+	const isComma = isCommaToken(tokens);
+	const isLeftParent = isLeftParentToken(tokens);
+	const isRightParent = isRightParentToken(tokens);
+	const isString = isStringToken(tokens);
+	const isPeriod = isPeriodToken(tokens);
+	const isTable = isTableValue(tokens);
+	const isDefault = isDefaultValue(tokens);
+	const isFor = isForValue(tokens);
+	const nextValueFor = isNextValueFor(tokens);
+	const isOnly = isAlterTableAddOnly(tokens)($pos.value);
+	const isToken = () => $pos.value < tokens.length;
+	const isColumnFor = (pos) => isFor(pos) && !nextValueFor(pos);
+	const expressionEnd = (start) => {
+		let depth = 0;
+		let cursor = start;
+		for (; cursor < tokens.length; cursor++) {
+			if (isSemicolon(cursor) || newStatement(cursor)) break;
+			if (isLeftParent(cursor)) depth++;
+			else if (isRightParent(cursor)) {
+				if (depth === 0) break;
+				depth--;
+			} else if (depth === 0 && (isComma(cursor) || isColumnFor(cursor))) break;
+		}
+		return cursor;
+	};
+	const ast = {
+		type: StatementType.alterTableAddDefault,
+		name: "",
+		columnName: "",
+		default: ""
+	};
+	let clauseRead = false;
+	$pos.value++;
+	if (isTable($pos.value)) {
+		$pos.value++;
+		if (isOnly) $pos.value++;
+		if (isString($pos.value)) {
+			ast.name = tokens[$pos.value].value;
+			$pos.value++;
+			while (isPeriod($pos.value) && isString($pos.value + 1)) {
+				ast.name = tokens[$pos.value + 1].value;
+				$pos.value += 2;
+			}
+		}
+	}
+	while (isToken() && !newStatement($pos.value)) {
+		if (isSemicolon($pos.value)) {
+			$pos.value++;
+			break;
+		}
+		if (!clauseRead && isDefault($pos.value)) {
+			const start = $pos.value + 1;
+			const end = expressionEnd(start);
+			ast.default = writeDefaultExpression(tokens.slice(start, end), database);
+			$pos.value = end;
+			clauseRead = true;
+			if (isFor($pos.value) && isString($pos.value + 1)) {
+				ast.columnName = tokens[$pos.value + 1].value;
+				$pos.value += 2;
+			}
+			continue;
+		}
+		$pos.value++;
+	}
+	return ast;
+}
+//#endregion
+export { alterTableAddDefaultParser };

package/dist/schema-sql-parser/dist/parser/statement/alter.table.add.foreignKey.js

@@ -0,0 +1,69 @@
+import { StatementType } from "./index.js";
+import { isAlterTableAddOnly, isConstraintValue, isForeignValue, isNewStatement, isPeriodToken, isSemicolonToken, isStringToken, isTableValue } from "../helper.js";
+import { parserForeignKeyParser } from "./create.table.js";
+//#region ../schema-sql-parser/dist/parser/statement/alter.table.add.foreignKey.js
+function alterTableAddForeignKeyParser(tokens, $pos) {
+	const newStatement = isNewStatement(tokens);
+	const isSemicolon = isSemicolonToken(tokens);
+	const isString = isStringToken(tokens);
+	const isConstraint = isConstraintValue(tokens);
+	const isPeriod = isPeriodToken(tokens);
+	const isTable = isTableValue(tokens);
+	const isForeign = isForeignValue(tokens);
+	const isOnly = isAlterTableAddOnly(tokens)($pos.value);
+	const isToken = () => $pos.value < tokens.length;
+	const ast = {
+		type: StatementType.alterTableAddForeignKey,
+		name: "",
+		columnNames: [],
+		refTableName: "",
+		refColumnNames: [],
+		onDelete: "",
+		onUpdate: ""
+	};
+	$pos.value++;
+	while (isToken() && !newStatement($pos.value)) {
+		let token = tokens[$pos.value];
+		if (isSemicolon($pos.value)) {
+			$pos.value++;
+			break;
+		}
+		if (isTable($pos.value)) {
+			token = tokens[++$pos.value];
+			if (isOnly) token = tokens[++$pos.value];
+			if (isString($pos.value)) {
+				ast.name = token.value;
+				$pos.value++;
+				while (isPeriod($pos.value)) {
+					if (!isString($pos.value + 1)) {
+						$pos.value++;
+						break;
+					}
+					ast.name = tokens[$pos.value + 1].value;
+					$pos.value += 2;
+				}
+			}
+			continue;
+		}
+		if (isConstraint($pos.value)) {
+			token = tokens[++$pos.value];
+			if (isString($pos.value)) $pos.value++;
+			continue;
+		}
+		if (isForeign($pos.value)) {
+			const foreignKey = parserForeignKeyParser(tokens, $pos);
+			if (foreignKey) {
+				ast.columnNames = foreignKey.columnNames;
+				ast.refTableName = foreignKey.refTableName;
+				ast.refColumnNames = foreignKey.refColumnNames;
+				ast.onDelete = foreignKey.onDelete;
+				ast.onUpdate = foreignKey.onUpdate;
+			}
+			continue;
+		}
+		$pos.value++;
+	}
+	return ast;
+}
+//#endregion
+export { alterTableAddForeignKeyParser };

package/dist/schema-sql-parser/dist/parser/statement/alter.table.add.primaryKey.js

@@ -0,0 +1,86 @@
+import { StatementType } from "./index.js";
+import { isAddValue, isAlterTableAddOnly, isCommaToken, isConstraintValue, isKeyValue, isLeftParentToken, isNewStatement, isPeriodToken, isPrimaryValue, isSemicolonToken, isStringToken, isTableValue, matchKeyModifiers, matchUsingIndexName } from "../helper.js";
+import { indexColumnsParser } from "./index.columns.js";
+//#region ../schema-sql-parser/dist/parser/statement/alter.table.add.primaryKey.js
+function alterTableAddPrimaryKeyParser(tokens, $pos) {
+	const newStatement = isNewStatement(tokens);
+	const isSemicolon = isSemicolonToken(tokens);
+	const isString = isStringToken(tokens);
+	const isLeftParent = isLeftParentToken(tokens);
+	const isConstraint = isConstraintValue(tokens);
+	const isPrimary = isPrimaryValue(tokens);
+	const isPeriod = isPeriodToken(tokens);
+	const isKey = isKeyValue(tokens);
+	const isTable = isTableValue(tokens);
+	const isComma = isCommaToken(tokens);
+	const isAdd = isAddValue(tokens);
+	const keyModifiers = matchKeyModifiers(tokens);
+	const usingIndexName = matchUsingIndexName(tokens);
+	const isOnly = isAlterTableAddOnly(tokens)($pos.value);
+	const isToken = () => $pos.value < tokens.length;
+	const ast = {
+		type: StatementType.alterTableAddPrimaryKey,
+		name: "",
+		constraintName: "",
+		usingIndexName: "",
+		columnNames: []
+	};
+	let keyRead = false;
+	let keyClause = true;
+	$pos.value++;
+	while (isToken() && !newStatement($pos.value)) {
+		let token = tokens[$pos.value];
+		if (isSemicolon($pos.value)) {
+			$pos.value++;
+			break;
+		}
+		if (isTable($pos.value)) {
+			token = tokens[++$pos.value];
+			if (isOnly) token = tokens[++$pos.value];
+			if (isString($pos.value)) {
+				ast.name = token.value;
+				$pos.value++;
+				while (isPeriod($pos.value)) {
+					if (!isString($pos.value + 1)) {
+						$pos.value++;
+						break;
+					}
+					ast.name = tokens[$pos.value + 1].value;
+					$pos.value += 2;
+				}
+			}
+			continue;
+		}
+		if (keyRead && (isComma($pos.value) || isAdd($pos.value))) keyClause = false;
+		if (isConstraint($pos.value)) {
+			token = tokens[++$pos.value];
+			if (isString($pos.value) && !isPrimary($pos.value)) {
+				if (!keyRead) ast.constraintName = token.value;
+				$pos.value++;
+			}
+			continue;
+		}
+		const usingIndex = usingIndexName($pos.value);
+		if (usingIndex) {
+			if (keyRead && keyClause) ast.usingIndexName = tokens[$pos.value + usingIndex - 1].value;
+			$pos.value += usingIndex;
+			continue;
+		}
+		if (isPrimary($pos.value)) {
+			token = tokens[++$pos.value];
+			if (isKey($pos.value)) {
+				token = tokens[++$pos.value];
+				$pos.value += keyModifiers($pos.value);
+				if (isLeftParent($pos.value)) {
+					ast.columnNames = indexColumnsParser(tokens, $pos).map((indexColumn) => indexColumn.name);
+					keyRead = true;
+				}
+			}
+			continue;
+		}
+		$pos.value++;
+	}
+	return ast;
+}
+//#endregion
+export { alterTableAddPrimaryKeyParser };

package/dist/schema-sql-parser/dist/parser/statement/alter.table.add.unique.js

@@ -0,0 +1,128 @@
+import { StatementType } from "./index.js";
+import { isAddValue, isAlterTableAddOnly, isCommaToken, isConstraintValue, isExistsValue, isForeignValue, isIfValue, isIndexValue, isKeyValue, isLeftParentToken, isNewStatement, isNotValue, isPeriodToken, isPrimaryValue, isRightParentToken, isSemicolonToken, isStringToken, isTableValue, isUniqueValue, matchKeyModifiers, matchUsingIndexName } from "../helper.js";
+import { indexColumnsParser } from "./index.columns.js";
+//#region ../schema-sql-parser/dist/parser/statement/alter.table.add.unique.js
+function alterTableAddUniqueParser(tokens, $pos) {
+	const newStatement = isNewStatement(tokens);
+	const isSemicolon = isSemicolonToken(tokens);
+	const isString = isStringToken(tokens);
+	const isComma = isCommaToken(tokens);
+	const isAdd = isAddValue(tokens);
+	const isConstraint = isConstraintValue(tokens);
+	const isPeriod = isPeriodToken(tokens);
+	const isTable = isTableValue(tokens);
+	const isUnique = isUniqueValue(tokens);
+	const isPrimary = isPrimaryValue(tokens);
+	const isForeign = isForeignValue(tokens);
+	const isKey = isKeyValue(tokens);
+	const isIndex = isIndexValue(tokens);
+	const isIf = isIfValue(tokens);
+	const isNot = isNotValue(tokens);
+	const isExists = isExistsValue(tokens);
+	const isLeftParent = isLeftParentToken(tokens);
+	const isRightParent = isRightParentToken(tokens);
+	const keyModifiers = matchKeyModifiers(tokens);
+	const usingIndexName = matchUsingIndexName(tokens);
+	const isOnly = isAlterTableAddOnly(tokens)($pos.value);
+	const isToken = () => $pos.value < tokens.length;
+	const skipGroup = () => {
+		let depth = 0;
+		while (isToken() && !isSemicolon($pos.value)) {
+			if (isLeftParent($pos.value)) depth++;
+			else if (isRightParent($pos.value) && --depth === 0) {
+				$pos.value++;
+				return;
+			}
+			$pos.value++;
+		}
+	};
+	const keys = [];
+	let name = "";
+	let constraintName = "";
+	let clauseKey = null;
+	let columnClause = false;
+	$pos.value++;
+	if (isTable($pos.value)) {
+		$pos.value++;
+		if (isOnly) $pos.value++;
+		if (isString($pos.value)) {
+			name = tokens[$pos.value].value;
+			$pos.value++;
+			while (isPeriod($pos.value)) {
+				if (!isString($pos.value + 1)) {
+					$pos.value++;
+					break;
+				}
+				name = tokens[$pos.value + 1].value;
+				$pos.value += 2;
+			}
+		}
+	}
+	while (isToken() && !newStatement($pos.value)) {
+		if (isSemicolon($pos.value)) {
+			$pos.value++;
+			break;
+		}
+		if (isComma($pos.value) || isAdd($pos.value)) {
+			constraintName = "";
+			clauseKey = null;
+			columnClause = false;
+			$pos.value++;
+			continue;
+		}
+		if (isLeftParent($pos.value)) {
+			skipGroup();
+			continue;
+		}
+		if (isConstraint($pos.value)) {
+			$pos.value++;
+			if (isString($pos.value) && !isUnique($pos.value) && !isPrimary($pos.value) && !isForeign($pos.value)) {
+				constraintName = tokens[$pos.value].value;
+				$pos.value++;
+			}
+			continue;
+		}
+		if (isUnique($pos.value)) {
+			$pos.value++;
+			if (columnClause) {
+				constraintName = "";
+				continue;
+			}
+			if (isKey($pos.value) || isIndex($pos.value)) $pos.value++;
+			if (isIf($pos.value) && isNot($pos.value + 1) && isExists($pos.value + 2)) $pos.value += 3;
+			$pos.value += keyModifiers($pos.value);
+			let keyName = constraintName;
+			constraintName = "";
+			if (isString($pos.value)) {
+				keyName = tokens[$pos.value].value;
+				$pos.value++;
+				$pos.value += keyModifiers($pos.value);
+			}
+			if (isLeftParent($pos.value)) {
+				const columns = indexColumnsParser(tokens, $pos);
+				if (columns.length) {
+					clauseKey = {
+						type: StatementType.alterTableAddUnique,
+						name,
+						constraintName: keyName,
+						usingIndexName: "",
+						columns
+					};
+					keys.push(clauseKey);
+				}
+			}
+			continue;
+		}
+		const usingIndex = usingIndexName($pos.value);
+		if (usingIndex) {
+			if (clauseKey) clauseKey.usingIndexName = tokens[$pos.value + usingIndex - 1].value;
+			$pos.value += usingIndex;
+			continue;
+		}
+		columnClause = true;
+		$pos.value++;
+	}
+	return keys;
+}
+//#endregion
+export { alterTableAddUniqueParser };

package/dist/schema-sql-parser/dist/parser/statement/alter.table.alter.column.js

@@ -0,0 +1,90 @@
+import { StatementType } from "./index.js";
+import { isAlterValue, isColumnValue, isCommaToken, isDefaultValue, isDropValue, isLeftParentToken, isNewStatement, isRightParentToken, isSemicolonToken, isSetValue, isStringToken, isTableValue, matchAlterTableAlter } from "../helper.js";
+import { isNextvalDefault } from "./default.expression.js";
+//#region ../schema-sql-parser/dist/parser/statement/alter.table.alter.column.js
+var AddIdentity = [[
+	"ADD",
+	"GENERATED",
+	"ALWAYS",
+	"AS",
+	"IDENTITY"
+], [
+	"ADD",
+	"GENERATED",
+	"BY",
+	"DEFAULT",
+	"AS",
+	"IDENTITY"
+]];
+var ColumnActionWords = [
+	"ADD",
+	"DROP",
+	"OPTIONS",
+	"RESET",
+	"RESTART",
+	"SET",
+	"TYPE"
+];
+function alterTableAlterColumnParser(tokens, $pos) {
+	const head = matchAlterTableAlter(tokens);
+	const newStatement = isNewStatement(tokens);
+	const isSemicolon = isSemicolonToken(tokens);
+	const isComma = isCommaToken(tokens);
+	const isLeftParent = isLeftParentToken(tokens);
+	const isRightParent = isRightParentToken(tokens);
+	const isString = isStringToken(tokens);
+	const isAlter = isAlterValue(tokens);
+	const isTable = isTableValue(tokens);
+	const isDrop = isDropValue(tokens);
+	const isColumn = isColumnValue(tokens);
+	const isSet = isSetValue(tokens);
+	const isDefault = isDefaultValue(tokens);
+	const word = (pos) => {
+		const token = tokens[pos];
+		return token && isString(pos) && !token.quoted ? token.value.toUpperCase() : "";
+	};
+	const isWords = (pos, words) => words.every((value, index) => word(pos + index) === value);
+	const isNextvalAt = (pos) => {
+		let end = pos;
+		while (end < tokens.length && !newStatement(end)) end++;
+		return isNextvalDefault(tokens.slice(pos, end))(0);
+	};
+	const makesAutoIncrement = (pos) => isSet(pos) && isDefault(pos + 1) && isNextvalAt(pos + 2) || AddIdentity.some((words) => isWords(pos, words));
+	const isColumnName = (pos) => isString(pos) && (!newStatement(pos) || ColumnActionWords.includes(word(pos + 1)));
+	const length = head($pos.value);
+	const name = tokens[$pos.value + length - 1].value;
+	const ast = [];
+	let depth = 0;
+	let actionStart = true;
+	$pos.value += length;
+	while ($pos.value < tokens.length) {
+		if (isSemicolon($pos.value)) {
+			$pos.value++;
+			break;
+		}
+		if (actionStart && isAlter($pos.value) && !isTable($pos.value + 1)) {
+			actionStart = false;
+			$pos.value++;
+			if (isColumn($pos.value)) $pos.value++;
+			if (isColumnName($pos.value)) {
+				if (makesAutoIncrement($pos.value + 1)) ast.push({
+					type: StatementType.alterTableAlterColumnAutoIncrement,
+					name,
+					columnName: tokens[$pos.value].value
+				});
+				$pos.value++;
+				if (isDrop($pos.value)) $pos.value++;
+			}
+			continue;
+		}
+		if (newStatement($pos.value)) break;
+		actionStart = false;
+		if (isLeftParent($pos.value)) depth++;
+		else if (isRightParent($pos.value)) depth--;
+		else if (depth === 0 && isComma($pos.value)) actionStart = true;
+		$pos.value++;
+	}
+	return ast;
+}
+//#endregion
+export { alterTableAlterColumnParser };

package/dist/schema-sql-parser/dist/parser/statement/comment.on.column.js

@@ -0,0 +1,56 @@
+import { StatementType } from "./index.js";
+import { isIsValue, isNewStatement, isNullValue, isPeriodToken, isSemicolonToken, isStringToken } from "../helper.js";
+//#region ../schema-sql-parser/dist/parser/statement/comment.on.column.js
+function commentOnColumnParser(tokens, $pos) {
+	const newStatement = isNewStatement(tokens);
+	const isString = isStringToken(tokens);
+	const isPeriod = isPeriodToken(tokens);
+	const isSemicolon = isSemicolonToken(tokens);
+	const isIs = isIsValue(tokens);
+	const isNull = isNullValue(tokens);
+	const isToken = () => $pos.value < tokens.length;
+	const ast = {
+		type: StatementType.commentOnColumn,
+		tableName: "",
+		columnName: "",
+		comment: ""
+	};
+	$pos.value += 3;
+	const names = [];
+	let isValue = false;
+	while (isToken() && !newStatement($pos.value)) {
+		let token = tokens[$pos.value];
+		if (isSemicolon($pos.value)) {
+			$pos.value++;
+			break;
+		}
+		if (isIs($pos.value)) {
+			isValue = true;
+			token = tokens[++$pos.value];
+			if (isNull($pos.value)) {
+				$pos.value++;
+				continue;
+			}
+			if (isString($pos.value)) {
+				ast.comment = token.value;
+				$pos.value++;
+			}
+			continue;
+		}
+		if (isPeriod($pos.value)) {
+			$pos.value++;
+			continue;
+		}
+		if (isString($pos.value) && !isValue) {
+			names.push(token.value);
+			$pos.value++;
+			continue;
+		}
+		$pos.value++;
+	}
+	ast.columnName = names.length ? names[names.length - 1] : "";
+	ast.tableName = names.length > 1 ? names[names.length - 2] : "";
+	return ast;
+}
+//#endregion
+export { commentOnColumnParser };