@dineug/erd-editor 4.2.0 → 5.0.0

package/dist/utils/schema-graphql-parser/parser.js

@@ -0,0 +1,490 @@
+import { isNotNil } from "es-toolkit";
+import { Kind, TokenKind, parse } from "graphql";
+//#region src/utils/schema-graphql-parser/parser.ts
+var DEFAULT_ROOT_TYPE_NAMES = [
+	"Query",
+	"Mutation",
+	"Subscription"
+];
+var INTROSPECTION_PREFIX = "__";
+var RELAY_TYPE_NAMES = ["PageInfo"];
+var RELAY_SUFFIXES = ["Connection", "Edge"];
+var HASURA_SUFFIXES = [
+	"_aggregate",
+	"_aggregate_fields",
+	"_mutation_response",
+	"_max_fields",
+	"_min_fields",
+	"_sum_fields",
+	"_avg_fields",
+	"_stddev_fields",
+	"_variance_fields",
+	"_bool_exp",
+	"_order_by",
+	"_insert_input",
+	"_set_input",
+	"_on_conflict",
+	"_constraint",
+	"_update_column",
+	"_select_column"
+];
+var FEDERATION_TYPE_NAMES = [
+	"_Service",
+	"_Entity",
+	"_Any",
+	"_FieldSet"
+];
+var DB_DIRECTIVE_PREFIX = "db_";
+var AUTO_INCREMENT_DEFAULTS = ["autoincrement", "autoincrement()"];
+var NAME_START = /[_A-Za-z]/;
+var NAME_PART = /[_0-9A-Za-z]/;
+function parseGraphQLModel(sdl) {
+	try {
+		return {
+			ok: true,
+			model: toModel(parseDocument(sdl))
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			message: toErrorMessage(error)
+		};
+	}
+}
+function parseDocument(sdl) {
+	try {
+		return parse(sdl);
+	} catch (error) {
+		const sanitized = sanitizePrismaDirectives(sdl);
+		if (sanitized === sdl) throw error;
+		try {
+			return parse(sanitized);
+		} catch {
+			throw error;
+		}
+	}
+}
+function toErrorMessage(error) {
+	const message = error instanceof Error ? error.message : String(error);
+	const location = error?.locations?.[0];
+	if (!location) return message;
+	const description = message.replace(/^Syntax Error:\s*/, "");
+	return `Syntax Error at line ${location.line}, column ${location.column}: ${description}`;
+}
+function toModel(ast) {
+	const enums = {};
+	const unions = {};
+	const customScalars = [];
+	const interfaceFields = /* @__PURE__ */ new Map();
+	const drafts = /* @__PURE__ */ new Map();
+	const declaredRootTypeNames = /* @__PURE__ */ new Set();
+	for (const definition of ast.definitions) switch (definition.kind) {
+		case Kind.OBJECT_TYPE_DEFINITION:
+		case Kind.OBJECT_TYPE_EXTENSION:
+			mergeObject(drafts, definition);
+			break;
+		case Kind.INTERFACE_TYPE_DEFINITION:
+		case Kind.INTERFACE_TYPE_EXTENSION: {
+			const name = definition.name.value;
+			const fields = interfaceFields.get(name) ?? [];
+			fields.push(...definition.fields ?? []);
+			interfaceFields.set(name, fields);
+			break;
+		}
+		case Kind.SCHEMA_DEFINITION:
+		case Kind.SCHEMA_EXTENSION:
+			for (const operationType of definition.operationTypes ?? []) declaredRootTypeNames.add(operationType.type.name.value);
+			break;
+		case Kind.ENUM_TYPE_DEFINITION:
+			enums[definition.name.value] = (definition.values ?? []).map((value) => value.name.value);
+			break;
+		case Kind.UNION_TYPE_DEFINITION:
+			unions[definition.name.value] = (definition.types ?? []).map((type) => type.name.value);
+			break;
+		case Kind.SCALAR_TYPE_DEFINITION: customScalars.push(definition.name.value);
+	}
+	const rootTypeNames = declaredRootTypeNames.size ? declaredRootTypeNames : new Set(DEFAULT_ROOT_TYPE_NAMES);
+	const tables = [];
+	const skipped = [];
+	const renamed = /* @__PURE__ */ new Map();
+	for (const draft of drafts.values()) {
+		if (isNoiseTypeName(draft.name, rootTypeNames)) {
+			skipped.push(draft.name);
+			continue;
+		}
+		const table = toTable(draft, interfaceFields);
+		if (!table.fields.length) {
+			skipped.push(draft.name);
+			continue;
+		}
+		if (table.name !== draft.name) renamed.set(draft.name, table.name);
+		tables.push(table);
+	}
+	applyTableRenames(tables, renamed);
+	return {
+		tables,
+		enums,
+		customScalars,
+		unions,
+		skipped
+	};
+}
+function applyTableRenames(tables, renamed) {
+	if (!renamed.size) return;
+	for (const table of tables) for (const field of table.fields) {
+		const name = renamed.get(field.typeRef.named);
+		if (name) field.typeRef.named = name;
+	}
+}
+function mergeObject(drafts, node) {
+	const name = node.name.value;
+	const interfaceNames = (node.interfaces ?? []).map((interfaceNode) => interfaceNode.name.value);
+	const draft = drafts.get(name);
+	if (draft) {
+		draft.fieldNodes.push(...node.fields ?? []);
+		draft.interfaceNames.push(...interfaceNames);
+		draft.directives.push(...node.directives ?? []);
+		if (!draft.comment) draft.comment = describe(node);
+		return;
+	}
+	drafts.set(name, {
+		name,
+		comment: describe(node),
+		interfaceNames,
+		fieldNodes: [...node.fields ?? []],
+		directives: [...node.directives ?? []]
+	});
+}
+function toTable(draft, interfaceFields) {
+	const ownFieldNodes = dedupeByName(draft.fieldNodes);
+	const seen = new Set(ownFieldNodes.map((node) => node.name.value));
+	const inheritedFieldNodes = [];
+	for (const interfaceName of draft.interfaceNames) for (const node of interfaceFields.get(interfaceName) ?? []) {
+		const name = node.name.value;
+		if (seen.has(name)) continue;
+		seen.add(name);
+		inheritedFieldNodes.push(node);
+	}
+	const table = {
+		name: draft.name,
+		comment: draft.comment,
+		fields: [...inheritedFieldNodes, ...ownFieldNodes].map(toField).filter(isNotNil),
+		indexes: []
+	};
+	for (const directive of draft.directives) applyTableDirective(table, directive);
+	return table;
+}
+function dedupeByName(nodes) {
+	const seen = /* @__PURE__ */ new Set();
+	return nodes.filter((node) => {
+		const name = node.name.value;
+		if (seen.has(name)) return false;
+		seen.add(name);
+		return true;
+	});
+}
+function toField(node) {
+	if (node.name.value.startsWith(INTROSPECTION_PREFIX)) return null;
+	const field = {
+		name: node.name.value,
+		comment: describe(node),
+		typeRef: toTypeRef(node.type),
+		primaryKey: false,
+		unique: false,
+		autoIncrement: false,
+		default: "",
+		dataType: "",
+		relationName: "",
+		relationFields: [],
+		relationReferences: [],
+		hasArguments: (node.arguments ?? []).length > 0
+	};
+	for (const directive of node.directives ?? []) applyFieldDirective(field, directive);
+	return field;
+}
+function toTypeRef(node) {
+	const nonNull = node.kind === Kind.NON_NULL_TYPE;
+	const unwrapped = nonNull ? node.type : node;
+	const isList = unwrapped.kind === Kind.LIST_TYPE;
+	const item = isList ? unwrapped.type : unwrapped;
+	const itemNonNull = isList && item.kind === Kind.NON_NULL_TYPE;
+	let named = item;
+	while (named.kind !== Kind.NAMED_TYPE) named = named.type;
+	return {
+		named: named.name.value,
+		nonNull,
+		isList,
+		itemNonNull
+	};
+}
+function applyFieldDirective(field, directive) {
+	const name = directive.name.value;
+	if (name.startsWith(DB_DIRECTIVE_PREFIX)) {
+		field.dataType = toDbDataType(name, directive);
+		return;
+	}
+	switch (name) {
+		case "id":
+		case "primaryKey":
+			field.primaryKey = true;
+			break;
+		case "unique":
+			field.unique = true;
+			break;
+		case "autoincrement":
+		case "autoIncrement":
+			field.autoIncrement = true;
+			break;
+		case "default": {
+			const value = argumentOf(directive, "value");
+			if (!value) break;
+			const text = valueToString(value);
+			if (AUTO_INCREMENT_DEFAULTS.includes(text.toLowerCase())) field.autoIncrement = true;
+			else field.default = text;
+			break;
+		}
+		case "map": {
+			const mapped = stringArgument(directive, "name") || stringArgument(directive, "value");
+			if (mapped) field.name = mapped;
+			break;
+		}
+		case "relation": {
+			const relationName = stringArgument(directive, "name") || stringArgument(directive, "value");
+			if (relationName) field.relationName = relationName;
+			const fields = argumentOf(directive, "fields");
+			if (fields) field.relationFields = valueToList(fields);
+			const references = argumentOf(directive, "references");
+			if (references) field.relationReferences = valueToList(references);
+			break;
+		}
+		case "column": {
+			const mapped = stringArgument(directive, "name");
+			if (mapped) field.name = mapped;
+			const dataType = stringArgument(directive, "dataType");
+			if (dataType) field.dataType = dataType;
+			const defaultValue = argumentOf(directive, "default");
+			if (defaultValue) field.default = valueToString(defaultValue);
+			const autoIncrement = booleanArgument(directive, "autoIncrement");
+			if (autoIncrement !== null) field.autoIncrement = autoIncrement;
+			const unique = booleanArgument(directive, "unique");
+			if (unique !== null) field.unique = unique;
+			const primaryKey = booleanArgument(directive, "primaryKey");
+			if (primaryKey !== null) field.primaryKey = primaryKey;
+			break;
+		}
+	}
+}
+function applyTableDirective(table, directive) {
+	switch (directive.name.value) {
+		case "map": {
+			const mapped = stringArgument(directive, "name") || stringArgument(directive, "value");
+			if (mapped) table.name = mapped;
+			break;
+		}
+		case "table": {
+			const name = stringArgument(directive, "name");
+			if (name) table.name = name;
+			const comment = argumentOf(directive, "comment");
+			if (comment) table.comment = valueToString(comment);
+			break;
+		}
+		case "index": {
+			const fields = argumentOf(directive, "fields");
+			const fieldNames = fields ? valueToList(fields) : [];
+			if (!fieldNames.length) break;
+			const index = {
+				name: stringArgument(directive, "name"),
+				unique: booleanArgument(directive, "unique") ?? false,
+				fieldNames
+			};
+			table.indexes.push(index);
+			break;
+		}
+	}
+}
+function toDbDataType(name, directive) {
+	const dataType = name.slice(3);
+	const args = directive.arguments ?? [];
+	if (!args.length) return dataType;
+	return `${dataType}(${args.map((argument) => valueToString(argument.value)).join(", ")})`;
+}
+function argumentOf(directive, name) {
+	const argument = (directive.arguments ?? []).find((argument) => argument.name.value === name);
+	return argument ? argument.value : null;
+}
+function stringArgument(directive, name) {
+	const value = argumentOf(directive, name);
+	return value ? valueToString(value) : "";
+}
+function booleanArgument(directive, name) {
+	const value = argumentOf(directive, name);
+	return value ? valueToString(value) === "true" : null;
+}
+function valueToString(node) {
+	switch (node.kind) {
+		case Kind.STRING:
+		case Kind.INT:
+		case Kind.FLOAT:
+		case Kind.ENUM: return node.value;
+		case Kind.BOOLEAN: return node.value ? "true" : "false";
+		case Kind.NULL: return "null";
+		case Kind.LIST: return node.values.map(valueToString).join(", ");
+		default: return "";
+	}
+}
+function valueToList(node) {
+	return (node.kind === Kind.LIST ? node.values : [node]).map(valueToString).filter((value) => value !== "");
+}
+function isNoiseTypeName(name, rootTypeNames) {
+	return rootTypeNames.has(name) || name.startsWith(INTROSPECTION_PREFIX) || FEDERATION_TYPE_NAMES.includes(name) || RELAY_TYPE_NAMES.includes(name) || RELAY_SUFFIXES.some((suffix) => hasNoiseSuffix(name, suffix)) || HASURA_SUFFIXES.some((suffix) => hasNoiseSuffix(name, suffix));
+}
+function hasNoiseSuffix(name, suffix) {
+	return name.length > suffix.length && name.endsWith(suffix);
+}
+function describe(node) {
+	if (node.description) return normalizeText(node.description.value);
+	if (!node.loc) return "";
+	const comments = [];
+	let line = node.loc.startToken.line - 1;
+	let token = node.loc.startToken.prev;
+	while (token && token.kind === TokenKind.COMMENT && token.line === line && (!token.prev || token.prev.line < token.line)) {
+		comments.unshift(token.value ?? "");
+		line -= 1;
+		token = token.prev;
+	}
+	return normalizeText(comments.join(" "));
+}
+function normalizeText(text) {
+	return text.replace(/\s+/g, " ").trim();
+}
+function sanitizePrismaDirectives(sdl) {
+	let out = "";
+	let index = 0;
+	let changed = false;
+	while (index < sdl.length) {
+		const char = sdl[index];
+		if (char === "#") {
+			const end = endOfLine(sdl, index);
+			out += sdl.slice(index, end);
+			index = end;
+			continue;
+		}
+		if (char === "\"") {
+			const end = endOfString(sdl, index);
+			out += sdl.slice(index, end);
+			index = end;
+			continue;
+		}
+		if (char !== "@" || !NAME_START.test(sdl[index + 1] ?? "")) {
+			out += char;
+			index += 1;
+			continue;
+		}
+		let end = endOfName(sdl, index + 1);
+		let name = sdl.slice(index + 1, end);
+		while (sdl[end] === "." && NAME_START.test(sdl[end + 1] ?? "")) {
+			const partEnd = endOfName(sdl, end + 1);
+			name += `_${sdl.slice(end + 1, partEnd)}`;
+			end = partEnd;
+			changed = true;
+		}
+		out += `@${name}`;
+		index = end;
+		const parenthesis = skipTrivia(sdl, index);
+		if (sdl[parenthesis] !== "(") continue;
+		out += sdl.slice(index, parenthesis + 1);
+		index = parenthesis + 1;
+		for (let argIndex = 0; index < sdl.length; argIndex++) {
+			const start = skipTrivia(sdl, index);
+			out += sdl.slice(index, start);
+			index = start;
+			if (sdl[index] === ")" || index >= sdl.length) break;
+			const colon = argumentNameEnd(sdl, index);
+			if (colon === -1) {
+				out += argIndex === 0 ? "value: " : `value${argIndex}: `;
+				changed = true;
+			} else {
+				out += sdl.slice(index, colon + 1);
+				index = colon + 1;
+			}
+			const valueEnd = Math.max(endOfValue(sdl, skipTrivia(sdl, index)), index + 1);
+			out += sdl.slice(index, valueEnd);
+			index = valueEnd;
+		}
+	}
+	return changed ? out : sdl;
+}
+function argumentNameEnd(sdl, from) {
+	if (!NAME_START.test(sdl[from] ?? "")) return -1;
+	const colon = skipTrivia(sdl, endOfName(sdl, from));
+	return sdl[colon] === ":" ? colon : -1;
+}
+function endOfName(sdl, from) {
+	let index = from;
+	while (index < sdl.length && NAME_PART.test(sdl[index])) index += 1;
+	return index;
+}
+function endOfLine(sdl, from) {
+	const end = sdl.indexOf("\n", from);
+	return end === -1 ? sdl.length : end;
+}
+function endOfString(sdl, from) {
+	if (sdl.startsWith("\"\"\"", from)) {
+		const end = sdl.indexOf("\"\"\"", from + 3);
+		return end === -1 ? sdl.length : end + 3;
+	}
+	let index = from + 1;
+	while (index < sdl.length) {
+		const char = sdl[index];
+		if (char === "\\") {
+			index += 2;
+			continue;
+		}
+		if (char === "\n") return index;
+		if (char === "\"") return index + 1;
+		index += 1;
+	}
+	return index;
+}
+function endOfValue(sdl, from) {
+	const brackets = [];
+	let index = from;
+	while (index < sdl.length) {
+		const char = sdl[index];
+		if (char === "\"") {
+			index = endOfString(sdl, index);
+			continue;
+		}
+		if (char === "[" || char === "{") {
+			brackets.push(char);
+			index += 1;
+			continue;
+		}
+		if (char === "]" || char === "}") {
+			if (!brackets.length) break;
+			brackets.pop();
+			index += 1;
+			if (!brackets.length) return index;
+			continue;
+		}
+		if (!brackets.length && (char === ")" || char === "," || char === "#")) break;
+		if (!brackets.length && /\s/.test(char)) break;
+		index += 1;
+	}
+	return index;
+}
+function skipTrivia(sdl, from) {
+	let index = from;
+	while (index < sdl.length) {
+		const char = sdl[index];
+		if (char === "#") {
+			index = endOfLine(sdl, index);
+			continue;
+		}
+		if (!/[\s,]/.test(char)) break;
+		index += 1;
+	}
+	return index;
+}
+//#endregion
+export { parseGraphQLModel };

