276 lines
10 KiB
JavaScript
276 lines
10 KiB
JavaScript
import buildColumnDefinition, { fieldRequiresNotNull, } from "./build-column-definition";
|
|
import createTable from "./create-table";
|
|
import getTableColumns, {} from "./get-table-columns";
|
|
import isVectorField from "./is-vector-field";
|
|
import mapDataType from "./map-data-types";
|
|
import MariaDBQuoteGen from "./mariadb-quote-gen";
|
|
import recreateTable from "./recreate-table";
|
|
import runSchemaQuery, { querySchemaRows } from "./run-schema-query";
|
|
import schemaCondition from "./schema-condition";
|
|
import { dropForeignKeysOnColumns } from "./sync-foreign-keys";
|
|
/**
|
|
* Compare live COLUMN_TYPE with schema-mapped type.
|
|
* Live types often include display widths (e.g. bigint(20) vs BIGINT).
|
|
*/
|
|
function columnTypesMatch(liveType, expectedType) {
|
|
const live = liveType.toLowerCase().replace(/\s+/g, "");
|
|
const expected = expectedType.toLowerCase().replace(/\s+/g, "");
|
|
if (live === expected)
|
|
return true;
|
|
// live may include display width: bigint(20) vs bigint
|
|
if (live.startsWith(`${expected}(`))
|
|
return true;
|
|
// expected may include length live omits in some versions
|
|
if (expected.startsWith(`${live}(`))
|
|
return true;
|
|
return false;
|
|
}
|
|
function vectorTypeDiverged(liveType, liveComment, field) {
|
|
const dimensions = field.vectorSize || 1536;
|
|
const expectedNative = `vector(${dimensions})`;
|
|
const live = liveType.toLowerCase().replace(/\s+/g, "");
|
|
if (live === expectedNative)
|
|
return false;
|
|
// Legacy LONGTEXT storage with vector_size comment
|
|
if (live.startsWith("longtext") || live.startsWith("text")) {
|
|
const match = liveComment.match(/vector_size\s*=\s*(\d+)/i);
|
|
if (match && Number(match[1]) === dimensions) {
|
|
// Still legacy storage — treat as diverged so we can migrate to VECTOR
|
|
return true;
|
|
}
|
|
return true;
|
|
}
|
|
return true;
|
|
}
|
|
function normalizeDefault(value) {
|
|
if (value == null)
|
|
return "";
|
|
let v = String(value).trim();
|
|
// Strip surrounding quotes MariaDB may include
|
|
if ((v.startsWith("'") && v.endsWith("'")) ||
|
|
(v.startsWith('"') && v.endsWith('"'))) {
|
|
v = v.slice(1, -1);
|
|
}
|
|
return v.toLowerCase().replace(/\s+/g, " ");
|
|
}
|
|
function expectedDefault(field) {
|
|
if (field.defaultValue !== undefined) {
|
|
return String(field.defaultValue);
|
|
}
|
|
if (field.defaultValueLiteral) {
|
|
return field.defaultValueLiteral;
|
|
}
|
|
return null;
|
|
}
|
|
function expectedOnUpdate(field) {
|
|
if (field.onUpdate)
|
|
return field.onUpdate;
|
|
if (field.onUpdateLiteral)
|
|
return field.onUpdateLiteral;
|
|
return null;
|
|
}
|
|
function defaultsMatch(liveDefault, expected) {
|
|
if (liveDefault === expected)
|
|
return true;
|
|
if (expected.includes("current_timestamp") &&
|
|
liveDefault.includes("current_timestamp")) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function columnAttributesDiverged(live, field) {
|
|
const wantsNotNull = fieldRequiresNotNull(field);
|
|
if (wantsNotNull && live.isNullable) {
|
|
return true;
|
|
}
|
|
if (!wantsNotNull && !live.isNullable && !field.primaryKey) {
|
|
return true;
|
|
}
|
|
const liveExtra = (live.extra || "").toLowerCase();
|
|
const wantsAi = Boolean(field.autoIncrement);
|
|
const hasAi = liveExtra.includes("auto_increment");
|
|
if (wantsAi !== hasAi) {
|
|
return true;
|
|
}
|
|
const wantsDefault = expectedDefault(field);
|
|
if (wantsDefault != null) {
|
|
const liveDefault = normalizeDefault(live.columnDefault);
|
|
const expected = normalizeDefault(wantsDefault);
|
|
if (!defaultsMatch(liveDefault, expected)) {
|
|
return true;
|
|
}
|
|
}
|
|
const wantsOnUpdate = expectedOnUpdate(field);
|
|
const hasOnUpdate = /on update/i.test(live.extra || "");
|
|
if (wantsOnUpdate && !hasOnUpdate) {
|
|
return true;
|
|
}
|
|
if (!wantsOnUpdate && hasOnUpdate) {
|
|
return true;
|
|
}
|
|
if (wantsOnUpdate && hasOnUpdate) {
|
|
const liveOnUpdate = normalizeDefault((live.extra.match(/on update\s+(.+)/i) || [])[1] || "");
|
|
const expectedOu = normalizeDefault(wantsOnUpdate);
|
|
if (liveOnUpdate && expectedOu && !defaultsMatch(liveOnUpdate, expectedOu)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
async function addColumn({ tableName, field, config, }) {
|
|
console.log(`Adding column: ${tableName}.${field.fieldName}`);
|
|
// omitUnique — unique constraints are applied by syncUniqueConstraints
|
|
const columnDef = buildColumnDefinition(field, { omitUnique: true }).trim();
|
|
await runSchemaQuery({
|
|
query: `ALTER TABLE ${MariaDBQuoteGen(tableName)} ADD COLUMN IF NOT EXISTS ${columnDef}`,
|
|
config,
|
|
});
|
|
}
|
|
async function modifyColumn({ tableName, field, config, }) {
|
|
console.log(`Modifying column: ${tableName}.${field.fieldName}`);
|
|
const columnDef = buildColumnDefinition(field, { omitUnique: true }).trim();
|
|
await runSchemaQuery({
|
|
query: `ALTER TABLE ${MariaDBQuoteGen(tableName)} MODIFY COLUMN ${columnDef}`,
|
|
config,
|
|
});
|
|
}
|
|
async function dropColumn({ tableName, fieldName, config, }) {
|
|
console.log(`Dropping column: ${tableName}.${fieldName}`);
|
|
await runSchemaQuery({
|
|
query: `ALTER TABLE ${MariaDBQuoteGen(tableName)} DROP COLUMN ${MariaDBQuoteGen(fieldName)}`,
|
|
config,
|
|
});
|
|
}
|
|
export default async function updateTable({ table, config, }) {
|
|
const existingColumns = await getTableColumns({
|
|
tableName: table.tableName,
|
|
config,
|
|
});
|
|
if (existingColumns.length === 0) {
|
|
await createTable({ table, config });
|
|
return;
|
|
}
|
|
const liveFieldsMap = new Map(existingColumns.map((col) => [col.name, col]));
|
|
const codeFieldsMap = new Map((table.fields || []).map((f) => [f.fieldName, f]));
|
|
const fieldsToAdd = [];
|
|
const fieldsToModify = [];
|
|
const fieldsToDrop = [];
|
|
let needsVectorRecreate = false;
|
|
for (const field of table.fields || []) {
|
|
if (!field.fieldName)
|
|
continue;
|
|
const liveField = liveFieldsMap.get(field.fieldName);
|
|
if (!liveField) {
|
|
fieldsToAdd.push(field);
|
|
}
|
|
else {
|
|
let typeDiverged = !columnTypesMatch(liveField.type, mapDataType(field));
|
|
if (isVectorField(field)) {
|
|
typeDiverged = vectorTypeDiverged(liveField.type, liveField.comment || "", field);
|
|
if (typeDiverged) {
|
|
needsVectorRecreate = true;
|
|
}
|
|
}
|
|
const attrsDiverged = !typeDiverged && columnAttributesDiverged(liveField, field);
|
|
if (typeDiverged || attrsDiverged) {
|
|
fieldsToModify.push(field);
|
|
}
|
|
}
|
|
}
|
|
// Vector dimension / storage type changes → full rebuild automatically
|
|
if (needsVectorRecreate) {
|
|
console.log(`Vector column change detected on \`${table.tableName}\`; recreating table`);
|
|
await recreateTable({ table, config });
|
|
return;
|
|
}
|
|
for (const col of existingColumns) {
|
|
if (!codeFieldsMap.has(col.name)) {
|
|
fieldsToDrop.push(col.name);
|
|
}
|
|
}
|
|
if (fieldsToAdd.length === 0 &&
|
|
fieldsToModify.length === 0 &&
|
|
fieldsToDrop.length === 0) {
|
|
return;
|
|
}
|
|
console.log(`Surgically updating table structure from database layout: ${table.tableName}`);
|
|
if (fieldsToDrop.length > 0) {
|
|
// Drop FKs that reference columns being removed
|
|
await dropForeignKeysOnColumns({
|
|
tableName: table.tableName,
|
|
columns: fieldsToDrop,
|
|
config,
|
|
});
|
|
const schemaCond = schemaCondition(config);
|
|
const pkRows = await querySchemaRows({
|
|
query: `SELECT COLUMN_NAME FROM information_schema.KEY_COLUMN_USAGE WHERE ${schemaCond.where} AND TABLE_NAME = ? AND CONSTRAINT_NAME = 'PRIMARY'`,
|
|
values: [...schemaCond.values, table.tableName],
|
|
config,
|
|
});
|
|
const pkColumnNames = pkRows.map((r) => r.COLUMN_NAME);
|
|
if (fieldsToDrop.some((f) => pkColumnNames.includes(f))) {
|
|
console.log(`Dropping primary key because a PK column is being dropped`);
|
|
await runSchemaQuery({
|
|
query: `ALTER TABLE ${MariaDBQuoteGen(table.tableName)} DROP PRIMARY KEY`,
|
|
config,
|
|
});
|
|
}
|
|
const indexRows = await querySchemaRows({
|
|
query: `SELECT INDEX_NAME, COLUMN_NAME FROM information_schema.STATISTICS WHERE ${schemaCond.where} AND TABLE_NAME = ? AND INDEX_NAME <> 'PRIMARY'`,
|
|
values: [...schemaCond.values, table.tableName],
|
|
config,
|
|
});
|
|
const indexesToDrop = new Set();
|
|
for (const row of indexRows) {
|
|
if (fieldsToDrop.includes(row.COLUMN_NAME)) {
|
|
indexesToDrop.add(row.INDEX_NAME);
|
|
}
|
|
}
|
|
for (const indexName of indexesToDrop) {
|
|
console.log(`Dropping index ${indexName} because it contains a dropped column`);
|
|
try {
|
|
await runSchemaQuery({
|
|
query: `DROP INDEX ${MariaDBQuoteGen(indexName)} ON ${MariaDBQuoteGen(table.tableName)}`,
|
|
config,
|
|
});
|
|
}
|
|
catch (err) {
|
|
if (String(err?.message || "").includes("needed in a foreign key constraint")) {
|
|
console.warn(`Skipping drop of index ${indexName}: required by a foreign key constraint`);
|
|
continue;
|
|
}
|
|
throw err;
|
|
}
|
|
}
|
|
}
|
|
// Drop FKs on columns being modified (MODIFY can fail with FK present)
|
|
if (fieldsToModify.length > 0) {
|
|
await dropForeignKeysOnColumns({
|
|
tableName: table.tableName,
|
|
columns: fieldsToModify
|
|
.map((f) => f.fieldName)
|
|
.filter((n) => Boolean(n)),
|
|
config,
|
|
});
|
|
}
|
|
for (const field of fieldsToAdd) {
|
|
await addColumn({ tableName: table.tableName, field, config });
|
|
}
|
|
for (const field of fieldsToModify) {
|
|
try {
|
|
await modifyColumn({ tableName: table.tableName, field, config });
|
|
}
|
|
catch (err) {
|
|
if (isVectorField(field)) {
|
|
console.warn(`[Vector Resize] Re-aligning dimension spaces natively via safe migration schema rebuild.`);
|
|
await recreateTable({ table, config });
|
|
return;
|
|
}
|
|
throw err;
|
|
}
|
|
}
|
|
for (const fieldName of fieldsToDrop) {
|
|
await dropColumn({ tableName: table.tableName, fieldName, config });
|
|
}
|
|
}
|