@dineug/erd-editor 4.2.0 → 5.0.0

package/dist/schema-sql-parser/dist/parser/statement/default.expression.js

@@ -0,0 +1,206 @@
+import { TokenType } from "../tokenizer.js";
+import { isCharacterSet, isColumnKeywordValue, isCommaToken, isConstraintState, isLeftParentToken, isRightBracketToken, isRightParentToken, isSemicolonToken, requote, toStringLiteral } from "../helper.js";
+//#region ../schema-sql-parser/dist/parser/statement/default.expression.js
+var QuotedKinds = {
+	"'": "string",
+	"[": "bracket",
+	"\"": "word",
+	"`": "word"
+};
+var ExpressionWords = [
+	"AND",
+	"AT",
+	"BETWEEN",
+	"COLLATE",
+	"ILIKE",
+	"IN",
+	"IS",
+	"LIKE",
+	"NOT",
+	"OR",
+	"OVERLAPS",
+	"SIMILAR"
+];
+var VendorColumnWords = [
+	"COLUMN_FORMAT",
+	"INDEX",
+	"MASK",
+	"ROWGUIDCOL",
+	"SPARSE",
+	"STORAGE"
+];
+var NUMBER = /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?$/i;
+var TYPE_WORD = /^(?:[a-z_][\w$]*|"(?:[^"]|"")*")$/i;
+var ARRAY_DIMENSION = /^\[\d*\]$/;
+var word = (token) => token && token.type === TokenType.string && !token.quoted ? token.value.toUpperCase() : "";
+var isNextValueFor = (tokens) => (pos) => word(tokens[pos]) === "FOR" && word(tokens[pos - 1]) === "VALUE" && word(tokens[pos - 2]) === "NEXT";
+var matchDefaultExpression = (tokens) => {
+	const isComma = isCommaToken(tokens);
+	const isLeftParent = isLeftParentToken(tokens);
+	const isRightParent = isRightParentToken(tokens);
+	const isRightBracket = isRightBracketToken(tokens);
+	const isSemicolon = isSemicolonToken(tokens);
+	const isColumnKeyword = isColumnKeywordValue(tokens);
+	const constraintState = isConstraintState(tokens);
+	const characterSet = isCharacterSet(tokens);
+	const nextValueFor = isNextValueFor(tokens);
+	const isTimeZone = (pos) => {
+		if (word(tokens[pos]) === "LOCAL") return isTimeZone(pos + 1);
+		return word(tokens[pos]) === "TIME" && word(tokens[pos + 1]) === "ZONE";
+	};
+	const endsAt = (pos) => {
+		const keyword = word(tokens[pos]);
+		if (keyword === "FOR") return !nextValueFor(pos);
+		if (keyword === "WITH" || keyword === "WITHOUT") return !isTimeZone(pos + 1);
+		if (keyword === "TAG") return isLeftParent(pos + 1);
+		return isColumnKeyword(pos) || VendorColumnWords.includes(keyword) || constraintState(pos) || characterSet(pos);
+	};
+	const isCase = (pos) => word(tokens[pos]) === "CASE";
+	const isEnd = (pos) => /^END(?:::|$)/.test(word(tokens[pos]));
+	return (pos) => {
+		let depth = 0;
+		let cursor = pos;
+		for (; cursor < tokens.length && !isSemicolon(cursor); cursor++) if (isLeftParent(cursor) || isCase(cursor)) depth++;
+		else if (isRightParent(cursor)) {
+			if (depth === 0) break;
+			depth--;
+		} else if (depth > 0) {
+			if (isEnd(cursor)) depth--;
+		} else if (isComma(cursor) || isRightBracket(cursor)) break;
+		else if (cursor > pos && endsAt(cursor)) break;
+		return cursor - pos;
+	};
+};
+var toPieces = (tokens, database) => tokens.flatMap((token) => {
+	switch (token.type) {
+		case TokenType.leftParent: return [{
+			kind: "open",
+			text: "("
+		}];
+		case TokenType.rightParent: return [{
+			kind: "close",
+			text: ")"
+		}];
+		case TokenType.comma: return [{
+			kind: "comma",
+			text: ","
+		}];
+		case TokenType.period: return [{
+			kind: "period",
+			text: "."
+		}];
+	}
+	if (token.quoted) return [{
+		kind: QuotedKinds[token.quoted],
+		text: requote(token, database),
+		token
+	}];
+	return token.value.split("::").flatMap((part, index) => [...index ? [{
+		kind: "cast",
+		text: "::"
+	}] : [], ...part ? [{
+		kind: "word",
+		text: part
+	}] : []]);
+});
+var isOperator = (piece) => piece.kind === "word" && !/[\p{L}\p{N}_$#@'"`]/u.test(piece.text);
+var isSubscript = (prev, next) => /^ARRAY$/i.test(prev.text) || !/^\[[\p{L}_@#]/u.test(next.text);
+var isSplitOperator = (prev, next) => prev.kind === "word" && next.kind === "word" && (next.text === "=" && /[<>!=]$/.test(prev.text) || prev.text === "=" && next.text.startsWith(">"));
+var spaceBetween = (prev, next) => {
+	if ([
+		"close",
+		"comma",
+		"period",
+		"cast"
+	].includes(next.kind)) return false;
+	if ([
+		"open",
+		"period",
+		"cast"
+	].includes(prev.kind)) return false;
+	if (prev.kind === "comma") return true;
+	if (isSplitOperator(prev, next)) return false;
+	if (next.kind === "bracket" && !isSubscript(prev, next)) return true;
+	if (next.kind === "open" || next.kind === "bracket") return isOperator(prev);
+	return true;
+};
+var render = (pieces) => pieces.reduce((text, piece, index) => index && spaceBetween(pieces[index - 1], piece) ? `${text} ${piece.text}` : text + piece.text, "");
+var closeOf = (pieces, start) => {
+	let depth = 0;
+	for (let index = start; index < pieces.length; index++) if (pieces[index].kind === "open") depth++;
+	else if (pieces[index].kind === "close" && --depth === 0) return index;
+	return -1;
+};
+var unwrap = (pieces) => {
+	let inner = pieces;
+	while (inner.length > 1 && inner[0].kind === "open" && closeOf(inner, 0) === inner.length - 1) inner = inner.slice(1, -1);
+	return inner;
+};
+var isTypeName = (pieces) => {
+	let depth = 0;
+	return pieces.length > 0 && pieces[0].kind === "word" && pieces.every(({ kind, text }) => {
+		if (kind === "open") {
+			depth++;
+			return true;
+		}
+		if (kind === "close") return --depth >= 0;
+		if (depth > 0 || kind === "period") return true;
+		if (kind === "bracket") return ARRAY_DIMENSION.test(text);
+		return kind === "word" && TYPE_WORD.test(text) && !ExpressionWords.includes(text.toUpperCase());
+	});
+};
+var isLiteral = (pieces) => {
+	if (pieces.length === 1 && pieces[0].kind === "string") return true;
+	const text = render(pieces);
+	return NUMBER.test(text) || /^(?:null|true|false)$/i.test(text);
+};
+var lastCastOf = (pieces) => {
+	let depth = 0;
+	let cast = -1;
+	pieces.forEach(({ kind }, index) => {
+		if (kind === "open") depth++;
+		else if (kind === "close") depth--;
+		else if (depth === 0 && kind === "cast") cast = index;
+	});
+	return cast;
+};
+var uncast = (pieces) => {
+	const cast = lastCastOf(pieces);
+	if (cast === -1 || !isTypeName(pieces.slice(cast + 1))) return pieces;
+	const operand = unwrap(pieces.slice(0, cast));
+	return isLiteral(operand) ? operand : pieces;
+};
+function writeDefaultExpression(tokens, database) {
+	const pieces = uncast(unwrap(toPieces(tokens, database)));
+	const [first] = pieces;
+	if (pieces.length === 1 && first.token) {
+		const { value, prefix = "" } = first.token;
+		return prefix + toStringLiteral(value, database);
+	}
+	return render(pieces);
+}
+function defaultExpressionParser(tokens, $pos, database) {
+	const span = matchDefaultExpression(tokens)($pos.value);
+	const expression = tokens.slice($pos.value, $pos.value + span);
+	$pos.value += span;
+	return writeDefaultExpression(expression, database);
+}
+var isNextvalName = ({ kind, text, token }) => kind === "word" && (token ? token.quoted === "\"" && token.value === "nextval" : /^nextval$/i.test(text));
+var SEQUENCE_PREFIX = /^(?:e|u&)?$/i;
+var isSequenceArgument = (pieces) => {
+	const operand = unwrap(pieces);
+	const cast = lastCastOf(operand);
+	if (cast !== -1) return isTypeName(operand.slice(cast + 1)) && isSequenceArgument(operand.slice(0, cast));
+	const [name] = operand;
+	return operand.length === 1 && name.kind === "string" && SEQUENCE_PREFIX.test(name.token?.prefix ?? "");
+};
+var isNextvalDefault = (tokens) => {
+	const defaultExpression = matchDefaultExpression(tokens);
+	return (pos) => {
+		const pieces = unwrap(toPieces(tokens.slice(pos, pos + defaultExpression(pos))));
+		const [name, open] = pieces;
+		return !!name && isNextvalName(name) && open?.kind === "open" && closeOf(pieces, 1) === pieces.length - 1 && isSequenceArgument(pieces.slice(2, -1));
+	};
+};
+//#endregion
+export { defaultExpressionParser, isNextValueFor, isNextvalDefault, matchDefaultExpression, writeDefaultExpression };

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

@@ -0,0 +1,49 @@
+import { SortType } from "./index.js";
+import { isAscValue, isCommaToken, isDescValue, isLeftParentToken, isRightParentToken, isSemicolonToken, isStringToken } from "../helper.js";
+//#region ../schema-sql-parser/dist/parser/statement/index.columns.js
+function indexColumnsParser(tokens, $pos) {
+	const isString = isStringToken(tokens);
+	const isLeftParent = isLeftParentToken(tokens);
+	const isRightParent = isRightParentToken(tokens);
+	const isComma = isCommaToken(tokens);
+	const isSemicolon = isSemicolonToken(tokens);
+	const isDesc = isDescValue(tokens);
+	const isAsc = isAscValue(tokens);
+	const isToken = () => $pos.value < tokens.length && !isSemicolon($pos.value);
+	const isPrefixLength = (pos) => isString(pos + 1) && /^\d+$/.test(tokens[pos + 1].value) && isRightParent(pos + 2);
+	const indexColumns = [];
+	let indexColumn = {
+		name: "",
+		sort: SortType.asc
+	};
+	let expression = false;
+	$pos.value++;
+	while (isToken() && !isRightParent($pos.value)) {
+		if (isLeftParent($pos.value)) {
+			expression ||= !indexColumn.name || !isPrefixLength($pos.value);
+			let depth = 0;
+			while (isToken()) {
+				if (isLeftParent($pos.value)) depth++;
+				else if (isRightParent($pos.value) && --depth === 0) break;
+				$pos.value++;
+			}
+			if (!isToken()) break;
+		}
+		if (!indexColumn.name && isString($pos.value) && !isDesc($pos.value) && !isAsc($pos.value)) indexColumn.name = tokens[$pos.value].value;
+		if (isDesc($pos.value)) indexColumn.sort = SortType.desc;
+		if (isComma($pos.value)) {
+			indexColumns.push(indexColumn);
+			indexColumn = {
+				name: "",
+				sort: SortType.asc
+			};
+		}
+		$pos.value++;
+	}
+	if (isSemicolon($pos.value)) return [];
+	if (indexColumn.name !== "") indexColumns.push(indexColumn);
+	$pos.value++;
+	return expression ? [] : indexColumns;
+}
+//#endregion
+export { indexColumnsParser };

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

@@ -0,0 +1,25 @@
+//#region ../schema-sql-parser/dist/parser/statement/index.js
+var StatementType = {
+	createTable: "create.table",
+	createIndex: "create.index",
+	alterTableAddUnique: "alter.table.add.unique",
+	alterTableAddPrimaryKey: "alter.table.add.primaryKey",
+	alterTableAddForeignKey: "alter.table.add.foreignKey",
+	alterTableAddDefault: "alter.table.add.default",
+	alterTableAlterColumnAutoIncrement: "alter.table.alter.column.autoIncrement",
+	commentOnTable: "comment.on.table",
+	commentOnColumn: "comment.on.column"
+};
+var SortType = {
+	asc: "ASC",
+	desc: "DESC"
+};
+var ReferentialAction = {
+	noAction: "NO ACTION",
+	restrict: "RESTRICT",
+	cascade: "CASCADE",
+	setNull: "SET NULL",
+	setDefault: "SET DEFAULT"
+};
+//#endregion
+export { ReferentialAction, SortType, StatementType };

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

@@ -0,0 +1,241 @@
+//#region ../schema-sql-parser/dist/parser/tokenizer.js
+var TokenType = {
+	string: "string",
+	leftParent: "leftParent",
+	rightParent: "rightParent",
+	leftBracket: "leftBracket",
+	rightBracket: "rightBracket",
+	comma: "comma",
+	period: "period",
+	equal: "equal",
+	semicolon: "semicolon"
+};
+var pattern = {
+	doubleQuote: `"`,
+	dash: "-",
+	slash: "/",
+	asterisk: "*",
+	newLine: "\n",
+	singleQuote: `'`,
+	backtick: "`",
+	whiteSpace: /\s/,
+	string: /\S/,
+	breakString: /;|,|\(|\)|\[|\]|\.|=/,
+	literalEnd: /[\s,;)\]:|+]/,
+	equal: "=",
+	period: ".",
+	comma: ",",
+	semicolon: ";",
+	leftParent: "(",
+	rightParent: ")",
+	leftBracket: "[",
+	rightBracket: "]"
+};
+var SparkEscapes = {
+	"0": "\0",
+	b: "\b",
+	n: "\n",
+	r: "\r",
+	t: "	",
+	Z: "",
+	"%": "\\%",
+	_: "\\_"
+};
+var fromSparkCodePoint = (codePoint) => codePoint < 65536 ? String.fromCharCode(codePoint) : String.fromCharCode(Math.floor((codePoint - 65536) / 1024) + 55296, (codePoint - 65536) % 1024 + 56320);
+var readSparkEscape = (rest) => {
+	const unicode = /^(?:u([\da-fA-F]{4})|U([\da-fA-F]{8}))/.exec(rest);
+	if (unicode) {
+		const hex = unicode[1] ?? unicode[2];
+		return [fromSparkCodePoint(parseInt(hex, 16)), hex.length + 1];
+	}
+	const octal = /^[01][0-7]{2}/.exec(rest);
+	if (octal) return [String.fromCharCode(parseInt(octal[0], 8)), 3];
+	if (!rest) return ["\\", 0];
+	return [SparkEscapes[rest[0]] ?? rest[0], 1];
+};
+var PREFIX = String.raw`(?:[nebx]|u&|_[a-z\d]+)`;
+var OPERATOR = String.raw`[+\-*/%|<>!^~#@?]`;
+var OPENS_LITERAL = new RegExp(String.raw`(?:(?:^|${OPERATOR})${PREFIX}|${OPERATOR})$`, "i");
+var GLUED_LITERAL = new RegExp(String.raw`^(.*?)(${OPERATOR}*)(${PREFIX}?)$`, "is");
+var createEqual = (type) => (char) => type === char;
+var createTest = (regexp) => (char) => regexp.test(char);
+var match = {
+	doubleQuote: createEqual(pattern.doubleQuote),
+	dash: createEqual(pattern.dash),
+	slash: createEqual(pattern.slash),
+	asterisk: createEqual(pattern.asterisk),
+	newLine: createEqual(pattern.newLine),
+	singleQuote: createEqual(pattern.singleQuote),
+	backtick: createEqual(pattern.backtick),
+	whiteSpace: createTest(pattern.whiteSpace),
+	string: createTest(pattern.string),
+	breakString: createTest(pattern.breakString),
+	literalEnd: createTest(pattern.literalEnd),
+	equal: createEqual(pattern.equal),
+	period: createEqual(pattern.period),
+	comma: createEqual(pattern.comma),
+	semicolon: createEqual(pattern.semicolon),
+	leftParent: createEqual(pattern.leftParent),
+	rightParent: createEqual(pattern.rightParent),
+	leftBracket: createEqual(pattern.leftBracket),
+	rightBracket: createEqual(pattern.rightBracket)
+};
+function tokenizer(source, database) {
+	const tokens = [];
+	const spark = database === "Databricks";
+	let pos = 0;
+	const isChar = () => pos < source.length;
+	const isEscapedQuote = (value) => {
+		if (pos + 1 >= source.length || match.literalEnd(source[pos + 1])) return false;
+		let run = 0;
+		while (value[value.length - 1 - run] === "\\") run++;
+		return run % 2 === 1;
+	};
+	const readQuoted = (quote, prefix) => {
+		const close = quote === "[" ? "]" : quote;
+		let value = "";
+		pos++;
+		while (isChar()) {
+			const char = source[pos];
+			if (spark && quote === "'" && char === "\\") {
+				const [text, length] = readSparkEscape(source.slice(pos + 1, pos + 10));
+				value += text;
+				pos += length + 1;
+				continue;
+			}
+			if (char === close && quote === "'" && !spark && isEscapedQuote(value)) value = value.slice(0, -1);
+			else if (char === close) {
+				if (quote === "[" || source[pos + 1] !== close) break;
+				pos++;
+			}
+			value += char;
+			pos++;
+		}
+		tokens.push({
+			type: TokenType.string,
+			value,
+			quoted: quote,
+			...prefix ? { prefix } : {}
+		});
+		pos++;
+	};
+	while (isChar()) {
+		let char = source[pos];
+		if (match.whiteSpace(char)) {
+			let value = "";
+			while (isChar() && match.whiteSpace(char)) {
+				value += char;
+				char = source[++pos];
+			}
+			continue;
+		}
+		if (match.dash(char) && match.dash(source[pos + 1])) {
+			while (isChar() && !match.newLine(char)) char = source[++pos];
+			continue;
+		}
+		if (match.slash(char) && match.asterisk(source[pos + 1])) {
+			pos += 2;
+			char = source[pos];
+			while (isChar() && !(match.asterisk(char) && match.slash(source[pos + 1]))) char = source[++pos];
+			pos += 2;
+			continue;
+		}
+		if (match.leftParent(char)) {
+			tokens.push({
+				type: TokenType.leftParent,
+				value: char
+			});
+			pos++;
+			continue;
+		}
+		if (match.rightParent(char)) {
+			tokens.push({
+				type: TokenType.rightParent,
+				value: char
+			});
+			pos++;
+			continue;
+		}
+		if (match.comma(char)) {
+			tokens.push({
+				type: TokenType.comma,
+				value: char
+			});
+			pos++;
+			continue;
+		}
+		if (match.period(char)) {
+			tokens.push({
+				type: TokenType.period,
+				value: char
+			});
+			pos++;
+			continue;
+		}
+		if (match.equal(char)) {
+			tokens.push({
+				type: TokenType.equal,
+				value: char
+			});
+			pos++;
+			continue;
+		}
+		if (match.semicolon(char)) {
+			tokens.push({
+				type: TokenType.semicolon,
+				value: char
+			});
+			pos++;
+			continue;
+		}
+		if (match.rightBracket(char)) {
+			tokens.push({
+				type: TokenType.rightBracket,
+				value: char
+			});
+			pos++;
+			continue;
+		}
+		if (match.leftBracket(char)) {
+			readQuoted("[");
+			continue;
+		}
+		if (match.doubleQuote(char)) {
+			readQuoted("\"");
+			continue;
+		}
+		if (match.singleQuote(char)) {
+			readQuoted("'");
+			continue;
+		}
+		if (match.backtick(char)) {
+			readQuoted("`");
+			continue;
+		}
+		if (match.string(char)) {
+			let value = "";
+			while (isChar() && match.string(char) && !match.breakString(char) && !(match.dash(char) && match.dash(source[pos + 1])) && !(match.slash(char) && match.asterisk(source[pos + 1])) && !(match.singleQuote(char) && OPENS_LITERAL.test(value))) {
+				value += char;
+				char = source[++pos];
+			}
+			if (!match.singleQuote(char)) {
+				tokens.push({
+					type: TokenType.string,
+					value
+				});
+				continue;
+			}
+			const [, head, operator, prefix] = GLUED_LITERAL.exec(value);
+			for (const word of [head, operator]) if (word) tokens.push({
+				type: TokenType.string,
+				value: word
+			});
+			readQuoted("'", prefix);
+			continue;
+		}
+		pos++;
+	}
+	return tokens;
+}
+//#endregion
+export { TokenType, tokenizer };