befly 3.15.5 → 3.15.7

package/dist/befly.js

@@ -10105,17 +10105,18 @@ class SyncTable {
     }
     return "";
   }
-  static buildIndexSQL(tableName, indexName, fieldName, action) {
-    const tableQuoted = SyncTable.quoteIdentifier(tableName);
+  static buildIndexClause(indexName, fieldName, action) {
     const indexQuoted = SyncTable.quoteIdentifier(indexName);
-    const fieldQuoted = SyncTable.quoteIdentifier(fieldName);
-    const parts = [];
     if (action === "create") {
-      parts.push(`ADD INDEX ${indexQuoted} (${fieldQuoted})`);
-    } else {
-      parts.push(`DROP INDEX ${indexQuoted}`);
+      const fieldQuoted = SyncTable.quoteIdentifier(fieldName);
+      return `ADD INDEX ${indexQuoted} (${fieldQuoted})`;
     }
-    return `ALTER TABLE ${tableQuoted} ALGORITHM=INPLACE, LOCK=NONE, ${parts.join(", ")}`;
+    return `DROP INDEX ${indexQuoted}`;
+  }
+  static buildIndexSQL(tableName, indexName, fieldName, action) {
+    const tableQuoted = SyncTable.quoteIdentifier(tableName);
+    const clause = SyncTable.buildIndexClause(indexName, fieldName, action);
+    return `ALTER TABLE ${tableQuoted} ALGORITHM=INPLACE, LOCK=NONE, ${clause}`;
   }
   static getSystemColumnDef(fieldName) {
     let meta = null;
@@ -10165,23 +10166,49 @@ class SyncTable {
     const nullableSql = normalized.nullable ? " NULL" : " NOT NULL";
     return `${isAdd ? "ADD COLUMN" : "MODIFY COLUMN"} ${colQuoted} ${sqlType}${uniqueSql}${nullableSql}${defaultSql} COMMENT "${escapeComment(normalized.name)}"`;
   }
+  static stripAlgorithmAndLock(stmt) {
+    let sql = String(stmt);
+    sql = sql.replace(/\bALGORITHM\s*=\s*(INPLACE|INSTANT|COPY)\b\s*,?\s*/gi, "").replace(/\bLOCK\s*=\s*(NONE|SHARED|EXCLUSIVE)\b\s*,?\s*/gi, "");
+    sql = sql.replace(/,\s*,/g, ", ").replace(/,\s*$/g, "").replace(/\s{2,}/g, " ").trim();
+    return sql;
+  }
+  static buildDdlFallbackCandidates(stmt) {
+    const original = String(stmt);
+    const attempted = [];
+    if (/\bALGORITHM\s*=\s*INSTANT\b/i.test(original)) {
+      attempted.push({
+        stmt: original.replace(/\bALGORITHM\s*=\s*INSTANT\b/gi, "ALGORITHM=INPLACE"),
+        reason: "ALGORITHM=INSTANT \u2192 INPLACE"
+      });
+    }
+    const stripped = SyncTable.stripAlgorithmAndLock(original);
+    if (stripped !== original) {
+      attempted.push({ stmt: stripped, reason: "\u79FB\u9664 ALGORITHM/LOCK" });
+    }
+    const out = [];
+    for (const item of attempted) {
+      if (!item.stmt || item.stmt.trim() === "")
+        continue;
+      if (item.stmt === original)
+        continue;
+      if (out.some((x) => x.stmt === item.stmt))
+        continue;
+      out.push(item);
+    }
+    return out;
+  }
   static async executeDDLSafely(db, stmt) {
     try {
       await db.unsafe(stmt);
       return true;
     } catch (error) {
-      if (stmt.includes("ALGORITHM=INSTANT")) {
-        const inplaceSql = stmt.replace(/ALGORITHM=INSTANT/g, "ALGORITHM=INPLACE");
+      const candidates = SyncTable.buildDdlFallbackCandidates(stmt);
+      for (const candidate of candidates) {
         try {
-          await db.unsafe(inplaceSql);
+          await db.unsafe(candidate.stmt);
+          Logger.debug(`[DDL\u964D\u7EA7] ${candidate.reason}\uFF08\u5DF2\u6210\u529F\uFF09`);
           return true;
-        } catch {
-          let traditionSql = stmt;
-          traditionSql = traditionSql.replace(/\bALGORITHM\s*=\s*(INPLACE|INSTANT)\b\s*,?\s*/g, "").replace(/\bLOCK\s*=\s*(NONE|SHARED|EXCLUSIVE)\b\s*,?\s*/g, "");
-          traditionSql = traditionSql.replace(/,\s*,/g, ", ").replace(/,\s*$/g, "").replace(/\s{2,}/g, " ").trim();
-          await db.unsafe(traditionSql);
-          return true;
-        }
+        } catch {}
       }
       throw error;
     }
@@ -10335,13 +10362,17 @@ class SyncTable {
       return;
     const dropIndexActions = plan.indexActions.filter((a) => a.action === "drop");
     const createIndexActions = plan.indexActions.filter((a) => a.action === "create");
-    for (const act of dropIndexActions) {
-      const stmt = SyncTable.buildIndexSQL(tableName, act.indexName, act.fieldName, act.action);
+    if (dropIndexActions.length > 0) {
+      const dropClauses = [];
+      for (const act of dropIndexActions) {
+        dropClauses.push(SyncTable.buildIndexClause(act.indexName, act.fieldName, "drop"));
+      }
+      const tableQuoted = SyncTable.quoteIdentifier(tableName);
+      const stmt = `ALTER TABLE ${tableQuoted} ALGORITHM=INPLACE, LOCK=NONE, ${dropClauses.join(", ")}`;
       try {
-        await db.unsafe(stmt);
-        Logger.debug(`[\u7D22\u5F15\u53D8\u5316] \u5220\u9664\u7D22\u5F15 ${tableName}.${act.indexName} (${act.fieldName})`);
+        await SyncTable.executeDDLSafely(db, stmt);
       } catch (error) {
-        Logger.error({ err: error, table: tableName, index: act.indexName, field: act.fieldName, msg: "\u5220\u9664\u7D22\u5F15\u5931\u8D25" });
+        Logger.error({ err: error, table: tableName, msg: "\u6279\u91CF\u5220\u9664\u7D22\u5F15\u5931\u8D25" });
         throw error;
       }
     }
@@ -10356,13 +10387,17 @@ class SyncTable {
       const stmt = `ALTER TABLE ${tableQuoted} ALGORITHM=INSTANT, LOCK=NONE, ${plan.defaultClauses.join(", ")}`;
       await SyncTable.executeDDLSafely(db, stmt);
     }
-    for (const act of createIndexActions) {
-      const stmt = SyncTable.buildIndexSQL(tableName, act.indexName, act.fieldName, act.action);
+    if (createIndexActions.length > 0) {
+      const createClauses = [];
+      for (const act of createIndexActions) {
+        createClauses.push(SyncTable.buildIndexClause(act.indexName, act.fieldName, "create"));
+      }
+      const tableQuoted = SyncTable.quoteIdentifier(tableName);
+      const stmt = `ALTER TABLE ${tableQuoted} ALGORITHM=INPLACE, LOCK=NONE, ${createClauses.join(", ")}`;
       try {
-        await db.unsafe(stmt);
-        Logger.debug(`[\u7D22\u5F15\u53D8\u5316] \u65B0\u5EFA\u7D22\u5F15 ${tableName}.${act.indexName} (${act.fieldName})`);
+        await SyncTable.executeDDLSafely(db, stmt);
       } catch (error) {
-        Logger.error({ err: error, table: tableName, index: act.indexName, field: act.fieldName, msg: "\u521B\u5EFA\u7D22\u5F15\u5931\u8D25" });
+        Logger.error({ err: error, table: tableName, msg: "\u6279\u91CF\u521B\u5EFA\u7D22\u5F15\u5931\u8D25" });
         throw error;
       }
     }
@@ -10377,29 +10412,22 @@ class SyncTable {
             ${cols}
         ) ENGINE=${ENGINE} DEFAULT CHARSET=${CHARSET} COLLATE=${COLLATE}`;
     await db.unsafe(createSQL);
-    const indexTasks = [];
-    const existingIndexes = {};
+    Logger.debug(`[\u8868 ${tableName}] + \u521B\u5EFA\u8868\uFF08\u7CFB\u7EDF\u5B57\u6BB5 + \u4E1A\u52A1\u5B57\u6BB5\uFF09`);
+    const indexClauses = [];
     for (const sysField of systemIndexFields) {
       const indexName = `idx_${sysField}`;
-      if (existingIndexes[indexName]) {
-        continue;
-      }
-      const stmt = SyncTable.buildIndexSQL(tableName, indexName, sysField, "create");
-      indexTasks.push(db.unsafe(stmt));
+      indexClauses.push(SyncTable.buildIndexClause(indexName, sysField, "create"));
     }
     for (const [fieldKey, fieldDef] of Object.entries(fields)) {
       const dbFieldName = snakeCase(fieldKey);
       if (fieldDef.index === true && fieldDef.unique !== true) {
         const indexName = `idx_${dbFieldName}`;
-        if (existingIndexes[indexName]) {
-          continue;
-        }
-        const stmt = SyncTable.buildIndexSQL(tableName, indexName, dbFieldName, "create");
-        indexTasks.push(db.unsafe(stmt));
+        indexClauses.push(SyncTable.buildIndexClause(indexName, dbFieldName, "create"));
       }
     }
-    if (indexTasks.length > 0) {
-      await Promise.all(indexTasks);
+    if (indexClauses.length > 0) {
+      const stmt = `ALTER TABLE ${tableQuoted} ALGORITHM=INPLACE, LOCK=NONE, ${indexClauses.join(", ")}`;
+      await SyncTable.executeDDLSafely(db, stmt);
     }
   }
   static async modifyTable(db, dbName, tableName, fields) {
@@ -10410,15 +10438,17 @@ class SyncTable {
     const modifyClauses = [];
     const defaultClauses = [];
     const indexActions = [];
+    const addedBusinessFields = [];
+    const addedSystemFields = [];
+    const modifiedFields = [];
+    const defaultOnlyChangedFields = [];
+    const compatibleTypeChanges = [];
     for (const [fieldKey, fieldDef] of Object.entries(fields)) {
       const dbFieldName = snakeCase(fieldKey);
       if (existingColumns[dbFieldName]) {
         const comparison = SyncTable.compareFieldDefinition(existingColumns[dbFieldName], fieldDef);
         if (comparison.length > 0) {
-          for (const c of comparison) {
-            const changeLabel = SyncTable.CHANGE_TYPE_LABELS[c.type] || "\u672A\u77E5";
-            Logger.debug(`  ~ \u4FEE\u6539 ${dbFieldName} ${changeLabel}: ${c.current} -> ${c.expected}`);
-          }
+          modifiedFields.push(dbFieldName);
           const hasTypeChange = comparison.some((c) => c.type === "datatype");
           const onlyDefaultChanged = comparison.every((c) => c.type === "default");
           const defaultChanged = comparison.some((c) => c.type === "default");
@@ -10432,7 +10462,7 @@ class SyncTable {
 `);
               throw new Error(errorMsg);
             }
-            Logger.debug(`[\u517C\u5BB9\u7C7B\u578B\u53D8\u66F4] ${tableName}.${dbFieldName} ${currentType} -> ${expectedType}`);
+            compatibleTypeChanges.push(`${dbFieldName}: ${currentType} -> ${expectedType}`);
           }
           if (defaultChanged) {
             const actualDefault = SyncTable.resolveDefaultValue(fieldDef.default ?? null, fieldDef.type);
@@ -10445,6 +10475,7 @@ class SyncTable {
               if (fieldDef.type !== "text") {
                 const colQuoted = SyncTable.quoteIdentifier(dbFieldName);
                 defaultClauses.push(`ALTER COLUMN ${colQuoted} SET DEFAULT ${v}`);
+                defaultOnlyChangedFields.push(dbFieldName);
               }
             }
           }
@@ -10454,6 +10485,7 @@ class SyncTable {
           changed = true;
         }
       } else {
+        addedBusinessFields.push(dbFieldName);
         addClauses.push(SyncTable.generateDDLClause(fieldKey, fieldDef, true));
         changed = true;
       }
@@ -10463,7 +10495,7 @@ class SyncTable {
       if (!existingColumns[sysFieldName]) {
         const colDef = SyncTable.getSystemColumnDef(sysFieldName);
         if (colDef) {
-          Logger.debug(`  + \u65B0\u589E\u7CFB\u7EDF\u5B57\u6BB5 ${sysFieldName}`);
+          addedSystemFields.push(sysFieldName);
           addClauses.push(`ADD COLUMN ${colDef}`);
           changed = true;
         }
@@ -10497,6 +10529,49 @@ class SyncTable {
       indexActions
     };
     if (plan.changed) {
+      const summaryParts = [];
+      summaryParts.push(`[\u8868 ${tableName}] \u53D8\u66F4\u6C47\u603B`);
+      summaryParts.push(`\u65B0\u589E\u5B57\u6BB5=${addedBusinessFields.length}`);
+      summaryParts.push(`\u65B0\u589E\u7CFB\u7EDF\u5B57\u6BB5=${addedSystemFields.length}`);
+      summaryParts.push(`\u4FEE\u6539\u5B57\u6BB5=${modifiedFields.length}`);
+      summaryParts.push(`\u9ED8\u8BA4\u503C\u66F4\u65B0=${defaultOnlyChangedFields.length}`);
+      summaryParts.push(`\u7D22\u5F15\u53D8\u66F4=${indexActions.length}`);
+      const detailParts = [];
+      if (addedBusinessFields.length > 0) {
+        detailParts.push(`\u65B0\u589E\u5B57\u6BB5:${addedBusinessFields.join(",")}`);
+      }
+      if (addedSystemFields.length > 0) {
+        detailParts.push(`\u65B0\u589E\u7CFB\u7EDF\u5B57\u6BB5:${addedSystemFields.join(",")}`);
+      }
+      if (modifiedFields.length > 0) {
+        detailParts.push(`\u4FEE\u6539\u5B57\u6BB5:${modifiedFields.join(",")}`);
+      }
+      if (defaultOnlyChangedFields.length > 0) {
+        detailParts.push(`\u9ED8\u8BA4\u503C\u66F4\u65B0:${defaultOnlyChangedFields.join(",")}`);
+      }
+      if (compatibleTypeChanges.length > 0) {
+        detailParts.push(`\u517C\u5BB9\u7C7B\u578B\u53D8\u66F4:${compatibleTypeChanges.join(";")}`);
+      }
+      if (indexActions.length > 0) {
+        const createIndexSummaries = [];
+        const dropIndexSummaries = [];
+        for (const a of indexActions) {
+          const item = `${a.indexName}(${a.fieldName})`;
+          if (a.action === "create") {
+            createIndexSummaries.push(`+${item}`);
+          } else {
+            dropIndexSummaries.push(`-${item}`);
+          }
+        }
+        const indexPart = [];
+        if (dropIndexSummaries.length > 0)
+          indexPart.push(dropIndexSummaries.join(","));
+        if (createIndexSummaries.length > 0)
+          indexPart.push(createIndexSummaries.join(","));
+        detailParts.push(`\u7D22\u5F15:${indexPart.join(",")}`);
+      }
+      const msg = detailParts.length > 0 ? `${summaryParts.join("\uFF0C")}\uFF1B${detailParts.join("\uFF0C")}` : summaryParts.join("\uFF0C");
+      Logger.debug(msg);
       await SyncTable.applyTablePlan(db, tableName, plan);
     }
     return plan;