package/dist/utils/schema-sql/Databricks.js

@@ -0,0 +1,158 @@
+import { uuid25 } from "../../uuid/dist/uuid25.js";
+import { query } from "../../erd-editor-schema/dist/query/index.js";
+import { ColumnOption, Database } from "../../constants/schema.js";
+import { bHas } from "../bit.js";
+import { autoName, primaryKeyColumns } from "../tableName.js";
+import { SchemaSQLHeader, SchemaSQLStatements } from "./options.js";
+import { commentToWrite, formatNames, formatReferentialActions, formatSize, formatSpace, ifNotExists, primaryKey, referentialActionSupport, selectIndexColumns, toForeignKeyPairs, toOrderName, toSchemaEntities, uniqueColumns } from "./utils.js";
+//#region src/utils/schema-sql/Databricks.ts
+var BRACKET = "`";
+function toSparkStringLiteral(value) {
+	return `'${value.replace(/[\\']/g, "\\$&")}'`;
+}
+var CONSTRAINT_OPTIONS = "NOT ENFORCED RELY";
+var ACTION_SUPPORT = referentialActionSupport(Database.Databricks);
+var IDENTITY_TYPES = /* @__PURE__ */ new Set(["BIGINT", "LONG"]);
+function takesIdentity(column) {
+	return bHas(column.options, ColumnOption.autoIncrement) && IDENTITY_TYPES.has(column.dataType.trim().toUpperCase());
+}
+function createSchema(state, tableIds, { statements, written, logicalNameAsComment } = {}) {
+	const fkNames = [];
+	const indexNames = [];
+	const stringBuffer = [""];
+	const { tables, relationships, indexes } = toSchemaEntities(state, tableIds);
+	tables.forEach((table) => {
+		written?.tables.push(table);
+		formatTable(state, {
+			table,
+			buffer: stringBuffer,
+			statements,
+			logicalNameAsComment
+		});
+		stringBuffer.push("");
+		formatUnique(state, {
+			table,
+			buffer: stringBuffer
+		});
+	});
+	relationships.forEach((relationship) => {
+		if (formatRelation(state, {
+			relationship,
+			buffer: stringBuffer,
+			fkNames,
+			statements
+		})) stringBuffer.push("");
+	});
+	indexes.forEach((index) => {
+		formatIndex(state, {
+			index,
+			buffer: stringBuffer,
+			indexNames
+		});
+		stringBuffer.push("");
+	});
+	return stringBuffer.join("\n");
+}
+function formatTable(state, { buffer, table, statements, logicalNameAsComment }) {
+	const { collections } = state;
+	const columns = query(collections).collection("tableColumnEntities").selectByIds(table.columnIds);
+	buffer.push(`CREATE TABLE${ifNotExists(statements)} ${BRACKET}${table.name}${BRACKET}`);
+	buffer.push(`(`);
+	const pk = primaryKey(columns);
+	const spaceSize = formatSize(columns);
+	columns.forEach((column, i) => {
+		formatColumn(state, {
+			column,
+			isComma: pk || columns.length !== i + 1,
+			spaceSize,
+			buffer,
+			logicalNameAsComment
+		});
+	});
+	if (pk) {
+		const pkColumns = primaryKeyColumns(columns);
+		buffer.push(`  CONSTRAINT ${BRACKET}PK_${table.name}${BRACKET} PRIMARY KEY (${formatNames(pkColumns, BRACKET)}) ${CONSTRAINT_OPTIONS}`);
+	}
+	buffer.push(`)`);
+	const comment = commentToWrite(table, logicalNameAsComment);
+	if (comment === "") buffer.push(`USING DELTA;`);
+	else {
+		buffer.push(`USING DELTA`);
+		buffer.push(`COMMENT ${toSparkStringLiteral(comment)};`);
+	}
+	const withoutIdentity = columns.filter((column) => bHas(column.options, ColumnOption.autoIncrement) && !takesIdentity(column));
+	if (withoutIdentity.length !== 0) {
+		buffer.push("");
+		withoutIdentity.forEach((column) => {
+			buffer.push(`-- Databricks takes IDENTITY only on BIGINT, so ${BRACKET}${table.name}${BRACKET}.${BRACKET}${column.name}${BRACKET} is written without it.`);
+		});
+	}
+}
+function formatUnique({ collections }, { buffer, table }) {
+	const columns = query(collections).collection("tableColumnEntities").selectByIds(table.columnIds);
+	uniqueColumns(columns).forEach((column) => {
+		buffer.push(`-- Databricks does not support UNIQUE constraints: ${BRACKET}${table.name}${BRACKET}.${BRACKET}${column.name}${BRACKET}`);
+		buffer.push("");
+	});
+}
+function formatColumn(_, { buffer, column, isComma, spaceSize, logicalNameAsComment }) {
+	const stringBuffer = [];
+	stringBuffer.push(`  ${BRACKET}${column.name}${BRACKET}` + formatSpace(spaceSize.name - column.name.length));
+	stringBuffer.push(`${column.dataType}` + formatSpace(spaceSize.dataType - column.dataType.length));
+	const notNull = bHas(column.options, ColumnOption.notNull) || bHas(column.options, ColumnOption.primaryKey);
+	stringBuffer.push(notNull ? "NOT NULL" : "        ");
+	if (takesIdentity(column)) stringBuffer.push(`GENERATED ALWAYS AS IDENTITY`);
+	else if (!bHas(column.options, ColumnOption.autoIncrement) && column.default.trim() !== "") stringBuffer.push(`DEFAULT ${column.default}`);
+	const comment = commentToWrite(column, logicalNameAsComment);
+	if (comment !== "") stringBuffer.push(`COMMENT ${toSparkStringLiteral(comment)}`);
+	buffer.push(stringBuffer.join(" ").trimEnd() + `${isComma ? "," : ""}`);
+}
+function formatRelation(state, { buffer, relationship, fkNames, statements }) {
+	const columns = toForeignKeyPairs(state, relationship);
+	if (!columns) return false;
+	const { startTable, endTable } = columns;
+	let fkName = `FK_${startTable.name}_TO_${endTable.name}`;
+	fkName = autoName(fkNames, "", fkName);
+	fkNames.push({
+		id: uuid25(),
+		name: fkName
+	});
+	const alterTable = `ALTER TABLE ${BRACKET}${endTable.name}${BRACKET}`;
+	if (statements === SchemaSQLStatements.ifNotExists) buffer.push(`${alterTable} DROP CONSTRAINT IF EXISTS ${BRACKET}${fkName}${BRACKET};`);
+	buffer.push(alterTable);
+	buffer.push(`  ADD CONSTRAINT ${BRACKET}${fkName}${BRACKET}`);
+	buffer.push(`    FOREIGN KEY (${formatNames(columns.end, BRACKET)})`);
+	buffer.push([
+		`    REFERENCES ${BRACKET}${startTable.name}${BRACKET} (${formatNames(columns.start, BRACKET)})`,
+		...formatReferentialActions(relationship, ACTION_SUPPORT),
+		`${CONSTRAINT_OPTIONS};`
+	].join(" "));
+	return true;
+}
+function formatIndex({ collections }, { buffer, index, indexNames }) {
+	const table = query(collections).collection("tableEntities").selectById(index.tableId);
+	if (!table) return;
+	const columnNames = selectIndexColumns(collections, table, index).map(({ indexColumn, column }) => ({ name: `${BRACKET}${column.name}${BRACKET} ${toOrderName(indexColumn.orderType)}` }));
+	if (columnNames.length === 0) return;
+	let indexName = index.name;
+	if (index.name.trim() === "") {
+		indexName = `IDX_${table.name}`;
+		indexName = autoName(indexNames, "", indexName);
+		indexNames.push({
+			id: uuid25(),
+			name: indexName
+		});
+	}
+	buffer.push(`-- Databricks has no secondary indexes. ${BRACKET}${indexName}${BRACKET} on ${BRACKET}${table.name}${BRACKET} (${formatNames(columnNames)})`);
+	buffer.push(`-- ALTER TABLE ${BRACKET}${table.name}${BRACKET} CLUSTER BY (${formatNames(selectIndexColumns(collections, table, index).map(({ column }) => column), BRACKET)});`);
+}
+function formatHeader(_, header, name) {
+	const schema = `${BRACKET}${name}${BRACKET}`;
+	const use = `USE SCHEMA ${schema};`;
+	return header === SchemaSQLHeader.createAndUse ? `CREATE SCHEMA IF NOT EXISTS ${schema};\n${use}` : use;
+}
+function formatDropBlock(_, { tables }) {
+	return tables.map(({ name }) => `DROP TABLE IF EXISTS ${BRACKET}${name}${BRACKET};`).join("\n");
+}
+//#endregion
+export { createSchema, formatDropBlock, formatHeader, formatIndex, formatTable, formatUnique };