@dineug/erd-editor 4.2.0 → 5.0.0

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

@@ -0,0 +1,701 @@
+import { ReferentialAction } from "./statement/index.js";
+import { TokenType } from "./tokenizer.js";
+import { DatabricksTypes } from "./dataType/Databricks.js";
+import { MariaDBTypes } from "./dataType/MariaDB.js";
+import { MSSQLTypes } from "./dataType/MSSQL.js";
+import { MySQLTypes } from "./dataType/MySQL.js";
+import { OracleTypes } from "./dataType/Oracle.js";
+import { PostgreSQLTypes } from "./dataType/PostgreSQL.js";
+import { SnowflakeTypes } from "./dataType/Snowflake.js";
+import { SQLiteTypes } from "./dataType/SQLite.js";
+//#region ../schema-sql-parser/dist/parser/helper.js
+var createTypeEqual = (type) => (tokens) => (pos) => tokens[pos] ? tokens[pos].type === type : false;
+var createValueEqual = (type) => {
+	const value = type.toUpperCase();
+	return (tokens) => (pos) => {
+		const token = tokens[pos];
+		return token ? !token.quoted && token.value.toUpperCase() === value : false;
+	};
+};
+var isStringToken = createTypeEqual(TokenType.string);
+var isEqualToken = createTypeEqual(TokenType.equal);
+var isPeriodToken = createTypeEqual(TokenType.period);
+var isCommaToken = createTypeEqual(TokenType.comma);
+var isSemicolonToken = createTypeEqual(TokenType.semicolon);
+var isLeftParentToken = createTypeEqual(TokenType.leftParent);
+var isRightParentToken = createTypeEqual(TokenType.rightParent);
+TokenType.leftBracket;
+var isRightBracketToken = createTypeEqual(TokenType.rightBracket);
+var isCreateValue = createValueEqual("CREATE");
+var isAlterValue = createValueEqual("ALTER");
+var isDropValue = createValueEqual("DROP");
+var isUseValue = createValueEqual("USE");
+var isRenameValue = createValueEqual("RENAME");
+var isDeleteValue = createValueEqual("DELETE");
+var isSelectValue = createValueEqual("SELECT");
+var isTableValue = createValueEqual("TABLE");
+var isTablespaceValue = createValueEqual("TABLESPACE");
+var isIndexValue = createValueEqual("INDEX");
+var isUniqueValue = createValueEqual("UNIQUE");
+var isAddValue = createValueEqual("ADD");
+var isPrimaryValue = createValueEqual("PRIMARY");
+var isKeyValue = createValueEqual("KEY");
+var isConstraintValue = createValueEqual("CONSTRAINT");
+var isForeignValue = createValueEqual("FOREIGN");
+var isNotValue = createValueEqual("NOT");
+var isNullValue = createValueEqual("NULL");
+var isDefaultValue = createValueEqual("DEFAULT");
+var isCommentValue = createValueEqual("COMMENT");
+var isReferencesValue = createValueEqual("REFERENCES");
+var isAscValue = createValueEqual("ASC");
+var isDescValue = createValueEqual("DESC");
+var isOnValue = createValueEqual("ON");
+var isAuto_incrementValue = createValueEqual("AUTO_INCREMENT");
+var isAutoincrementValue = createValueEqual("AUTOINCREMENT");
+var isIfValue = createValueEqual("IF");
+var isExistsValue = createValueEqual("EXISTS");
+var isOnlyValue = createValueEqual("ONLY");
+var isIsValue = createValueEqual("IS");
+var isColumnValue = createValueEqual("COLUMN");
+var isCharacterValue = createValueEqual("CHARACTER");
+var isSetValue = createValueEqual("SET");
+var isCollateValue = createValueEqual("COLLATE");
+var isEnforcedValue = createValueEqual("ENFORCED");
+var isRelyValue = createValueEqual("RELY");
+var isNorelyValue = createValueEqual("NORELY");
+var isDeferrableValue = createValueEqual("DEFERRABLE");
+var isInitiallyValue = createValueEqual("INITIALLY");
+var isDeferredValue = createValueEqual("DEFERRED");
+var isImmediateValue = createValueEqual("IMMEDIATE");
+var isIdentityValue = createValueEqual("IDENTITY");
+var isFunctionValue = createValueEqual("FUNCTION");
+var isClusterValue = createValueEqual("CLUSTER");
+var isByValue = createValueEqual("BY");
+var isFulltextValue = createValueEqual("FULLTEXT");
+var isSpatialValue = createValueEqual("SPATIAL");
+var isWithValue = createValueEqual("WITH");
+var isCheckValue = createValueEqual("CHECK");
+var isNocheckValue = createValueEqual("NOCHECK");
+var isConcurrentlyValue = createValueEqual("CONCURRENTLY");
+var isWhereValue = createValueEqual("WHERE");
+var isUsingValue = createValueEqual("USING");
+var isAndValue = createValueEqual("AND");
+var isOrValue = createValueEqual("OR");
+var isArrayValue = createValueEqual("ARRAY");
+var isGeneratedValue = createValueEqual("GENERATED");
+var isForValue = createValueEqual("FOR");
+var isExecValue = createValueEqual("EXEC");
+var isExecuteValue = createValueEqual("EXECUTE");
+var isGoValue = createValueEqual("GO");
+var isSignedValue = createValueEqual("SIGNED");
+var TypeModifiers = [
+	"SIGNED",
+	"UNSIGNED",
+	"ZEROFILL"
+];
+var isTypeModifier = (tokens) => (pos) => {
+	const token = tokens[pos];
+	return !!token && !token.quoted && TypeModifiers.includes(token.value.toUpperCase());
+};
+var toStringLiteral = (value, database) => database === "Databricks" ? `'${value.replace(/[\\']/g, "\\$&")}'` : `'${value.replaceAll("'", "''")}'`;
+var requote = ({ value, quoted, prefix = "" }, database) => {
+	if (!quoted) return value;
+	if (quoted === "[") return `[${value}]`;
+	if (quoted === "'") return prefix + toStringLiteral(value, database);
+	return `${quoted}${value.replaceAll(quoted, quoted + quoted)}${quoted}`;
+};
+var isConstraintState = (tokens) => {
+	const isEnforced = isEnforcedValue(tokens);
+	const isRely = isRelyValue(tokens);
+	const isNorely = isNorelyValue(tokens);
+	const isDeferrable = isDeferrableValue(tokens);
+	const isInitially = isInitiallyValue(tokens);
+	const isDeferred = isDeferredValue(tokens);
+	const isImmediate = isImmediateValue(tokens);
+	return (pos) => isEnforced(pos) || isRely(pos) || isNorely(pos) || isDeferrable(pos) || isInitially(pos) || isDeferred(pos) || isImmediate(pos);
+};
+var ReferentialActions = [
+	ReferentialAction.setNull,
+	ReferentialAction.setDefault,
+	ReferentialAction.noAction,
+	ReferentialAction.cascade,
+	ReferentialAction.restrict
+];
+var MatchKinds = [
+	"FULL",
+	"PARTIAL",
+	"SIMPLE"
+];
+var matchReferentialClause = (tokens) => {
+	const word = (pos) => {
+		const token = tokens[pos];
+		return token && token.type === TokenType.string && !token.quoted ? token.value.toUpperCase() : "";
+	};
+	const columnList = (pos) => {
+		if (tokens[pos]?.type !== TokenType.leftParent) return 0;
+		for (let cursor = pos + 1; cursor < tokens.length; cursor++) {
+			const { type } = tokens[cursor];
+			if (type === TokenType.rightParent) return cursor - pos + 1;
+			if (type !== TokenType.string && type !== TokenType.comma) return 0;
+		}
+		return 0;
+	};
+	return (pos) => {
+		const event = word(pos + 1);
+		if (word(pos) === "ON" && (event === "DELETE" || event === "UPDATE")) {
+			const action = ReferentialActions.find((value) => value.split(" ").every((part, index) => word(pos + 2 + index) === part));
+			if (!action) return {
+				span: 2,
+				event,
+				action: ""
+			};
+			const span = 2 + action.split(" ").length;
+			return {
+				span: span + (action.startsWith("SET ") ? columnList(pos + span) : 0),
+				event,
+				action
+			};
+		}
+		return {
+			span: word(pos) === "MATCH" && MatchKinds.includes(word(pos + 1)) ? 2 : 0,
+			event: "",
+			action: ""
+		};
+	};
+};
+var isIndexKind = (tokens) => {
+	const isFulltext = isFulltextValue(tokens);
+	const isSpatial = isSpatialValue(tokens);
+	const isIndex = isIndexValue(tokens);
+	const isKey = isKeyValue(tokens);
+	return (pos) => (isFulltext(pos) || isSpatial(pos)) && (isIndex(pos + 1) || isKey(pos + 1));
+};
+var matchKeyword = (tokens) => (pos) => {
+	const token = tokens[pos];
+	return token && token.type === TokenType.string && !token.quoted ? token.value.toUpperCase() : "";
+};
+var isClustering = (word) => word === "CLUSTERED" || word === "NONCLUSTERED";
+var matchKeyModifier = (tokens) => {
+	const word = matchKeyword(tokens);
+	return (pos) => {
+		const first = word(pos);
+		if (isClustering(first)) return 1;
+		if (first === "USING") return word(pos + 1) ? 2 : 1;
+		if (first !== "NULLS") return 0;
+		if (word(pos + 1) === "DISTINCT") return 2;
+		return word(pos + 1) === "NOT" && word(pos + 2) === "DISTINCT" ? 3 : 0;
+	};
+};
+var matchKeyModifiers = (tokens) => {
+	const keyModifier = matchKeyModifier(tokens);
+	return (pos) => {
+		let cursor = pos;
+		let span = keyModifier(cursor);
+		while (span) {
+			cursor += span;
+			span = keyModifier(cursor);
+		}
+		return cursor - pos;
+	};
+};
+var NestedDataTypes = [
+	"ARRAY",
+	"MAP",
+	"STRUCT"
+];
+var matchNestedDataType = (tokens) => {
+	const isString = isStringToken(tokens);
+	const angleDepth = (value) => {
+		let depth = 0;
+		for (const char of value) if (char === "<") depth++;
+		else if (char === ">") depth--;
+		return depth;
+	};
+	return (pos) => {
+		const token = tokens[pos];
+		if (!token || token.quoted || !isString(pos)) return 0;
+		const open = token.value.indexOf("<");
+		if (open === -1) return 0;
+		if (!NestedDataTypes.includes(token.value.slice(0, open).toUpperCase())) return 0;
+		let depth = 0;
+		for (let cursor = pos; cursor < tokens.length; cursor++) {
+			if (!tokens[cursor].quoted) depth += angleDepth(tokens[cursor].value);
+			if (depth <= 0) return cursor - pos + 1;
+		}
+		return tokens.length - pos;
+	};
+};
+var isAutoIncrementValue = (tokens) => {
+	const isAuto_increment = isAuto_incrementValue(tokens);
+	const isAutoincrement = isAutoincrementValue(tokens);
+	const isIdentity = isIdentityValue(tokens);
+	return (pos) => isAuto_increment(pos) || isAutoincrement(pos) || isIdentity(pos);
+};
+var isClusterBy = (tokens) => {
+	const isCluster = isClusterValue(tokens);
+	const isBy = isByValue(tokens);
+	return (pos) => isCluster(pos) && isBy(pos + 1);
+};
+var isCommentOn = (tokens) => {
+	const isComment = isCommentValue(tokens);
+	const isOn = isOnValue(tokens);
+	return (pos) => isComment(pos) && isOn(pos + 1);
+};
+var isCommentOnTable = (tokens) => {
+	const commentOn = isCommentOn(tokens);
+	const isTable = isTableValue(tokens);
+	return (pos) => commentOn(pos) && isTable(pos + 2);
+};
+var isCommentOnColumn = (tokens) => {
+	const commentOn = isCommentOn(tokens);
+	const isColumn = isColumnValue(tokens);
+	return (pos) => commentOn(pos) && isColumn(pos + 2);
+};
+var isNewStatement = (tokens) => {
+	const isCreate = isCreateValue(tokens);
+	const isAlter = isAlterValue(tokens);
+	const isDrop = isDropValue(tokens);
+	const isUse = isUseValue(tokens);
+	const isRename = isRenameValue(tokens);
+	const isDelete = isDeleteValue(tokens);
+	const isSelect = isSelectValue(tokens);
+	const commentOn = isCommentOn(tokens);
+	const addExtendedProperty = isAddExtendedProperty(tokens);
+	return (pos) => isCreate(pos) || isAlter(pos) || isDrop(pos) || isUse(pos) || isRename(pos) || isDelete(pos) || isSelect(pos) || commentOn(pos) || addExtendedProperty(pos);
+};
+var CreateTableModifiers = [
+	"OR",
+	"REPLACE",
+	"TRANSIENT",
+	"TEMPORARY",
+	"TEMP",
+	"LOCAL",
+	"GLOBAL",
+	"VOLATILE",
+	"UNLOGGED",
+	"HYBRID",
+	"ICEBERG",
+	"DYNAMIC",
+	"EXTERNAL"
+];
+var matchCreateTable = (tokens) => {
+	const isCreate = isCreateValue(tokens);
+	const isTable = isTableValue(tokens);
+	const isString = isStringToken(tokens);
+	const isFunction = isFunctionValue(tokens);
+	const isIf = isIfValue(tokens);
+	const isNot = isNotValue(tokens);
+	const isExists = isExistsValue(tokens);
+	return (pos) => {
+		if (!isCreate(pos)) return 0;
+		let cursor = pos + 1;
+		while (cursor < tokens.length && !isTable(cursor)) {
+			const token = tokens[cursor];
+			if (!isString(cursor) || token.quoted || !CreateTableModifiers.includes(token.value.toUpperCase())) return 0;
+			cursor++;
+		}
+		if (!isTable(cursor)) return 0;
+		if (isFunction(cursor + 1)) return 0;
+		cursor++;
+		if (isIf(cursor) && isNot(cursor + 1) && isExists(cursor + 2)) cursor += 3;
+		return cursor - pos;
+	};
+};
+var isCharacterSet = (tokens) => {
+	const isCharacter = isCharacterValue(tokens);
+	const isSet = isSetValue(tokens);
+	return (pos) => isCharacter(pos) && isSet(pos + 1);
+};
+var isCreateTable = (tokens) => {
+	const createTable = matchCreateTable(tokens);
+	return (pos) => createTable(pos) > 0;
+};
+var matchCreateIndex = (tokens) => {
+	const isCreate = isCreateValue(tokens);
+	const isUnique = isUniqueValue(tokens);
+	const isIndex = isIndexValue(tokens);
+	const word = matchKeyword(tokens);
+	return (pos) => {
+		if (!isCreate(pos)) return 0;
+		let cursor = pos + 1;
+		if (isUnique(cursor)) cursor++;
+		if (isClustering(word(cursor))) cursor++;
+		return isIndex(cursor) ? cursor + 1 - pos : 0;
+	};
+};
+var isCreateIndex = (tokens) => {
+	const createIndex = matchCreateIndex(tokens);
+	return (pos) => createIndex(pos) > 0;
+};
+var isAlterTable = (tokens) => {
+	const isAlter = isAlterValue(tokens);
+	const isTable = isTableValue(tokens);
+	return (pos) => isAlter(pos) && isTable(pos + 1);
+};
+var matchQualifiedName = (tokens) => {
+	const isString = isStringToken(tokens);
+	const isPeriod = isPeriodToken(tokens);
+	return (pos) => {
+		if (!isString(pos)) return 0;
+		let cursor = pos + 1;
+		while (isPeriod(cursor) && isString(cursor + 1)) cursor += 2;
+		return cursor - pos;
+	};
+};
+var matchAddExtendedProperty = (tokens) => {
+	const isExec = isExecValue(tokens);
+	const isExecute = isExecuteValue(tokens);
+	const qualifiedName = matchQualifiedName(tokens);
+	return (pos) => {
+		if (!isExec(pos) && !isExecute(pos)) return 0;
+		const name = qualifiedName(pos + 1);
+		return name > 0 && tokens[pos + name].value.toUpperCase() === "SP_ADDEXTENDEDPROPERTY" ? name + 1 : 0;
+	};
+};
+var isAddExtendedProperty = (tokens) => {
+	const addExtendedProperty = matchAddExtendedProperty(tokens);
+	return (pos) => addExtendedProperty(pos) > 0;
+};
+var IndexProperties = [
+	"COMPRESS",
+	"COMPUTE",
+	"DEFERRABLE",
+	"DISABLE",
+	"ENABLE",
+	"EXCEPTIONS",
+	"FILESYSTEM_LIKE_LOGGING",
+	"GLOBAL",
+	"INDEXING",
+	"INDEXTYPE",
+	"INITIALLY",
+	"INITRANS",
+	"INVISIBLE",
+	"LOCAL",
+	"LOGGING",
+	"MAXTRANS",
+	"NOCOMPRESS",
+	"NOLOGGING",
+	"NOPARALLEL",
+	"NORELY",
+	"NOSORT",
+	"NOT",
+	"NOVALIDATE",
+	"ONLINE",
+	"PARALLEL",
+	"PCTFREE",
+	"PCTUSED",
+	"RELY",
+	"REVERSE",
+	"SORT",
+	"STORAGE",
+	"TABLESPACE",
+	"USING",
+	"VALIDATE",
+	"VISIBLE"
+];
+var matchUsingIndexName = (tokens) => {
+	const word = matchKeyword(tokens);
+	const qualifiedName = matchQualifiedName(tokens);
+	return (pos) => {
+		if (word(pos) !== "USING" || word(pos + 1) !== "INDEX") return 0;
+		const name = qualifiedName(pos + 2);
+		return name && !IndexProperties.includes(word(pos + 2)) ? 2 + name : 0;
+	};
+};
+var isNullFilter = (tokens) => {
+	const isWhere = isWhereValue(tokens);
+	const isString = isStringToken(tokens);
+	const isLeftParent = isLeftParentToken(tokens);
+	const isRightParent = isRightParentToken(tokens);
+	const isIs = isIsValue(tokens);
+	const isNot = isNotValue(tokens);
+	const isNull = isNullValue(tokens);
+	const isAnd = isAndValue(tokens);
+	const isOr = isOrValue(tokens);
+	return (pos, columnNames) => {
+		if (!isWhere(pos)) return false;
+		const names = new Set(columnNames.map((name) => name.toUpperCase()));
+		let depth = 0;
+		do {
+			pos++;
+			for (; isLeftParent(pos); pos++) depth++;
+			if (!isString(pos) || !names.has(tokens[pos].value.toUpperCase()) || !isIs(pos + 1) || !isNot(pos + 2) || !isNull(pos + 3)) return false;
+			pos += 4;
+			for (; depth > 0 && isRightParent(pos); pos++) depth--;
+		} while (isAnd(pos));
+		return !isOr(pos);
+	};
+};
+var ConstraintBodies = [
+	"UNIQUE",
+	"PRIMARY",
+	"FOREIGN",
+	"CHECK",
+	"DEFAULT"
+];
+var matchAlterTableAddHead = (tokens) => {
+	const alterTable = isAlterTable(tokens);
+	const isOnly = isOnlyValue(tokens);
+	const isAdd = isAddValue(tokens);
+	const isConstraint = isConstraintValue(tokens);
+	const isString = isStringToken(tokens);
+	const isWith = isWithValue(tokens);
+	const isCheck = isCheckValue(tokens);
+	const isNocheck = isNocheckValue(tokens);
+	const qualifiedName = matchQualifiedName(tokens);
+	const word = matchKeyword(tokens);
+	const fromName = (pos, start) => {
+		let cursor = start;
+		const name = qualifiedName(cursor);
+		if (!name) return 0;
+		cursor += name;
+		if (isWith(cursor) && (isCheck(cursor + 1) || isNocheck(cursor + 1))) cursor += 2;
+		if (!isAdd(cursor)) return 0;
+		cursor++;
+		if (isConstraint(cursor)) {
+			cursor++;
+			if (isString(cursor) && !ConstraintBodies.includes(word(cursor))) cursor++;
+		}
+		return cursor - pos;
+	};
+	return (pos) => {
+		if (!alterTable(pos)) return {
+			length: 0,
+			only: false
+		};
+		const start = pos + 2;
+		if (isOnly(start)) {
+			const length = fromName(pos, start + 1);
+			if (length) return {
+				length,
+				only: true
+			};
+		}
+		return {
+			length: fromName(pos, start),
+			only: false
+		};
+	};
+};
+var matchAlterTableAdd = (tokens) => {
+	const head = matchAlterTableAddHead(tokens);
+	return (pos) => head(pos).length;
+};
+var isAlterTableAddOnly = (tokens) => {
+	const head = matchAlterTableAddHead(tokens);
+	return (pos) => head(pos).only;
+};
+var isAlterTableAddPrimaryKey = (tokens) => {
+	const alterTableAdd = matchAlterTableAdd(tokens);
+	const isPrimary = isPrimaryValue(tokens);
+	const isKey = isKeyValue(tokens);
+	return (pos) => {
+		const length = alterTableAdd(pos);
+		return length > 0 && isPrimary(pos + length) && isKey(pos + length + 1);
+	};
+};
+var isAlterTableAddForeignKey = (tokens) => {
+	const alterTableAdd = matchAlterTableAdd(tokens);
+	const isForeign = isForeignValue(tokens);
+	const isKey = isKeyValue(tokens);
+	return (pos) => {
+		const length = alterTableAdd(pos);
+		return length > 0 && isForeign(pos + length) && isKey(pos + length + 1);
+	};
+};
+var isAlterTableAddDefault = (tokens) => {
+	const alterTableAdd = matchAlterTableAdd(tokens);
+	const isDefault = isDefaultValue(tokens);
+	return (pos) => {
+		const length = alterTableAdd(pos);
+		return length > 0 && isDefault(pos + length);
+	};
+};
+var isAlterTableAdd = (tokens) => {
+	const alterTableAdd = matchAlterTableAdd(tokens);
+	return (pos) => alterTableAdd(pos) > 0;
+};
+var matchAlterTableAlter = (tokens) => {
+	const alterTable = isAlterTable(tokens);
+	const isOnly = isOnlyValue(tokens);
+	const isAlter = isAlterValue(tokens);
+	const isTable = isTableValue(tokens);
+	const qualifiedName = matchQualifiedName(tokens);
+	const fromName = (pos, start) => {
+		const name = qualifiedName(start);
+		const end = start + name;
+		return name && isAlter(end) && !isTable(end + 1) ? end - pos : 0;
+	};
+	return (pos) => {
+		if (!alterTable(pos)) return 0;
+		const start = pos + 2;
+		return isOnly(start) && fromName(pos, start + 1) || fromName(pos, start);
+	};
+};
+var isAlterTableAlter = (tokens) => {
+	const alterTableAlter = matchAlterTableAlter(tokens);
+	return (pos) => alterTableAlter(pos) > 0;
+};
+var DataTypes = Array.from(new Set([
+	...DatabricksTypes,
+	...MariaDBTypes,
+	...MSSQLTypes,
+	...MySQLTypes,
+	...OracleTypes,
+	...PostgreSQLTypes,
+	...SnowflakeTypes,
+	...SQLiteTypes
+].map((type) => type.toUpperCase())));
+var groupByFirstWord = (types) => {
+	const groups = /* @__PURE__ */ new Map();
+	for (const type of types) {
+		const words = type.split(" ");
+		const candidates = groups.get(words[0]) ?? [];
+		candidates.push(words);
+		groups.set(words[0], candidates);
+	}
+	for (const candidates of groups.values()) candidates.sort((a, b) => b.length - a.length);
+	return groups;
+};
+var DataTypeWords = groupByFirstWord(DataTypes);
+var createSkipArguments = (tokens) => {
+	const isLeftParent = isLeftParentToken(tokens);
+	const isRightParent = isRightParentToken(tokens);
+	return (pos) => {
+		let depth = 0;
+		for (let cursor = pos; cursor < tokens.length; cursor++) if (isLeftParent(cursor)) depth++;
+		else if (isRightParent(cursor)) {
+			depth--;
+			if (depth === 0) return cursor + 1;
+		}
+		return tokens.length;
+	};
+};
+var isArrayDimensionToken = (tokens) => (pos) => {
+	const token = tokens[pos];
+	return !!token && token.quoted === "[" && /^\d*$/.test(token.value);
+};
+var matchArraySuffix = (tokens) => {
+	const isDimension = isArrayDimensionToken(tokens);
+	const isArray = isArrayValue(tokens);
+	return (pos) => {
+		if (isArray(pos)) return isDimension(pos + 1) ? 2 : 1;
+		let cursor = pos;
+		while (isDimension(cursor)) cursor++;
+		return cursor - pos;
+	};
+};
+var matchDataType = (tokens) => {
+	const isString = isStringToken(tokens);
+	const isLeftParent = isLeftParentToken(tokens);
+	const skipArguments = createSkipArguments(tokens);
+	const arraySuffix = matchArraySuffix(tokens);
+	const matchWords = (pos, words) => {
+		let cursor = pos;
+		for (const [index, word] of words.entries()) {
+			const token = tokens[cursor];
+			if (!token || !isString(cursor) || index > 0 && token.quoted) return 0;
+			if (token.value.toUpperCase() !== word) return 0;
+			cursor++;
+			if (isLeftParent(cursor)) cursor = skipArguments(cursor);
+		}
+		return cursor - pos;
+	};
+	return (pos) => {
+		const token = tokens[pos];
+		if (!token || !isString(pos)) return 0;
+		const value = token.value.toUpperCase();
+		for (const words of DataTypeWords.get(value) ?? []) {
+			const length = matchWords(pos, words);
+			if (length) return length + arraySuffix(pos + length);
+		}
+		return DataTypes.includes(value) ? 1 + arraySuffix(pos + 1) : 0;
+	};
+};
+var ColumnKeywords = [
+	"AS",
+	"AUTO_INCREMENT",
+	"AUTOINCREMENT",
+	"CHECK",
+	"COLLATE",
+	"COMMENT",
+	"CONSTRAINT",
+	"DEFAULT",
+	"ENCRYPT",
+	"FOR",
+	"FOREIGN",
+	"GENERATED",
+	"IDENTITY",
+	"INVISIBLE",
+	"KEY",
+	"MASKING",
+	"NOT",
+	"NULL",
+	"ON",
+	"PRIMARY",
+	"PROJECTION",
+	"REFERENCES",
+	"UNIQUE",
+	"USING",
+	"VISIBLE",
+	"WITH"
+];
+var isKeyword = (value) => ColumnKeywords.includes(value.toUpperCase());
+var isColumnKeyword = (token) => !!token && !token.quoted && isKeyword(token.value);
+var isColumnKeywordValue = (tokens) => (pos) => isColumnKeyword(tokens[pos]);
+var unquoteTypeName = (token) => token.quoted === "\"" && (token.value === "char" || token.value === "bit") ? requote(token) : token.value;
+var matchUserDataType = (tokens) => {
+	const isString = isStringToken(tokens);
+	const isPeriod = isPeriodToken(tokens);
+	const isComma = isCommaToken(tokens);
+	const isLeftParent = isLeftParentToken(tokens);
+	const isRightParent = isRightParentToken(tokens);
+	const skipArguments = createSkipArguments(tokens);
+	const arraySuffix = matchArraySuffix(tokens);
+	const dataType = matchDataType(tokens);
+	const isName = (pos) => isString(pos) && tokens[pos].quoted !== "'";
+	const isBareWord = (pos) => isString(pos) && !tokens[pos].quoted && !isKeyword(tokens[pos].value);
+	const endsColumn = (pos) => pos >= tokens.length || isComma(pos) || isRightParent(pos) || isColumnKeyword(tokens[pos]);
+	const isColumnOption = (pos) => {
+		const token = tokens[pos];
+		if (token.quoted) return false;
+		const word = token.value.toUpperCase();
+		return word === "TAG" && isLeftParent(pos + 1) || word === "SORT" && endsColumn(pos + 1);
+	};
+	return (pos) => {
+		if (!isName(pos)) return 0;
+		if (isColumnKeyword(tokens[pos]) || isColumnOption(pos)) return 0;
+		for (let cursor = pos; isBareWord(cursor); cursor++) {
+			const known = dataType(cursor + 1);
+			if (known) return cursor + 1 + known - pos;
+		}
+		let cursor = pos + 1;
+		while (isPeriod(cursor) && isName(cursor + 1)) cursor += 2;
+		if (isLeftParent(cursor)) cursor = skipArguments(cursor);
+		return cursor + arraySuffix(cursor) - pos;
+	};
+};
+var isTableItemWord = (tokens) => {
+	const isString = isStringToken(tokens);
+	const isLeftParent = isLeftParentToken(tokens);
+	const dataType = matchDataType(tokens);
+	const word = (pos) => {
+		const token = tokens[pos];
+		return token && isString(pos) && !token.quoted ? token.value.toUpperCase() : "";
+	};
+	const isItemName = (pos) => isString(pos) && tokens[pos].quoted !== "'" && !dataType(pos);
+	return (pos) => {
+		switch (word(pos)) {
+			case "CHECK": return isLeftParent(pos + 1) || word(pos + 1) === "NOT" && word(pos + 2) === "FOR" && word(pos + 3) === "REPLICATION";
+			case "LIKE": return isItemName(pos + 1);
+			case "EXCLUDE": return word(pos + 1) === "USING" || isLeftParent(pos + 1);
+			case "FULLTEXT":
+			case "SPATIAL": return isLeftParent(pos + 1) || isItemName(pos + 1) && isLeftParent(pos + 2);
+			case "PERIOD": return word(pos + 1) === "FOR";
+			case "SUPPLEMENTAL": return word(pos + 1) === "LOG";
+			default: return false;
+		}
+	};
+};
+//#endregion
+export { isAddExtendedProperty, isAddValue, isAlterTable, isAlterTableAdd, isAlterTableAddDefault, isAlterTableAddForeignKey, isAlterTableAddOnly, isAlterTableAddPrimaryKey, isAlterTableAlter, isAlterValue, isAndValue, isArrayDimensionToken, isArrayValue, isAscValue, isAutoIncrementValue, isAuto_incrementValue, isAutoincrementValue, isByValue, isCharacterSet, isCharacterValue, isCheckValue, isClusterBy, isClusterValue, isCollateValue, isColumnKeywordValue, isColumnValue, isCommaToken, isCommentOn, isCommentOnColumn, isCommentOnTable, isCommentValue, isConcurrentlyValue, isConstraintState, isConstraintValue, isCreateIndex, isCreateTable, isCreateValue, isDefaultValue, isDeferrableValue, isDeferredValue, isDeleteValue, isDescValue, isDropValue, isEnforcedValue, isEqualToken, isExecValue, isExecuteValue, isExistsValue, isForValue, isForeignValue, isFulltextValue, isFunctionValue, isGeneratedValue, isGoValue, isIdentityValue, isIfValue, isImmediateValue, isIndexKind, isIndexValue, isInitiallyValue, isIsValue, isKeyValue, isLeftParentToken, isNewStatement, isNocheckValue, isNorelyValue, isNotValue, isNullFilter, isNullValue, isOnValue, isOnlyValue, isOrValue, isPeriodToken, isPrimaryValue, isReferencesValue, isRelyValue, isRenameValue, isRightBracketToken, isRightParentToken, isSelectValue, isSemicolonToken, isSetValue, isSignedValue, isSpatialValue, isStringToken, isTableItemWord, isTableValue, isTablespaceValue, isTypeModifier, isUniqueValue, isUseValue, isUsingValue, isWhereValue, isWithValue, matchAddExtendedProperty, matchAlterTableAlter, matchCreateIndex, matchCreateTable, matchDataType, matchKeyModifier, matchKeyModifiers, matchNestedDataType, matchQualifiedName, matchReferentialClause, matchUserDataType, matchUsingIndexName, requote, toStringLiteral, unquoteTypeName };