imean-cassandra-orm 3.1.0 → 3.2.0

package/dist/mod.cjs

@@ -655,6 +655,20 @@ function shouldWrite(op, conf) {
   return Array.isArray(conf) && conf.includes(op);
 }
 
+// src/indexes.ts
+function createIndex(keyspace, tableName, fieldName, options) {
+  const indexName = `${tableName}_${String(fieldName).toLowerCase()}_sai_idx`;
+  const config = options !== true ? options : {
+    case_sensitive: false,
+    normalize: true,
+    ascii: true
+  };
+  const optionsString = JSON.stringify(config).replace(/"/g, "'");
+  return `CREATE INDEX IF NOT EXISTS ${indexName} ON ${keyspace}.${tableName} (${String(
+    fieldName
+  )}) USING 'sai' WITH OPTIONS = ${optionsString}`;
+}
+
 // src/helper.ts
 function dropTable(keyspace, tableName) {
   return `DROP TABLE IF EXISTS ${keyspace}.${tableName};`;
@@ -1194,28 +1208,10 @@ function buildSelectByIndexParams(query, fieldConfigs) {
 function createIndexes(schema) {
   const indexQueries = [];
   if (schema.indexes) {
-    Object.entries(schema.indexes).forEach(([fieldName, indexConfig]) => {
-      if (indexConfig) {
-        const indexName = `${fieldName.toLowerCase()}_sai_idx`;
-        let indexQuery = `CREATE INDEX ${indexName} ON ${schema.keyspace}.${schema.tableName} (${fieldName}) USING 'sai'`;
-        if (typeof indexConfig === "object" && Object.keys(indexConfig).length > 0) {
-          const options = [];
-          Object.entries(indexConfig).forEach(([key, value]) => {
-            if (value !== void 0 && value !== null) {
-              if (typeof value === "string") {
-                options.push(`'${key}': '${value}'`);
-              } else {
-                options.push(`'${key}': ${value}`);
-              }
-            }
-          });
-          if (options.length > 0) {
-            indexQuery += ` WITH OPTIONS = { ${options.join(", ")} }`;
-          }
-        }
-        indexQuery += ";";
-        indexQueries.push(indexQuery);
-      }
+    Object.entries(schema.indexes).forEach(([fieldName, options]) => {
+      indexQueries.push(
+        createIndex(schema.keyspace, schema.tableName, fieldName, options)
+      );
     });
   }
   return indexQueries;
@@ -1224,69 +1220,54 @@ function syncIndexes(schema, existingIndexes) {
   const operations = [];
   const existingIndexMap = /* @__PURE__ */ new Map();
   existingIndexes.forEach((index) => {
-    existingIndexMap.set(index.index_name, {
-      options: index.options
+    existingIndexMap.set(index.options.target, {
+      case_sensitive: Boolean(index.options.case_sensitive),
+      normalize: Boolean(index.options.normalize),
+      ascii: Boolean(index.options.ascii),
+      similarity_function: index.options.similarity_function ?? void 0
     });
   });
   const newIndexMap = /* @__PURE__ */ new Map();
   if (schema.indexes) {
-    Object.entries(schema.indexes).forEach(([fieldName, indexConfig]) => {
-      if (indexConfig) {
-        const indexName = `${fieldName.toLowerCase()}_sai_idx`;
-        let options = "";
-        if (typeof indexConfig === "object" && Object.keys(indexConfig).length > 0) {
-          const optionStrings = [];
-          Object.entries(indexConfig).forEach(([key, value]) => {
-            if (value !== void 0 && value !== null) {
-              if (typeof value === "string") {
-                optionStrings.push(`'${key}': '${value}'`);
-              } else {
-                optionStrings.push(`'${key}': ${value}`);
-              }
-            }
-          });
-          if (optionStrings.length > 0) {
-            options = `{ ${optionStrings.join(", ")} }`;
-          }
-        }
-        newIndexMap.set(indexName, { fieldName, config: indexConfig, options });
-      }
+    Object.entries(schema.indexes).forEach(([fieldName]) => {
+      const options = typeof schema.indexes?.[fieldName] === "boolean" ? {
+        case_sensitive: false,
+        normalize: true,
+        ascii: true
+      } : schema.indexes?.[fieldName];
+      newIndexMap.set(fieldName, options);
     });
   }
-  existingIndexMap.forEach((indexInfo, indexName) => {
+  existingIndexMap.forEach((_, indexName) => {
     if (!newIndexMap.has(indexName)) {
       operations.push(`DROP INDEX IF EXISTS ${schema.keyspace}.${indexName};`);
     }
   });
-  newIndexMap.forEach((indexInfo, indexName) => {
-    const existingIndex = existingIndexMap.get(indexName);
-    if (!existingIndex) {
-      let createQuery = `CREATE INDEX ${indexName} ON ${schema.keyspace}.${schema.tableName} (${indexInfo.fieldName}) USING 'sai'`;
-      if (indexInfo.options) {
-        createQuery += ` WITH OPTIONS = ${indexInfo.options}`;
-      }
-      createQuery += ";";
+  newIndexMap.forEach((_, fieldName) => {
+    const options = newIndexMap.get(fieldName);
+    const existingOptions = existingIndexMap.get(fieldName);
+    if (!existingOptions) {
+      let createQuery = createIndex(
+        schema.keyspace,
+        schema.tableName,
+        fieldName,
+        options
+      );
       operations.push(createQuery);
     } else {
-      const existingOptions = existingIndex.options;
-      const newOptions = indexInfo.options;
-      const normalizeOptions = (opts) => {
-        if (!opts) return "";
-        let normalized = opts.replace(/^"(.*)"$/, "$1").trim();
-        normalized = normalized.replace(/\s+/g, " ");
-        return normalized;
-      };
-      const normalizedExisting = normalizeOptions(existingOptions);
-      const normalizedNew = normalizeOptions(newOptions);
-      if (normalizedExisting !== normalizedNew) {
+      if (JSON.stringify(existingOptions) !== JSON.stringify(options)) {
         operations.push(
-          `DROP INDEX IF EXISTS ${schema.keyspace}.${indexName};`
+          dropIndex(
+            schema.keyspace,
+            `${schema.tableName}_${fieldName.toLowerCase()}_sai_idx`
+          )
+        );
+        let createQuery = createIndex(
+          schema.keyspace,
+          schema.tableName,
+          fieldName,
+          options
         );
-        let createQuery = `CREATE INDEX ${indexName} ON ${schema.keyspace}.${schema.tableName} (${indexInfo.fieldName}) USING 'sai'`;
-        if (indexInfo.options) {
-          createQuery += ` WITH OPTIONS = ${indexInfo.options}`;
-        }
-        createQuery += ";";
         operations.push(createQuery);
       }
     }
@@ -1364,6 +1345,691 @@ var createTableSchema = (config) => {
   return new TableSchema(config);
 };
 
+// src/model-synchronizer.ts
+var ModelSynchronizer = class {
+  constructor(model) {
+    this.model = model;
+  }
+  /**
+   * 检测表结构变更
+   */
+  async detectChanges() {
+    const existingTableInfo = await this.getExistingTableInfo();
+    const schemaTableInfo = await this.convertSchemaToTableInfo();
+    const addedFields = [];
+    const modifiedFields = [];
+    const deletedFields = [];
+    const addedIndexes = [];
+    const deletedIndexes = [];
+    const rebuiltIndexes = [];
+    for (const schemaColumn of schemaTableInfo.columns) {
+      const existingColumn = existingTableInfo.columns.find(
+        (c) => c.column_name.toLowerCase() === schemaColumn.column_name.toLowerCase()
+      );
+      if (!existingColumn) {
+        addedFields.push({
+          name: schemaColumn.column_name,
+          type: schemaColumn.type,
+          kind: schemaColumn.kind
+        });
+      } else {
+        if (schemaColumn.type.toLowerCase() !== existingColumn.type.toLowerCase()) {
+          modifiedFields.push({
+            name: schemaColumn.column_name,
+            oldType: existingColumn.type,
+            newType: schemaColumn.type
+          });
+        }
+        if (schemaColumn.kind !== existingColumn.kind) {
+          if (schemaColumn.column_name.toLowerCase() === existingColumn.column_name.toLowerCase()) {
+            const kindChangedField = {
+              name: existingColumn.column_name,
+              type: existingColumn.type,
+              kind: existingColumn.kind
+            };
+            if (!deletedFields.some(
+              (f) => f.name.toLowerCase() === kindChangedField.name.toLowerCase()
+            )) {
+              deletedFields.push(kindChangedField);
+            }
+            const kindChangedFieldNew = {
+              name: schemaColumn.column_name,
+              type: schemaColumn.type,
+              kind: schemaColumn.kind
+            };
+            if (!addedFields.some(
+              (f) => f.name.toLowerCase() === kindChangedFieldNew.name.toLowerCase()
+            )) {
+              addedFields.push(kindChangedFieldNew);
+            }
+          }
+        }
+      }
+    }
+    for (const existingColumn of existingTableInfo.columns) {
+      const schemaColumn = schemaTableInfo.columns.find(
+        (c) => c.column_name.toLowerCase() === existingColumn.column_name.toLowerCase()
+      );
+      if (!schemaColumn) {
+        if (!deletedFields.some(
+          (f) => f.name.toLowerCase() === existingColumn.column_name.toLowerCase()
+        )) {
+          deletedFields.push({
+            name: existingColumn.column_name,
+            type: existingColumn.type,
+            kind: existingColumn.kind
+          });
+        }
+      }
+    }
+    for (const schemaIndex of schemaTableInfo.indexes) {
+      const existingIndex = existingTableInfo.indexes.find(
+        (i) => i.index_name.toLowerCase() === schemaIndex.index_name.toLowerCase()
+      );
+      if (!existingIndex) {
+        addedIndexes.push({
+          name: schemaIndex.index_name,
+          options: schemaIndex.options
+        });
+      } else {
+        if (!this.areIndexOptionsEqual(existingIndex.options, schemaIndex.options)) {
+          rebuiltIndexes.push({
+            name: schemaIndex.index_name,
+            oldOptions: existingIndex.options,
+            newOptions: schemaIndex.options
+          });
+        }
+      }
+    }
+    for (const existingIndex of existingTableInfo.indexes) {
+      const schemaIndex = schemaTableInfo.indexes.find(
+        (i) => i.index_name.toLowerCase() === existingIndex.index_name.toLowerCase()
+      );
+      if (!schemaIndex) {
+        deletedIndexes.push({
+          name: existingIndex.index_name,
+          options: existingIndex.options
+        });
+      }
+    }
+    const hasChanges = addedFields.length > 0 || modifiedFields.length > 0 || deletedFields.length > 0 || addedIndexes.length > 0 || deletedIndexes.length > 0 || rebuiltIndexes.length > 0;
+    return {
+      addedFields,
+      modifiedFields,
+      deletedFields,
+      addedIndexes,
+      deletedIndexes,
+      rebuiltIndexes,
+      hasChanges
+    };
+  }
+  /**
+   * 打印变更信息（简洁列表格式）
+   */
+  printChangesTable(changes) {
+    if (!changes.hasChanges) {
+      return;
+    }
+    console.log(`
+\u{1F4CA} \u8868\u7ED3\u6784\u53D8\u5316
+`);
+    const stats = [];
+    const addedRegularFields = changes.addedFields.filter(
+      (f) => f.kind === "regular"
+    ).length;
+    const addedPartitionKeys = changes.addedFields.filter(
+      (f) => f.kind === "partition_key"
+    ).length;
+    const addedClusteringKeys = changes.addedFields.filter(
+      (f) => f.kind === "clustering_key"
+    ).length;
+    const deletedRegularFields = changes.deletedFields.filter(
+      (f) => f.kind === "regular"
+    ).length;
+    const deletedPartitionKeys = changes.deletedFields.filter(
+      (f) => f.kind === "partition_key"
+    ).length;
+    const deletedClusteringKeys = changes.deletedFields.filter(
+      (f) => f.kind === "clustering_key"
+    ).length;
+    if (addedRegularFields > 0) stats.push(`\u65B0\u589E${addedRegularFields}\u5B57\u6BB5`);
+    if (addedPartitionKeys > 0) stats.push(`\u65B0\u589E\u5206\u533A\u952E${addedPartitionKeys}`);
+    if (addedClusteringKeys > 0) stats.push(`\u65B0\u589E\u805A\u7C7B\u952E${addedClusteringKeys}`);
+    if (changes.modifiedFields.length > 0)
+      stats.push(`\u4FEE\u6539${changes.modifiedFields.length}\u5B57\u6BB5`);
+    if (deletedRegularFields > 0) stats.push(`\u5220\u9664${deletedRegularFields}\u5B57\u6BB5`);
+    if (deletedPartitionKeys > 0)
+      stats.push(`\u5220\u9664\u5206\u533A\u952E${deletedPartitionKeys}`);
+    if (deletedClusteringKeys > 0)
+      stats.push(`\u5220\u9664\u805A\u7C7B\u952E${deletedClusteringKeys}`);
+    if (changes.addedIndexes.length > 0)
+      stats.push(`\u65B0\u589E\u7D22\u5F15${changes.addedIndexes.length}`);
+    if (changes.rebuiltIndexes.length > 0)
+      stats.push(`\u91CD\u5EFA\u7D22\u5F15${changes.rebuiltIndexes.length}`);
+    if (changes.deletedIndexes.length > 0)
+      stats.push(`\u5220\u9664\u7D22\u5F15${changes.deletedIndexes.length}`);
+    if (stats.length > 0) {
+      console.log(`    \u7EDF\u8BA1\uFF08${stats.join("\uFF0C")}\uFF09`);
+    }
+    changes.addedFields.forEach((field) => {
+      console.log(`    \u{1F7E2} \u65B0\u589E\u5B57\u6BB5 ${field.name} = ${field.type}`);
+    });
+    changes.modifiedFields.forEach((field) => {
+      console.log(
+        `    \u{1F7E1} \u4FEE\u6539\u5B57\u6BB5 ${field.name} = ${field.oldType} \u2192 ${field.newType}`
+      );
+    });
+    changes.deletedFields.forEach((field) => {
+      console.log(`    \u{1F534} \u5220\u9664\u5B57\u6BB5 ${field.name} = ${field.type}`);
+    });
+    changes.addedIndexes.forEach((index) => {
+      const optionsStr = this.formatIndexOptions(index.options);
+      console.log(
+        `    \u{1F7E2} \u65B0\u589E\u7D22\u5F15 ${index.name}${optionsStr ? ` (${optionsStr})` : ""}`
+      );
+    });
+    changes.rebuiltIndexes.forEach((index) => {
+      console.log(`    \u{1F7E1} \u91CD\u5EFA\u7D22\u5F15 ${index.name}`);
+    });
+    changes.deletedIndexes.forEach((index) => {
+      console.log(`    \u{1F534} \u5220\u9664\u7D22\u5F15 ${index.name}`);
+    });
+  }
+  /**
+   * 打印表结构信息（简洁格式）
+   */
+  printTableStructure(schema) {
+    console.log(`
+\u{1F4CA} \u8868\u7ED3\u6784:
+`);
+    Object.entries(schema.fields.shape).forEach(([fieldName, fieldSchema]) => {
+      const type = convertZodToCassandraType(fieldSchema);
+      const kind = schema.partitionKeyFields.includes(fieldName) ? "partition_key" : schema.clusteringKeyFields.some((ck) => ck.field === fieldName) ? "clustering_key" : "regular";
+      const kindLabel = kind === "partition_key" ? " [\u5206\u533A\u952E]" : kind === "clustering_key" ? " [\u805A\u7C7B\u952E]" : "";
+      console.log(`    \u2022 ${fieldName} = ${type}${kindLabel}`);
+    });
+    if (schema.indexes && Object.keys(schema.indexes).length > 0) {
+      console.log(`
+\u{1F4C7} \u7D22\u5F15:`);
+      Object.entries(schema.indexes).forEach(([fieldName, options]) => {
+        const indexName = `${schema.tableName}_${fieldName}_sai_idx`.toLowerCase();
+        const optionsStr = this.formatIndexOptions(
+          typeof options === "boolean" ? { case_sensitive: false, normalize: true, ascii: true } : options
+        );
+        console.log(
+          `    \u2022 ${indexName} (${fieldName})${optionsStr ? ` - ${optionsStr}` : ""}`
+        );
+      });
+    }
+  }
+  /**
+   * 同步表结构（根据检测结果执行相应的变更）
+   */
+  async sync(forceRecreate = false) {
+    const { schema, client } = this.model;
+    const tableName = `${schema.keyspace}.${schema.tableName}`;
+    console.log(`
+\u{1F504} \u5F00\u59CB\u540C\u6B65\u8868\u7ED3\u6784: ${tableName}`);
+    console.log("=".repeat(56));
+    await client.execute(
+      queryHelper.ensureKeyspace(schema.keyspace, schema.keyspaceConfig)
+    );
+    console.log(`\u2705 Keyspace ${schema.keyspace} \u5DF2\u786E\u4FDD\u5B58\u5728`);
+    const changes = await this.detectChanges();
+    const tableExists = await this.checkTableExists();
+    if (tableExists) {
+      this.printChangesTable(changes);
+    }
+    if (!tableExists) {
+      console.log(`
+\u{1F4CB} \u8868\u4E0D\u5B58\u5728\uFF0C\u5C06\u521B\u5EFA\u65B0\u8868`);
+      this.printTableStructure(schema);
+      try {
+        console.log(`
+\u{1F680} \u521B\u5EFA\u8868 ${tableName}`);
+        await client.execute(queryHelper.createTable(schema));
+        console.log(`\u2705 \u521B\u5EFA\u8868 ${tableName} \u6210\u529F`);
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.error(`\u274C \u521B\u5EFA\u8868 ${tableName} \u5931\u8D25: ${errorMessage}`);
+        throw error;
+      }
+      if (schema.indexes && Object.keys(schema.indexes).length > 0) {
+        const indexQueries = queryHelper.createIndexes(schema);
+        const indexFields = Object.keys(schema.indexes);
+        for (let i = 0; i < indexQueries.length; i++) {
+          const indexQuery = indexQueries[i];
+          const fieldName = indexFields[i];
+          const indexName = `${schema.tableName}_${fieldName}_sai_idx`.toLowerCase();
+          try {
+            console.log(`\u{1F680} \u6DFB\u52A0\u7D22\u5F15 ${indexName}`);
+            await client.execute(indexQuery);
+            console.log(`\u2705 \u6DFB\u52A0\u7D22\u5F15 ${indexName} \u6210\u529F`);
+          } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.error(`\u274C \u6DFB\u52A0\u7D22\u5F15 ${indexName} \u5931\u8D25: ${errorMessage}`);
+            throw error;
+          }
+        }
+      }
+      console.log(`
+\u2705 \u8868\u7ED3\u6784\u540C\u6B65\u5B8C\u6210: ${tableName}
+`);
+      return;
+    }
+    if (!changes.hasChanges) {
+      console.log(`
+\u2705 \u8868\u7ED3\u6784\u5DF2\u662F\u6700\u65B0\u72B6\u6001\uFF0C\u65E0\u9700\u53D8\u66F4
+`);
+      return;
+    }
+    const needsRecreate = this.shouldRecreateTable(changes, forceRecreate);
+    if (needsRecreate && !forceRecreate) {
+      const reasons = [];
+      const primaryKeyChanges = [
+        ...changes.deletedFields.filter(
+          (f) => f.kind === "partition_key" || f.kind === "clustering_key"
+        ),
+        ...changes.addedFields.filter(
+          (f) => f.kind === "partition_key" || f.kind === "clustering_key"
+        )
+      ];
+      if (primaryKeyChanges.length > 0) {
+        const partitionKeyChanges = primaryKeyChanges.filter(
+          (f) => f.kind === "partition_key"
+        );
+        const clusteringKeyChanges = primaryKeyChanges.filter(
+          (f) => f.kind === "clustering_key"
+        );
+        if (partitionKeyChanges.length > 0) {
+          reasons.push(`\u4E3B\u952E\u53D8\u66F4: \u5206\u533A\u952E\u6570\u91CF\u4E0D\u4E00\u81F4`);
+        } else if (clusteringKeyChanges.length > 0) {
+          reasons.push(`\u4E3B\u952E\u53D8\u66F4: \u805A\u7C7B\u952E\u914D\u7F6E\u4E0D\u4E00\u81F4`);
+        } else {
+          const deletedKeys = primaryKeyChanges.map(
+            (f) => `${f.name} (${f.kind === "partition_key" ? "\u5206\u533A\u952E" : "\u805A\u7C7B\u952E"})`
+          );
+          reasons.push(`\u4E3B\u952E\u53D8\u66F4: ${deletedKeys.join(", ")}`);
+        }
+      }
+      const incompatibleTypeChanges = changes.modifiedFields.filter(
+        (f) => !this.isTypeCompatible(f.oldType, f.newType)
+      );
+      if (incompatibleTypeChanges.length > 0) {
+        const typeChangeDetails = incompatibleTypeChanges.map(
+          (f) => `${f.name} (${f.oldType} \u2192 ${f.newType})`
+        );
+        reasons.push(`\u5B57\u6BB5\u7C7B\u578B\u53D8\u66F4: ${typeChangeDetails.map((d) => `\u5B57\u6BB5\u7C7B\u578B\u4E0D\u517C\u5BB9: ${d.split("(")[0]}`).join(", ")}`);
+      }
+      const errorMessage = `\u8868 ${tableName} \u7ED3\u6784\u5B58\u5728\u4E0D\u53EF\u53D8\u66F4\u7684\u4FEE\u6539\uFF0C\u9700\u8981\u4F7F\u7528 forceRecreate=true \u6765\u91CD\u5EFA\u8868\u3002
+\u4E0D\u53EF\u53D8\u66F4\u7684\u4FEE\u6539\u5305\u62EC\uFF1A
+${reasons.map((r) => `  - ${r}`).join("\n")}
+\u5176\u4ED6\u53D8\u66F4\uFF1A
+  - \u65B0\u589E\u5B57\u6BB5: ${changes.addedFields.filter((f) => f.kind === "regular").map((f) => f.name).join(", ") || "\u65E0"}
+  - \u5220\u9664\u5B57\u6BB5: ${changes.deletedFields.filter((f) => f.kind === "regular").map((f) => f.name).join(", ") || "\u65E0"}
+  - \u65B0\u589E\u7D22\u5F15: ${changes.addedIndexes.map((i) => i.name).join(", ") || "\u65E0"}
+  - \u5220\u9664\u7D22\u5F15: ${changes.deletedIndexes.map((i) => i.name).join(", ") || "\u65E0"}
+  - \u91CD\u5EFA\u7D22\u5F15: ${changes.rebuiltIndexes.map((i) => i.name).join(", ") || "\u65E0"}`;
+      console.error(`
+\u274C ${errorMessage}
+`);
+      throw new Error(errorMessage);
+    }
+    if (needsRecreate) {
+      console.log(`
+\u{1F4CB} \u8868\u5DF2\u7ECF\u5B58\u5728\uFF0C\u9700\u8981\u91CD\u5EFA\u8868`);
+      try {
+        console.log(`
+\u{1F680} \u5220\u9664\u8868 ${tableName}`);
+        await client.execute(
+          queryHelper.dropTable(schema.keyspace, schema.tableName)
+        );
+        console.log(`\u2705 \u5220\u9664\u8868 ${tableName} \u6210\u529F`);
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.error(`\u274C \u5220\u9664\u8868 ${tableName} \u5931\u8D25: ${errorMessage}`);
+        throw error;
+      }
+      try {
+        console.log(`\u{1F680} \u521B\u5EFA\u8868 ${tableName}`);
+        await client.execute(queryHelper.createTable(schema));
+        console.log(`\u2705 \u521B\u5EFA\u8868 ${tableName} \u6210\u529F`);
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.error(`\u274C \u521B\u5EFA\u8868 ${tableName} \u5931\u8D25: ${errorMessage}`);
+        throw error;
+      }
+      if (schema.indexes && Object.keys(schema.indexes).length > 0) {
+        const indexQueries = queryHelper.createIndexes(schema);
+        const indexFields = Object.keys(schema.indexes);
+        for (let i = 0; i < indexQueries.length; i++) {
+          const indexQuery = indexQueries[i];
+          const fieldName = indexFields[i];
+          const indexName = `${schema.tableName}_${fieldName}_sai_idx`.toLowerCase();
+          try {
+            console.log(`\u{1F680} \u6DFB\u52A0\u7D22\u5F15 ${indexName}`);
+            await client.execute(indexQuery);
+            console.log(`\u2705 \u6DFB\u52A0\u7D22\u5F15 ${indexName} \u6210\u529F`);
+          } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.error(`\u274C \u6DFB\u52A0\u7D22\u5F15 ${indexName} \u5931\u8D25: ${errorMessage}`);
+            throw error;
+          }
+        }
+      }
+      console.log(`\u2705 \u4FEE\u6539\u8868 ${tableName} \u6210\u529F`);
+      console.log(`
+\u2705 \u8868\u7ED3\u6784\u540C\u6B65\u5B8C\u6210: ${tableName}
+`);
+      return;
+    }
+    console.log(`
+\u{1F4CB} \u8868\u5DF2\u7ECF\u5B58\u5728\uFF0C\u5F00\u59CB\u66F4\u65B0`);
+    if (changes.addedFields.length > 0) {
+      const regularFields = changes.addedFields.filter(
+        (f) => f.kind === "regular"
+      );
+      if (regularFields.length > 0) {
+        try {
+          regularFields.forEach((f) => {
+            console.log(`\u{1F680} \u6DFB\u52A0\u5B57\u6BB5 ${f.name}`);
+          });
+          await client.execute(
+            queryHelper.addColumns(
+              schema,
+              regularFields.map((f) => f.name)
+            )
+          );
+          regularFields.forEach((f) => {
+            console.log(`\u2705 \u6DFB\u52A0\u5B57\u6BB5 ${f.name} \u6210\u529F`);
+          });
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          console.error(`\u274C \u6DFB\u52A0\u5B57\u6BB5\u5931\u8D25: ${errorMessage}`);
+          throw error;
+        }
+      }
+    }
+    if (changes.deletedFields.length > 0) {
+      const regularFields = changes.deletedFields.filter(
+        (f) => f.kind === "regular"
+      );
+      if (regularFields.length > 0) {
+        try {
+          regularFields.forEach((f) => {
+            console.log(`\u{1F680} \u5220\u9664\u5B57\u6BB5 ${f.name}`);
+          });
+          await client.execute(
+            queryHelper.dropColumns(
+              schema,
+              regularFields.map((f) => f.name)
+            )
+          );
+          regularFields.forEach((f) => {
+            console.log(`\u2705 \u5220\u9664\u5B57\u6BB5 ${f.name} \u6210\u529F`);
+          });
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          console.error(`\u274C \u5220\u9664\u5B57\u6BB5\u5931\u8D25: ${errorMessage}`);
+          throw error;
+        }
+      }
+    }
+    if (changes.modifiedFields.length > 0) {
+      const compatibleChanges = changes.modifiedFields.filter(
+        (f) => this.isTypeCompatible(f.oldType, f.newType)
+      );
+      const incompatibleChanges = changes.modifiedFields.filter(
+        (f) => !this.isTypeCompatible(f.oldType, f.newType)
+      );
+      if (incompatibleChanges.length > 0) {
+        incompatibleChanges.forEach((f) => {
+          console.log(`\u{1F680} \u4FEE\u6539\u5B57\u6BB5 ${f.name} (${f.oldType} \u2192 ${f.newType})`);
+        });
+      }
+      if (compatibleChanges.length > 0) {
+        compatibleChanges.forEach((f) => {
+          console.log(`\u{1F680} \u4FEE\u6539\u5B57\u6BB5 ${f.name} (${f.oldType} \u2192 ${f.newType})`);
+        });
+      }
+    }
+    if (changes.deletedIndexes.length > 0) {
+      for (const deletedIndex of changes.deletedIndexes) {
+        try {
+          console.log(`\u{1F680} \u5220\u9664\u7D22\u5F15 ${deletedIndex.name}`);
+          await client.execute(
+            queryHelper.dropIndex(schema.keyspace, deletedIndex.name)
+          );
+          console.log(`\u2705 \u5220\u9664\u7D22\u5F15 ${deletedIndex.name} \u6210\u529F`);
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          console.error(
+            `\u274C \u5220\u9664\u7D22\u5F15 ${deletedIndex.name} \u5931\u8D25: ${errorMessage}`
+          );
+          throw error;
+        }
+      }
+    }
+    if (changes.rebuiltIndexes.length > 0) {
+      for (const rebuiltIndex of changes.rebuiltIndexes) {
+        try {
+          console.log(`\u{1F680} \u91CD\u5EFA\u7D22\u5F15 ${rebuiltIndex.name}`);
+          await client.execute(
+            queryHelper.dropIndex(schema.keyspace, rebuiltIndex.name)
+          );
+          console.log(`\u2705 \u5220\u9664\u65E7\u7D22\u5F15 ${rebuiltIndex.name} \u6210\u529F`);
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          console.error(
+            `\u274C \u5220\u9664\u65E7\u7D22\u5F15 ${rebuiltIndex.name} \u5931\u8D25: ${errorMessage}`
+          );
+          throw error;
+        }
+      }
+    }
+    if (changes.addedIndexes.length > 0 || changes.rebuiltIndexes.length > 0) {
+      if (schema.indexes) {
+        const indexQueries = queryHelper.createIndexes(schema);
+        const indexFields = Object.keys(schema.indexes);
+        for (let i = 0; i < indexQueries.length; i++) {
+          const indexQuery = indexQueries[i];
+          const fieldName = indexFields[i];
+          const indexName = `${schema.tableName}_${fieldName}_sai_idx`.toLowerCase();
+          try {
+            console.log(`\u{1F680} \u6DFB\u52A0\u7D22\u5F15 ${indexName}`);
+            await client.execute(indexQuery);
+            console.log(`\u2705 \u6DFB\u52A0\u7D22\u5F15 ${indexName} \u6210\u529F`);
+          } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.error(`\u274C \u6DFB\u52A0\u7D22\u5F15 ${indexName} \u5931\u8D25: ${errorMessage}`);
+            throw error;
+          }
+        }
+      }
+    }
+    console.log(`\u2705 \u4FEE\u6539\u8868 ${tableName} \u6210\u529F`);
+    console.log(`
+\u2705 \u8868\u7ED3\u6784\u540C\u6B65\u5B8C\u6210: ${tableName}
+`);
+  }
+  /**
+   * 判断是否需要重建表
+   */
+  shouldRecreateTable(changes, forceRecreate) {
+    if (forceRecreate && changes.hasChanges) {
+      return true;
+    }
+    const hasPrimaryKeyChanges = changes.deletedFields.some(
+      (f) => f.kind === "partition_key" || f.kind === "clustering_key"
+    ) || changes.addedFields.some(
+      (f) => f.kind === "partition_key" || f.kind === "clustering_key"
+    );
+    if (hasPrimaryKeyChanges) {
+      return true;
+    }
+    const hasIncompatibleTypeChanges = changes.modifiedFields.some(
+      (f) => !this.isTypeCompatible(f.oldType, f.newType)
+    );
+    if (hasIncompatibleTypeChanges) {
+      return true;
+    }
+    return false;
+  }
+  /**
+   * 检查类型是否兼容
+   * 基于 Cassandra 5.0 的类型兼容性规则
+   */
+  isTypeCompatible(existingType, newType) {
+    const normalizeType = (type) => type.toLowerCase().trim();
+    const existing = normalizeType(existingType);
+    const newT = normalizeType(newType);
+    if (existing === newT) {
+      return true;
+    }
+    const compatibleChanges = {
+      // 文本类型之间的兼容性
+      text: ["varchar", "ascii"],
+      varchar: ["text", "ascii"],
+      ascii: ["text", "varchar"],
+      // 整数类型之间的兼容性
+      int: ["bigint", "smallint", "tinyint", "varint"],
+      bigint: ["int", "smallint", "tinyint", "varint"],
+      smallint: ["int", "bigint", "tinyint", "varint"],
+      tinyint: ["int", "bigint", "smallint", "varint"],
+      varint: ["int", "bigint", "smallint", "tinyint"],
+      // 浮点数类型之间的兼容性
+      float: ["double"],
+      double: ["float"],
+      // 时间类型之间的兼容性
+      timestamp: ["timeuuid"],
+      // 某些场景下可以转换
+      // UUID 类型
+      uuid: ["timeuuid"],
+      // 某些场景下可以转换
+      timeuuid: ["uuid"]
+      // 某些场景下可以转换
+    };
+    if (compatibleChanges[existing] && compatibleChanges[existing].includes(newT)) {
+      return true;
+    }
+    if (compatibleChanges[newT] && compatibleChanges[newT].includes(existing)) {
+      return true;
+    }
+    const existingBase = existing.split("<")[0];
+    const newBase = newT.split("<")[0];
+    if (existingBase === newBase && (existingBase === "list" || existingBase === "set" || existingBase === "map")) {
+      return false;
+    }
+    return false;
+  }
+  /**
+   * 检查表是否存在
+   */
+  async checkTableExists() {
+    const { schema, client } = this.model;
+    try {
+      const result = await client.execute(queryHelper.tableMetadata(), [
+        schema.keyspace,
+        schema.tableName
+      ]);
+      return result.rows.length > 0;
+    } catch (error) {
+      return false;
+    }
+  }
+  /**
+   * 获取现有表信息
+   */
+  async getExistingTableInfo() {
+    const { schema, client } = this.model;
+    const tableColumnsRows = await client.execute(queryHelper.tableMetadata(), [
+      schema.keyspace,
+      schema.tableName
+    ]);
+    const columns = tableColumnsRows.rows.map((col) => ({
+      ...col,
+      // 标准化 kind 值：Cassandra 可能返回 "clustering" 而不是 "clustering_key"
+      kind: col.kind === "clustering" ? "clustering_key" : col.kind
+    }));
+    const indexesRows = await client.execute(queryHelper.getTableIndexes(), [
+      schema.keyspace,
+      schema.tableName
+    ]);
+    const indexes = indexesRows.rows;
+    return { columns, indexes };
+  }
+  /**
+   * 将 Schema 转换为表信息
+   */
+  async convertSchemaToTableInfo() {
+    const { schema } = this.model;
+    const columns = Object.keys(schema.fields.shape).map((field) => {
+      const kind = schema.partitionKeyFields.includes(field) ? "partition_key" : schema.clusteringKeyFields.some((ck) => ck.field === field) ? "clustering_key" : "regular";
+      return {
+        column_name: field,
+        type: convertZodToCassandraType(schema.fields.shape[field]),
+        kind
+      };
+    });
+    const indexes = Object.keys(schema.indexes ?? {}).map((index) => {
+      const options = schema.indexes?.[index];
+      const indexName = `${schema.tableName}_${index}_sai_idx`.toLowerCase();
+      const indexOptions = typeof options === "boolean" ? { case_sensitive: false, normalize: true, ascii: true } : options;
+      return {
+        index_name: indexName,
+        options: indexOptions
+      };
+    });
+    return { columns, indexes };
+  }
+  /**
+   * 比较索引选项是否相等
+   */
+  areIndexOptionsEqual(options1, options2) {
+    const normalizeOptions = (opts) => {
+      if (!opts || typeof opts !== "object") {
+        return { case_sensitive: false, normalize: true, ascii: true };
+      }
+      const toBool = (val) => {
+        if (typeof val === "boolean") return val;
+        if (typeof val === "string") return val.toLowerCase() === "true";
+        return Boolean(val);
+      };
+      return {
+        case_sensitive: toBool(opts.case_sensitive ?? false),
+        normalize: toBool(opts.normalize ?? true),
+        ascii: toBool(opts.ascii ?? true),
+        similarity_function: opts.similarity_function ?? void 0
+      };
+    };
+    const norm1 = normalizeOptions(options1);
+    const norm2 = normalizeOptions(options2);
+    return norm1.case_sensitive === norm2.case_sensitive && norm1.normalize === norm2.normalize && norm1.ascii === norm2.ascii && norm1.similarity_function === norm2.similarity_function;
+  }
+  /**
+   * 格式化索引选项为字符串
+   */
+  formatIndexOptions(options) {
+    if (!options || typeof options !== "object") {
+      return "";
+    }
+    const parts = [];
+    if (options.case_sensitive !== void 0) {
+      parts.push(`case_sensitive: ${options.case_sensitive}`);
+    }
+    if (options.normalize !== void 0) {
+      parts.push(`normalize: ${options.normalize}`);
+    }
+    if (options.ascii !== void 0) {
+      parts.push(`ascii: ${options.ascii}`);
+    }
+    if (options.similarity_function) {
+      parts.push(`similarity: ${options.similarity_function}`);
+    }
+    return parts.length > 0 ? parts.join(", ") : "";
+  }
+};
+
 // src/model.ts
 var Model = class _Model {
   schema;
@@ -1527,332 +2193,107 @@ var Model = class _Model {
       this.schema.fields
     );
   }
-  // 同步 Schema
+  // 同步 Schema（使用新的 ModelSynchronizer）
   async syncSchema(force = false) {
     try {
-      console.log(
-        `\u{1F504} \u5F00\u59CB\u540C\u6B65\u8868: ${this.schema.keyspace}.${this.schema.tableName}`
-      );
-      const operations = await this.syncTableSchema(force);
-      console.log(
-        `\u2705 \u8868 ${this.schema.keyspace}.${this.schema.tableName} \u540C\u6B65\u5B8C\u6210`
-      );
-      return operations.join("\n");
-    } catch (error) {
-      console.error(
-        `\u274C \u8868 ${this.schema.keyspace}.${this.schema.tableName} \u540C\u6B65\u5931\u8D25:`,
-        error
-      );
-      throw error;
-    }
-  }
-  // 同步表结构
-  async syncTableSchema(forceRecreate = false) {
-    const operations = [];
-    try {
-      console.log(
-        `  \u{1F4CB} \u8868\u7ED3\u6784: ${this.schema.keyspace}.${this.schema.tableName}`
-      );
-      console.log(`  \u{1F511} \u5206\u533A\u952E: [${this.schema.partitionKey.join(", ")}]`);
-      if (this.schema.clusteringKey) {
-        console.log(
-          `  \u{1F4CA} \u805A\u7C7B\u952E: ${Object.entries(this.schema.clusteringKey).map(([k, v]) => `${k}:${v}`).join(", ")}`
-        );
-      }
-      console.log(
-        `  \u{1F4DD} \u5B57\u6BB5\u6570\u91CF: ${Object.keys(this.schema.fields.shape).length}`
-      );
-      await this.client.execute(
-        queryHelper.ensureKeyspace(
-          this.schema.keyspace,
-          this.schema.keyspaceConfig
-        )
-      );
-      const tableExists = await this.checkTableExists();
+      const synchronizer = new ModelSynchronizer({
+        schema: this.schema,
+        client: this.client
+      });
+      const changes = await synchronizer.detectChanges();
+      const operations = [];
+      const tableExists = await synchronizer.checkTableExists();
       if (!tableExists) {
         operations.push(queryHelper.createTable(this.schema));
-        const indexQueries = queryHelper.createIndexes(this.schema);
-        operations.push(...indexQueries);
+        if (this.schema.indexes && Object.keys(this.schema.indexes).length > 0) {
+          operations.push(...queryHelper.createIndexes(this.schema));
+        }
+      } else if (!changes.hasChanges) {
+        await synchronizer.sync(force);
+        return "";
       } else {
-        const tableChanges = await this.analyzeTableChanges();
-        const hasUnalterableChanges = tableChanges.unalterableReasons.length > 0;
-        if (forceRecreate && hasUnalterableChanges) {
-          console.log("\u68C0\u6D4B\u5230\u4E0D\u53EF\u53D8\u66F4\u7684\u8868\u7ED3\u6784\u4FEE\u6539\uFF0C\u5C06\u91CD\u5EFA\u8868");
-          console.log("\u4E0D\u53EF\u53D8\u66F4\u539F\u56E0:", tableChanges.unalterableReasons);
-          console.log("\u6240\u6709\u53D8\u66F4:", tableChanges.changes);
+        const needsRecreate = synchronizer.shouldRecreateTable(
+          changes,
+          force
+        );
+        if (needsRecreate) {
           operations.push(
-            queryHelper.dropTable(this.schema.keyspace, this.schema.tableName)
+            `DROP TABLE IF EXISTS ${this.schema.keyspace}.${this.schema.tableName};`
           );
           operations.push(queryHelper.createTable(this.schema));
-          const indexQueries = queryHelper.createIndexes(this.schema);
-          operations.push(...indexQueries);
-        } else if (forceRecreate && !hasUnalterableChanges) {
-          console.log("\u68C0\u6D4B\u5230\u53EF\u53D8\u66F4\u7684\u8868\u7ED3\u6784\u4FEE\u6539\uFF0C\u5C06\u4F7F\u7528 ALTER TABLE");
-          console.log("\u53D8\u66F4\u8BE6\u60C5:", tableChanges.changes);
-          operations.push(...tableChanges.operations);
-          const indexOperations = await this.syncIndexes();
-          operations.push(...indexOperations);
-        } else if (!forceRecreate && hasUnalterableChanges) {
-          const reasons = tableChanges.unalterableReasons.join("; ");
-          throw new Error(
-            `\u8868 ${this.schema.keyspace}.${this.schema.tableName} \u7ED3\u6784\u5B58\u5728\u4E0D\u53EF\u53D8\u66F4\u7684\u4FEE\u6539\uFF0C\u9700\u8981\u4F7F\u7528 forceRecreate=true \u6765\u91CD\u5EFA\u8868\u3002
-\u4E0D\u53EF\u53D8\u66F4\u7684\u4FEE\u6539\u5305\u62EC\uFF1A
-${reasons}
-\u5176\u4ED6\u53D8\u66F4\uFF1A${tableChanges.changes.join("; ")}`
-          );
+          if (this.schema.indexes && Object.keys(this.schema.indexes).length > 0) {
+            operations.push(...queryHelper.createIndexes(this.schema));
+          }
         } else {
-          console.log("\u68C0\u6D4B\u5230\u53EF\u53D8\u66F4\u7684\u8868\u7ED3\u6784\u4FEE\u6539\uFF0C\u5C06\u4F7F\u7528 ALTER TABLE");
-          console.log("\u53D8\u66F4\u8BE6\u60C5:", tableChanges.changes);
-          operations.push(...tableChanges.operations);
-          const indexOperations = await this.syncIndexes();
-          operations.push(...indexOperations);
-        }
-      }
-      for (const operation of operations) {
-        await this.client.execute(operation);
-      }
-      return operations;
-    } catch (error) {
-      console.error("\u540C\u6B65\u8868\u7ED3\u6784\u65F6\u53D1\u751F\u9519\u8BEF:", error);
-      throw error;
-    }
-  }
-  // 检查表是否存在
-  async checkTableExists() {
-    try {
-      const result = await this.client.execute(queryHelper.tableMetadata(), [
-        this.schema.keyspace,
-        this.schema.tableName
-      ]);
-      return result.rows.length > 0;
-    } catch (error) {
-      return false;
-    }
-  }
-  // 分析表结构变更
-  async analyzeTableChanges() {
-    const operations = [];
-    const changes = [];
-    const unalterableReasons = [];
-    try {
-      const tableMetadata2 = await this.client.execute(queryHelper.tableMetadata(), [
-        this.schema.keyspace,
-        this.schema.tableName
-      ]).then((res) => res.rows);
-      const schemaFields = Object.keys(this.schema.fields.shape);
-      const newFields = this.getNewFields(schemaFields, tableMetadata2);
-      const deletedFields = this.getDeletedFields(schemaFields, tableMetadata2);
-      if (newFields.length > 0) {
-        changes.push(`\u65B0\u589E\u5B57\u6BB5: ${newFields.join(", ")}`);
-        operations.push(queryHelper.addColumns(this.schema, newFields));
-      }
-      if (deletedFields.length > 0) {
-        changes.push(`\u5220\u9664\u5B57\u6BB5: ${deletedFields.join(", ")}`);
-        operations.push(queryHelper.dropColumns(this.schema, deletedFields));
-      }
-      const primaryKeyChanges = await this.checkPrimaryKeyChanges();
-      if (primaryKeyChanges.hasChanges) {
-        unalterableReasons.push(
-          `\u4E3B\u952E\u53D8\u66F4: ${primaryKeyChanges.reasons.join(", ")}`
-        );
-        operations.push(
-          queryHelper.dropTable(this.schema.keyspace, this.schema.tableName)
-        );
-        operations.push(queryHelper.createTable(this.schema));
-        const indexQueries = queryHelper.createIndexes(this.schema);
-        operations.push(...indexQueries);
-      }
-      const typeChanges = await this.checkFieldTypeChanges(tableMetadata2);
-      if (typeChanges.hasChanges) {
-        unalterableReasons.push(
-          `\u5B57\u6BB5\u7C7B\u578B\u53D8\u66F4: ${typeChanges.reasons.join(", ")}`
-        );
-        operations.push(
-          queryHelper.dropTable(this.schema.keyspace, this.schema.tableName)
-        );
-        operations.push(queryHelper.createTable(this.schema));
-        const indexQueries = queryHelper.createIndexes(this.schema);
-        operations.push(...indexQueries);
-      }
-      const indexOperations = await this.syncIndexes();
-      operations.push(...indexOperations);
-      return { operations, changes, unalterableReasons };
-    } catch (error) {
-      throw new Error(
-        `\u5206\u6790\u8868 ${this.schema.keyspace}.${this.schema.tableName} \u7ED3\u6784\u53D8\u66F4\u5931\u8D25: ${error}`
-      );
-    }
-  }
-  // 智能同步索引
-  async syncIndexes() {
-    try {
-      const existingIndexes = await this.client.execute(queryHelper.getTableIndexes(), [
-        this.schema.keyspace,
-        this.schema.tableName
-      ]).then((res) => res.rows);
-      return queryHelper.syncIndexes(this.schema, existingIndexes);
-    } catch (error) {
-      console.error("\u540C\u6B65\u7D22\u5F15\u65F6\u53D1\u751F\u9519\u8BEF:", error);
-      return [];
-    }
-  }
-  // 获取新字段
-  getNewFields(schemaFields, tableMetadata2) {
-    const existingFields = tableMetadata2.map(
-      (t) => t.column_name.toLowerCase()
-    );
-    return schemaFields.filter(
-      (field) => !existingFields.includes(field.toLowerCase())
-    );
-  }
-  // 获取删除的字段
-  getDeletedFields(schemaFields, tableMetadata2) {
-    const schemaFieldSet = new Set(schemaFields.map((f) => f.toLowerCase()));
-    return tableMetadata2.filter((t) => !schemaFieldSet.has(t.column_name.toLowerCase())).map((t) => t.column_name);
-  }
-  // 检查主键变更
-  async checkPrimaryKeyChanges() {
-    try {
-      const partitionKeyResult = await this.client.execute(
-        "SELECT column_name, type FROM system_schema.columns WHERE keyspace_name = ? AND table_name = ? AND kind = 'partition_key' ALLOW FILTERING",
-        [this.schema.keyspace, this.schema.tableName]
-      );
-      const clusteringKeyResult = await this.client.execute(
-        "SELECT column_name, type FROM system_schema.columns WHERE keyspace_name = ? AND table_name = ? AND kind = 'clustering' ALLOW FILTERING",
-        [this.schema.keyspace, this.schema.tableName]
-      );
-      if (partitionKeyResult.rows.length !== this.schema.partitionKey.length) {
-        return { hasChanges: true, reasons: ["\u5206\u533A\u952E\u6570\u91CF\u4E0D\u4E00\u81F4"] };
-      }
-      const existingPartitionKeys = new Set(
-        partitionKeyResult.rows.map((row) => row.column_name.toLowerCase())
-      );
-      const schemaPartitionKeys = new Set(
-        this.schema.partitionKey.map((key) => String(key).toLowerCase())
-      );
-      if (existingPartitionKeys.size !== schemaPartitionKeys.size) {
-        return { hasChanges: true, reasons: ["\u5206\u533A\u952E\u5B57\u6BB5\u540D\u4E0D\u4E00\u81F4"] };
-      }
-      for (const key of existingPartitionKeys) {
-        if (!schemaPartitionKeys.has(key)) {
-          return { hasChanges: true, reasons: ["\u5206\u533A\u952E\u5B57\u6BB5\u540D\u4E0D\u4E00\u81F4"] };
-        }
-      }
-      if (this.schema.clusteringKey) {
-        const existingClusteringKeys = new Set(
-          clusteringKeyResult.rows.map(
-            (row) => row.column_name.toLowerCase()
-          )
-        );
-        const schemaClusteringKeys = new Set(
-          Object.keys(this.schema.clusteringKey).map((key) => key.toLowerCase())
-        );
-        if (existingClusteringKeys.size !== schemaClusteringKeys.size) {
-          return { hasChanges: true, reasons: ["\u805A\u7C7B\u952E\u914D\u7F6E\u4E0D\u4E00\u81F4"] };
-        }
-        for (const key of existingClusteringKeys) {
-          if (!schemaClusteringKeys.has(key)) {
-            return { hasChanges: true, reasons: ["\u805A\u7C7B\u952E\u914D\u7F6E\u4E0D\u4E00\u81F4"] };
+          const regularAddedFields = changes.addedFields.filter(
+            (f) => f.kind === "regular"
+          );
+          if (regularAddedFields.length > 0) {
+            operations.push(
+              queryHelper.addColumns(
+                this.schema,
+                regularAddedFields.map((f) => f.name)
+              )
+            );
           }
-        }
-      } else if (clusteringKeyResult.rows.length > 0) {
-        return { hasChanges: true, reasons: ["\u805A\u7C7B\u952E\u914D\u7F6E\u4E0D\u4E00\u81F4"] };
-      }
-      return { hasChanges: false, reasons: [] };
-    } catch (error) {
-      console.error("\u68C0\u67E5\u4E3B\u952E\u53D8\u66F4\u65F6\u53D1\u751F\u9519\u8BEF:", error);
-      return { hasChanges: false, reasons: [] };
-    }
-  }
-  // 检查字段类型变更
-  async checkFieldTypeChanges(tableMetadata2) {
-    try {
-      for (const field of Object.keys(this.schema.fields.shape)) {
-        const existingField = tableMetadata2.find(
-          (t) => t.column_name.toLowerCase() === field.toLowerCase()
-        );
-        if (existingField) {
-          const schemaType = this.getCassandraType(
-            this.schema.fields.shape[field]
+          const regularDeletedFields = changes.deletedFields.filter(
+            (f) => f.kind === "regular"
           );
-          const existingType = existingField.type.toLowerCase();
-          if (!this.isTypeCompatible(existingType, schemaType)) {
-            return {
-              hasChanges: true,
-              reasons: [
-                `\u5B57\u6BB5\u7C7B\u578B\u4E0D\u517C\u5BB9: ${field} (${existingType} \u2192 ${schemaType})`
-              ]
-            };
+          if (regularDeletedFields.length > 0) {
+            operations.push(
+              queryHelper.dropColumns(
+                this.schema,
+                regularDeletedFields.map((f) => f.name)
+              )
+            );
+          }
+          for (const deletedIndex of changes.deletedIndexes) {
+            operations.push(
+              queryHelper.dropIndex(this.schema.keyspace, deletedIndex.name)
+            );
+          }
+          for (const rebuiltIndex of changes.rebuiltIndexes) {
+            operations.push(
+              queryHelper.dropIndex(this.schema.keyspace, rebuiltIndex.name)
+            );
+          }
+          for (const addedIndex of changes.addedIndexes) {
+            const fieldName = addedIndex.name.replace(`${this.schema.tableName}_`, "").replace("_sai_idx", "");
+            const indexOptions = this.schema.indexes?.[fieldName];
+            if (indexOptions !== void 0) {
+              const indexQuery = createIndex(
+                this.schema.keyspace,
+                this.schema.tableName,
+                fieldName,
+                typeof indexOptions === "boolean" ? true : indexOptions
+              );
+              operations.push(indexQuery);
+            }
+          }
+          for (const rebuiltIndex of changes.rebuiltIndexes) {
+            const fieldName = rebuiltIndex.name.replace(`${this.schema.tableName}_`, "").replace("_sai_idx", "");
+            const indexOptions = this.schema.indexes?.[fieldName];
+            if (indexOptions !== void 0) {
+              const indexQuery = createIndex(
+                this.schema.keyspace,
+                this.schema.tableName,
+                fieldName,
+                typeof indexOptions === "boolean" ? true : indexOptions
+              );
+              operations.push(indexQuery);
+            }
           }
         }
       }
-      return { hasChanges: false, reasons: [] };
+      await synchronizer.sync(force);
+      return operations.join("\n");
     } catch (error) {
-      console.error("\u68C0\u67E5\u5B57\u6BB5\u7C7B\u578B\u53D8\u66F4\u65F6\u53D1\u751F\u9519\u8BEF:", error);
-      return { hasChanges: false, reasons: [] };
-    }
-  }
-  // 获取 Cassandra 类型
-  getCassandraType(zodType) {
-    let baseType = zodType;
-    while (baseType._def && (baseType._def.typeName === "ZodOptional" || baseType._def.typeName === "ZodNullable" || baseType._def.typeName === "ZodDefault")) {
-      baseType = baseType._def.innerType;
-    }
-    if (baseType._cassandraType) {
-      return baseType._cassandraType;
-    }
-    if (baseType._def.typeName === "ZodString") {
-      if (baseType._def.checks && baseType._def.checks.some((c) => c.kind === "uuid")) {
-        return "uuid";
-      }
-      return "text";
-    } else if (baseType._def.typeName === "ZodNumber") {
-      return "double";
-    } else if (baseType._def.typeName === "ZodBoolean") {
-      return "boolean";
-    } else if (baseType._def.typeName === "ZodDate") {
-      return "timestamp";
-    } else if (baseType._def.typeName === "ZodArray") {
-      return "list";
-    } else if (baseType._def.typeName === "ZodSet") {
-      return "set";
-    } else if (baseType._def.typeName === "ZodRecord") {
-      return "map";
-    }
-    return "text";
-  }
-  // 检查类型是否兼容
-  isTypeCompatible(existingType, newType) {
-    if (existingType === newType) {
-      return true;
-    }
-    const compatibleChanges = {
-      text: ["varchar", "ascii"],
-      // text 可以兼容 varchar 和 ascii
-      varchar: ["text", "ascii"],
-      // varchar 可以兼容 text 和 ascii
-      ascii: ["text", "varchar"],
-      // ascii 可以兼容 text 和 varchar
-      int: ["bigint", "smallint", "tinyint"],
-      // int 可以兼容其他整数类型
-      bigint: ["int", "smallint", "tinyint"],
-      // bigint 可以兼容其他整数类型
-      smallint: ["int", "bigint", "tinyint"],
-      // smallint 可以兼容其他整数类型
-      tinyint: ["int", "bigint", "smallint"],
-      // tinyint 可以兼容其他整数类型
-      float: ["double"],
-      // float 可以兼容 double
-      double: ["float"]
-      // double 可以兼容 float
-    };
-    if (compatibleChanges[existingType] && compatibleChanges[existingType].includes(newType)) {
-      return true;
-    }
-    if (compatibleChanges[newType] && compatibleChanges[newType].includes(existingType)) {
-      return true;
+      console.error(
+        `\u274C \u8868 ${this.schema.keyspace}.${this.schema.tableName} \u540C\u6B65\u5931\u8D25:`,
+        error
+      );
+      throw error;
     }
-    return false;
   }
   // 构建插入查询
   buildInsertQuery(data, options) {
@@ -1900,7 +2341,7 @@ function createModel(schema, client) {
 var uuid = () => cassandraDriver.types.Uuid.random().toString();
 
 // src/client.ts
-var Client2 = class {
+var Client3 = class {
   constructor(options) {
     this.options = options;
     this.cassandraClient = new cassandraDriver.Client({ ...options });
@@ -2069,7 +2510,7 @@ var Types = {
   )
 };
 
-exports.Client = Client2;
+exports.Client = Client3;
 exports.Model = Model;
 exports.TableSchema = TableSchema;
 exports.Types = Types;