orchid-orm 1.37.10 → 1.37.11

package/dist/migrations.js

@@ -128,18 +128,19 @@ const processSchemas = async (ast, schemas, dbStructure, verifying) => {
   }
   for (const schema of createSchemas) {
     if (dropSchemas.length) {
-      const index = await promptCreateOrRename(
+      const i = await promptCreateOrRename(
         "schema",
         schema,
         dropSchemas,
         verifying
       );
-      if (index) {
-        const from = dropSchemas[index - 1];
-        dropSchemas.splice(index - 1, 1);
+      if (i) {
+        const from = dropSchemas[i - 1];
+        dropSchemas.splice(i - 1, 1);
         renameSchemaInStructures(dbStructure.tables, from, schema);
         renameSchemaInStructures(dbStructure.views, from, schema);
         renameSchemaInStructures(dbStructure.indexes, from, schema);
+        renameSchemaInStructures(dbStructure.excludes, from, schema);
         renameSchemaInStructures(dbStructure.constraints, from, schema);
         renameSchemaInStructures(dbStructure.triggers, from, schema);
         renameSchemaInStructures(dbStructure.enums, from, schema);
@@ -303,15 +304,15 @@ const addOrRenameColumns = async (config, dbStructure, {
   for (const { key, column } of columnsToAdd) {
     if (columnsToDrop.length) {
       const codeName = column.data.name ?? key;
-      const index = await promptCreateOrRename(
+      const i = await promptCreateOrRename(
         "column",
         codeName,
         columnsToDrop.map((x) => x.key),
         verifying
       );
-      if (index) {
-        const drop = columnsToDrop[index - 1];
-        columnsToDrop.splice(index - 1, 1);
+      if (i) {
+        const drop = columnsToDrop[i - 1];
+        columnsToDrop.splice(i - 1, 1);
         const from = drop.column.data.name ?? drop.key;
         columnsToChange.set(from, {
           key,
@@ -322,8 +323,15 @@ const addOrRenameColumns = async (config, dbStructure, {
         if (dbTableData.primaryKey) {
           renameColumn(dbTableData.primaryKey.columns, from, to);
         }
-        for (const index2 of dbTableData.indexes) {
-          for (const column2 of index2.columns) {
+        for (const index of dbTableData.indexes) {
+          for (const column2 of index.columns) {
+            if ("column" in column2 && column2.column === from) {
+              column2.column = to;
+            }
+          }
+        }
+        for (const exclude of dbTableData.excludes) {
+          for (const column2 of exclude.columns) {
             if ("column" in column2 && column2.column === from) {
               column2.column = to;
             }
@@ -545,6 +553,7 @@ const changeColumn = (changeTableData, key, dbName, dbColumn, codeColumn) => {
     ...codeColumn.data,
     primaryKey: void 0,
     indexes: void 0,
+    excludes: void 0,
     foreignKeys: void 0,
     check: void 0
   };
@@ -638,8 +647,8 @@ const processDomains = async (ast, adapter, structureToAstCtx, domainsMap, dbStr
       tableExpressions.push({
         compare,
         source,
-        handle(index) {
-          const codeDomain = index === void 0 ? void 0 : found[index];
+        handle(i) {
+          const codeDomain = i === void 0 ? void 0 : found[i];
           if (!codeDomain) {
             ast.push(dropAst(dbDomain));
           } else {
@@ -781,15 +790,15 @@ const processEnums = async (ast, enums, dbStructure, currentSchema, verifying) =
   }
   for (const codeEnum of createEnums) {
     if (dropEnums.length) {
-      const index = await promptCreateOrRename(
+      const i = await promptCreateOrRename(
         "enum",
         codeEnum.name,
         dropEnums.map((x) => x.name),
         verifying
       );
-      if (index) {
-        const dbEnum = dropEnums[index - 1];
-        dropEnums.splice(index - 1, 1);
+      if (i) {
+        const dbEnum = dropEnums[i - 1];
+        dropEnums.splice(i - 1, 1);
         const fromSchema = dbEnum.schemaName;
         const from = dbEnum.name;
         const toSchema = codeEnum.schema ?? currentSchema;
@@ -973,86 +982,132 @@ const renamePrimaryKey = ({
   }
 };
 
-const processIndexes = (config, changeTableData, ast, compareExpressions) => {
-  const codeIndexes = collectCodeIndexes(config, changeTableData);
-  const codeComparableIndexes = collectCodeComparableIndexes(
+const processIndexesAndExcludes = (config, changeTableData, ast, compareExpressions) => {
+  const codeItems = collectCodeIndexes(config, changeTableData);
+  const codeComparableItems = collectCodeComparableItems(config, codeItems);
+  const skipCodeItems = {
+    indexes: /* @__PURE__ */ new Map(),
+    excludes: /* @__PURE__ */ new Map()
+  };
+  const holdCodeItems = {
+    indexes: /* @__PURE__ */ new Map(),
+    excludes: /* @__PURE__ */ new Map()
+  };
+  const processParams = {
     config,
-    codeIndexes
+    changeTableData,
+    codeComparableItems,
+    codeItems,
+    skipCodeItems,
+    holdCodeItems,
+    // counter for async SQL comparisons that are in progress
+    wait: { indexes: 0, excludes: 0 },
+    ast,
+    compareExpressions
+  };
+  processItems(processParams, "indexes");
+  processItems(processParams, "excludes");
+  addMainItems(
+    changeTableData,
+    codeItems,
+    skipCodeItems,
+    holdCodeItems,
+    "indexes"
   );
-  const skipCodeIndexes = /* @__PURE__ */ new Map();
-  const holdCodeIndexes = /* @__PURE__ */ new Map();
-  let wait = 0;
+  addMainItems(
+    changeTableData,
+    codeItems,
+    skipCodeItems,
+    holdCodeItems,
+    "excludes"
+  );
+};
+const processItems = ({
+  config,
+  changeTableData,
+  codeComparableItems,
+  codeItems,
+  skipCodeItems,
+  holdCodeItems,
+  wait,
+  ast,
+  compareExpressions
+}, key) => {
   const {
     changeTableAst: { shape }
   } = changeTableData;
-  for (const dbIndex of changeTableData.dbTableData.indexes) {
-    const hasAddedOrDroppedColumn = dbIndex.columns.some(
+  const dbItems = changeTableData.dbTableData[key];
+  for (const dbItem of dbItems) {
+    const hasAddedOrDroppedColumn = dbItem.columns.some(
       (column) => "column" in column && checkForColumnAddOrDrop(shape, column.column)
     );
     if (hasAddedOrDroppedColumn) continue;
-    normalizeIndex(dbIndex);
-    const { found, rename, foundAndHasSql } = findMatchingIndex(
-      dbIndex,
-      codeComparableIndexes,
-      codeIndexes,
-      skipCodeIndexes,
+    normalizeItem(dbItem);
+    const { found, rename, foundAndHasSql } = findMatchingItem(
+      dbItem,
+      codeComparableItems,
+      codeItems,
+      skipCodeItems,
       changeTableData.codeTable.table,
-      config
+      config,
+      key
     );
-    const { columns: dbColumns } = dbIndex;
+    const { columns: dbColumns } = dbItem;
     if (!foundAndHasSql) {
-      handleIndexChange(
+      handleItemChange(
         changeTableData,
-        dbIndex,
+        dbItem,
         dbColumns,
         found[0],
-        rename[0]
+        rename[0],
+        key
       );
       continue;
     }
-    for (const codeIndex of found) {
-      holdCodeIndexes.set(codeIndex, true);
+    for (const codeItem of found) {
+      holdCodeItems[key].set(codeItem, true);
     }
     const compare = [];
-    for (let i = 0; i < dbIndex.columns.length; i++) {
-      const column = dbIndex.columns[i];
+    for (let i = 0; i < dbItem.columns.length; i++) {
+      const column = dbItem.columns[i];
       if (!("expression" in column)) continue;
       compare.push({
         inDb: column.expression,
         inCode: found.map(
-          (index) => index.columns[i].expression
+          (x) => x.columns[i].expression
         )
       });
     }
-    if (dbIndex.with) {
+    if (dbItem.with) {
       compare.push({
-        inDb: dbIndex.with,
-        inCode: found.map((index) => index.options.with)
+        inDb: dbItem.with,
+        inCode: found.map((x) => x.options.with)
       });
     }
-    if (dbIndex.where) {
+    if (dbItem.where) {
       compare.push({
-        inDb: dbIndex.where,
-        inCode: found.map((index) => index.options.where)
+        inDb: dbItem.where,
+        inCode: found.map((x) => x.options.where)
       });
     }
-    wait++;
+    wait[key]++;
     compareExpressions.push({
       compare,
-      handle(index) {
-        const codeIndex = index === void 0 ? void 0 : found[index];
-        handleIndexChange(
+      handle(i) {
+        const codeItem = i === void 0 ? void 0 : found[i];
+        handleItemChange(
           changeTableData,
-          dbIndex,
+          dbItem,
           dbColumns,
-          codeIndex,
-          index === void 0 ? void 0 : rename[index]
+          codeItem,
+          i === void 0 ? void 0 : rename[i],
+          key
         );
-        if (codeIndex) {
-          holdCodeIndexes.delete(codeIndex);
+        if (codeItem) {
+          holdCodeItems[key].delete(codeItem);
         }
-        if (!--wait && holdCodeIndexes.size) {
-          addIndexes(changeTableData, [...holdCodeIndexes.keys()]);
+        if (!--wait[key] && holdCodeItems[key].size) {
+          addItems(changeTableData, [...holdCodeItems[key].keys()], key);
           if (!changeTableData.pushedAst) {
             changeTableData.pushedAst = true;
             ast.push(changeTableData.changeTableAst);
@@ -1061,41 +1116,41 @@ const processIndexes = (config, changeTableData, ast, compareExpressions) => {
       }
     });
   }
-  const indexesToAdd = codeIndexes.filter(
-    (index, i) => !skipCodeIndexes.has(i) && !holdCodeIndexes.has(index)
-  );
-  if (indexesToAdd.length) {
-    addIndexes(
-      changeTableData,
-      indexesToAdd.map((x) => ({
-        ...x,
-        columns: x.columnKeys,
-        columnNames: x.columns,
-        options: x.options.include ? { ...x.options, include: x.includeKeys } : x.options
-      }))
-    );
-  }
 };
 const collectCodeIndexes = (config, { codeTable, changeTableAst: { shape } }) => {
-  const codeIndexes = [];
+  const codeItems = { indexes: [], excludes: [] };
   for (const key in codeTable.shape) {
     const column = codeTable.shape[key];
-    if (!column.data.indexes) continue;
+    if (!column.data.indexes && !column.data.excludes) continue;
     const name = column.data.name ?? key;
     if (checkForColumnAddOrDrop(shape, name)) continue;
-    codeIndexes.push(
-      ...column.data.indexes.map(
-        ({
-          options: { collate, opclass, order, weight, ...options },
-          ...index
-        }) => ({
+    pushCodeColumnItems(config, codeItems, key, name, column, "indexes");
+    pushCodeColumnItems(config, codeItems, key, name, column, "excludes");
+  }
+  pushCodeCompositeItems(config, codeTable, codeItems, "indexes");
+  pushCodeCompositeItems(config, codeTable, codeItems, "excludes");
+  return codeItems;
+};
+const pushCodeColumnItems = (config, codeItems, columnKey, name, column, key) => {
+  const items = column.data[key];
+  if (!items) return;
+  codeItems[key].push(
+    ...items.map(
+      ({
+        options: { collate, opclass, order, weight, ...options },
+        with: wi,
+        ...index
+      }) => {
+        const w = key === "excludes" ? wi : void 0;
+        return {
           columns: [
             {
               collate,
               opclass,
               order,
               weight,
-              column: name
+              column: name,
+              with: w
             }
           ],
           ...index,
@@ -1103,49 +1158,70 @@ const collectCodeIndexes = (config, { codeTable, changeTableAst: { shape } }) =>
             ...options,
             include: orchidCore.toArray(options.include).map(orchidCore.toSnakeCase)
           } : options : options,
-          columnKeys: [{ collate, opclass, order, weight, column: key }],
+          columnKeys: [
+            {
+              collate,
+              opclass,
+              order,
+              weight,
+              column: columnKey,
+              with: w
+            }
+          ],
           includeKeys: options.include
-        })
-      )
-    );
-  }
-  if (codeTable.internal.tableData.indexes) {
-    codeIndexes.push(
-      ...codeTable.internal.tableData.indexes.map((x) => ({
-        ...x,
-        columns: config.snakeCase ? x.columns.map(
-          (c) => "column" in c ? { ...c, column: orchidCore.toSnakeCase(c.column) } : c
-        ) : x.columns,
-        columnKeys: x.columns,
-        options: x.options.include && config.snakeCase ? {
-          ...x.options,
-          include: orchidCore.toArray(x.options.include).map(orchidCore.toSnakeCase)
-        } : x.options,
-        includeKeys: x.options.include
-      }))
-    );
-  }
-  return codeIndexes;
-};
-const collectCodeComparableIndexes = (config, codeIndexes) => {
-  return codeIndexes.map((codeIndex) => {
-    normalizeIndex(codeIndex.options);
-    return indexToComparable({
-      ...codeIndex.options,
-      include: codeIndex.options.include === void 0 ? void 0 : config.snakeCase ? orchidCore.toArray(codeIndex.options.include).map(orchidCore.toSnakeCase) : orchidCore.toArray(codeIndex.options.include),
-      columns: codeIndex.columns,
-      name: codeIndex.name,
-      columnKeys: codeIndex.columnKeys,
-      includeKeys: codeIndex.includeKeys
+        };
+      }
+    )
+  );
+};
+const pushCodeCompositeItems = (config, codeTable, codeItems, key) => {
+  const items = codeTable.internal.tableData[key];
+  if (!items) return;
+  codeItems[key].push(
+    ...items.map((x) => ({
+      ...x,
+      columns: config.snakeCase ? x.columns.map(
+        (c) => "column" in c ? { ...c, column: orchidCore.toSnakeCase(c.column) } : c
+      ) : x.columns,
+      columnKeys: x.columns,
+      options: x.options.include && config.snakeCase ? {
+        ...x.options,
+        include: orchidCore.toArray(x.options.include).map(orchidCore.toSnakeCase)
+      } : x.options,
+      includeKeys: x.options.include
+    }))
+  );
+};
+const collectCodeComparableItems = (config, codeItems) => {
+  return {
+    indexes: collectCodeComparableItemsType(config, codeItems, "indexes"),
+    excludes: collectCodeComparableItemsType(config, codeItems, "excludes")
+  };
+};
+const collectCodeComparableItemsType = (config, codeItems, key) => {
+  return codeItems[key].map((codeItem) => {
+    normalizeItem(codeItem.options);
+    return itemToComparable({
+      ...codeItem.options,
+      include: codeItem.options.include === void 0 ? void 0 : config.snakeCase ? orchidCore.toArray(codeItem.options.include).map(orchidCore.toSnakeCase) : orchidCore.toArray(codeItem.options.include),
+      columns: codeItem.columns,
+      name: codeItem.name,
+      columnKeys: codeItem.columnKeys,
+      includeKeys: codeItem.includeKeys
     });
   });
 };
-const normalizeIndex = (index) => {
-  if (index.using === "btree") index.using = void 0;
-  if (!index.unique) index.unique = void 0;
-  if (index.nullsNotDistinct === false) index.nullsNotDistinct = void 0;
+const normalizeItem = (item) => {
+  if (item.using === "btree") item.using = void 0;
+  if (!item.unique) item.unique = void 0;
+  if (item.nullsNotDistinct === false) item.nullsNotDistinct = void 0;
+  if (item.exclude) {
+    for (let i = 0; i < item.columns.length; i++) {
+      item.columns[i].with = item.exclude[i];
+    }
+  }
 };
-const indexToComparable = (index) => {
+const itemToComparable = (index) => {
   let hasExpression = false;
   const columns = index.columns.map((column) => {
     const result = {
@@ -1168,30 +1244,43 @@ const indexToComparable = (index) => {
     hasExpression
   };
 };
-const findMatchingIndex = (dbIndex, codeComparableIndexes, codeIndexes, skipCodeIndexes, tableName, config) => {
-  const dbComparableIndex = indexToComparable(dbIndex);
-  const { found, rename } = findMatchingIndexWithoutSql(
-    dbComparableIndex,
-    codeComparableIndexes,
-    codeIndexes,
-    skipCodeIndexes,
+const findMatchingItem = (dbItem, codeComparableItems, codeItems, skipCodeItems, tableName, config, key) => {
+  const dbComparableItem = itemToComparable(
+    key === "indexes" ? dbItem : {
+      ...dbItem,
+      exclude: void 0,
+      columns: dbItem.columns.map((column, i) => ({
+        ...column,
+        with: dbItem.exclude[i]
+      }))
+    }
+  );
+  const { found, rename } = findMatchingItemWithoutSql(
+    dbComparableItem,
+    codeComparableItems,
+    codeItems,
+    skipCodeItems,
     tableName,
-    config
+    config,
+    key
   );
-  const foundAndHasSql = found.length && checkIfIndexHasSql(dbComparableIndex);
+  const foundAndHasSql = found.length && checkIfItemHasSql(dbComparableItem);
   return { found, rename, foundAndHasSql };
 };
-const findMatchingIndexWithoutSql = (dbIndex, codeComparableIndexes, codeIndexes, skipCodeIndexes, tableName, config) => {
+const findMatchingItemWithoutSql = (dbItem, codeComparableItems, codeItems, skipCodeItems, tableName, config, key) => {
   const found = [];
   const rename = [];
-  const { columns: dbColumns, ...dbIndexWithoutColumns } = dbIndex;
-  for (let i = 0; i < codeComparableIndexes.length; i++) {
-    if (skipCodeIndexes.has(i)) continue;
-    const { columns: codeColumns, ...codeIndex } = codeComparableIndexes[i];
+  const { columns: dbColumns, ...dbItemWithoutColumns } = dbItem;
+  for (let i = 0; i < codeComparableItems[key].length; i++) {
+    if (skipCodeItems[key].has(i)) continue;
+    const { columns: codeColumns, ...codeItem } = codeComparableItems[key][i];
     if (dbColumns.length === codeColumns.length && !dbColumns.some((dbColumn, i2) => !orchidCore.deepCompare(dbColumn, codeColumns[i2]))) {
-      let a = dbIndexWithoutColumns;
-      let b = codeIndex;
-      const codeName = b.name ?? rakeDb.getIndexName(tableName, dbColumns);
+      let a = dbItemWithoutColumns;
+      let b = codeItem;
+      const codeName = b.name ?? (key === "indexes" ? rakeDb.getIndexName : rakeDb.getExcludeName)(
+        tableName,
+        dbColumns
+      );
       if (a.name !== b.name) {
         a = { ...a, name: void 0 };
         b = {
@@ -1204,9 +1293,9 @@ const findMatchingIndexWithoutSql = (dbIndex, codeComparableIndexes, codeIndexes
           b.language = config.language ?? "english";
         }
         if (orchidCore.deepCompare(a, b)) {
-          found.push(codeIndexes[i]);
+          found.push(codeItems[key][i]);
           rename.push(
-            dbIndexWithoutColumns.name !== codeName ? codeName : void 0
+            dbItemWithoutColumns.name !== codeName ? codeName : void 0
           );
         }
       } else {
@@ -1214,69 +1303,96 @@ const findMatchingIndexWithoutSql = (dbIndex, codeComparableIndexes, codeIndexes
           // eslint-disable-next-line @typescript-eslint/no-unused-vars
           columnKeys,
           includeKeys,
-          ...codeIndexWithoutKeys
-        } = codeIndex;
-        if (orchidCore.deepCompare(dbIndexWithoutColumns, codeIndexWithoutKeys)) {
-          found.push(codeIndexes[i]);
+          ...codeItemWithoutKeys
+        } = codeItem;
+        if (orchidCore.deepCompare(dbItemWithoutColumns, codeItemWithoutKeys)) {
+          found.push(codeItems[key][i]);
           rename.push(void 0);
         }
       }
-      if (found.length && !checkIfIndexHasSql(codeIndex)) {
-        skipCodeIndexes.set(i, true);
+      if (found.length && !checkIfItemHasSql(codeItem)) {
+        skipCodeItems[key].set(i, true);
       }
     }
   }
   return { found, rename };
 };
-const checkIfIndexHasSql = (index) => index.hasWith || index.hasWhere || index.hasExpression;
-const handleIndexChange = ({
+const checkIfItemHasSql = (x) => x.hasWith || x.hasWhere || x.hasExpression;
+const handleItemChange = ({
   changeTableAst,
   schema,
   codeTable,
   changingColumns,
   delayedAst
-}, dbIndex, dbColumns, found, rename) => {
+}, dbItem, dbColumns, found, rename, key) => {
   var _a, _b;
   if (!found) {
-    const indexName = dbIndex.name === rakeDb.getIndexName(changeTableAst.name, dbColumns) ? void 0 : dbIndex.name;
+    const name = dbItem.name === (key === "indexes" ? rakeDb.getIndexName : rakeDb.getExcludeName)(
+      changeTableAst.name,
+      dbColumns
+    ) ? void 0 : dbItem.name;
     if (dbColumns.length === 1 && "column" in dbColumns[0]) {
-      const column = changingColumns[dbColumns[0].column];
+      const dbColumn = dbColumns[0];
+      const column = changingColumns[dbColumn.column];
       if (column) {
-        ((_a = column.from.data).indexes ?? (_a.indexes = [])).push({
-          options: dbIndex,
-          name: indexName
+        ((_a = column.from.data)[key] ?? (_a[key] = [])).push({
+          options: dbItem,
+          name,
+          with: key === "indexes" ? void 0 : dbColumn.with
         });
         return;
       }
     }
-    ((_b = changeTableAst.drop).indexes ?? (_b.indexes = [])).push({
+    ((_b = changeTableAst.drop)[key] ?? (_b[key] = [])).push({
       columns: dbColumns,
-      options: dbIndex,
-      name: indexName
+      options: dbItem,
+      name
     });
   } else if (rename) {
     delayedAst.push({
       type: "renameTableItem",
-      kind: "INDEX",
+      kind: key === "indexes" ? "INDEX" : "CONSTRAINT",
       tableSchema: schema,
       tableName: codeTable.table,
-      from: dbIndex.name,
+      from: dbItem.name,
       to: rename
     });
   }
 };
-const addIndexes = ({ changeTableAst, changingColumns }, add) => {
+const addMainItems = (changeTableData, codeItems, skipCodeItems, holdCodeItems, key) => {
+  const itemsToAdd = codeItems[key].filter(
+    (item, i) => !skipCodeItems[key].has(i) && !holdCodeItems[key].has(item)
+  );
+  if (itemsToAdd.length) {
+    addItems(
+      changeTableData,
+      itemsToAdd.map((x) => ({
+        ...x,
+        columns: x.columnKeys,
+        columnNames: x.columns,
+        options: x.options.include ? { ...x.options, include: x.includeKeys } : x.options
+      })),
+      key
+    );
+  }
+};
+const addItems = ({ changeTableAst, changingColumns }, add, key) => {
   var _a, _b;
-  const indexes = (_a = changeTableAst.add).indexes ?? (_a.indexes = []);
-  for (const index of add) {
-    if (index.columns.length === 1 && "column" in index.columns[0]) {
-      const column = changingColumns[(index.columnNames || index.columns)[0].column];
+  const items = (_a = changeTableAst.add)[key] ?? (_a[key] = []);
+  for (const item of add) {
+    if (item.columns.length === 1 && "column" in item.columns[0]) {
+      const column = changingColumns[(item.columnNames || item.columns)[0].column];
       if (column) {
-        ((_b = column.to.data).indexes ?? (_b.indexes = [])).push(index);
+        ((_b = column.to.data)[key] ?? (_b[key] = [])).push(
+          key === "indexes" ? item : {
+            ...item,
+            with: item.columns[0].with
+          }
+        );
         continue;
       }
     }
-    indexes.push(index);
+    items.push(item);
   }
 };
 
@@ -1533,13 +1649,13 @@ const processChecks = (ast, changeTableData, compareExpressions) => {
             inCode: codeChecks.map((check) => check.sql)
           }
         ],
-        handle(index) {
-          if (index !== void 0) return;
+        handle(i) {
+          if (i !== void 0) return;
           dropCheck(changeTableData, dbCheck, name);
           if (--wait === 0 && !changeTableData.pushedAst) {
             changeTableData.pushedAst = true;
             (add.constraints ?? (add.constraints = [])).push(
-              ...codeChecks.filter((_, i) => !foundCodeChecks.has(i)).map((check) => ({
+              ...codeChecks.filter((_, i2) => !foundCodeChecks.has(i2)).map((check) => ({
                 name: check.name,
                 check: check.sql
               }))
@@ -1770,15 +1886,15 @@ const applyCompareSql = async (compareSql, adapter) => {
 const applyCreateOrRenameTables = async (dbStructure, createTables, dropTables, changeTables, tableShapes, currentSchema, ast, verifying) => {
   for (const codeTable of createTables) {
     if (dropTables.length) {
-      const index = await promptCreateOrRename(
+      const i = await promptCreateOrRename(
         "table",
         codeTable.table,
         dropTables.map((x) => x.name),
         verifying
       );
-      if (index) {
-        const dbTable = dropTables[index - 1];
-        dropTables.splice(index - 1, 1);
+      if (i) {
+        const dbTable = dropTables[i - 1];
+        dropTables.splice(i - 1, 1);
         ast.push({
           type: "renameType",
           kind: "TABLE",
@@ -1860,7 +1976,7 @@ const processTableChange = async (adapter, structureToAstCtx, dbStructure, domai
     verifying
   );
   processPrimaryKey(config, changeTableData);
-  processIndexes(config, changeTableData, ast, compareExpressions);
+  processIndexesAndExcludes(config, changeTableData, ast, compareExpressions);
   processChecks(ast, changeTableData, compareExpressions);
   const { changeTableAst } = changeTableData;
   if (Object.keys(changeTableAst.shape).length || Object.keys(changeTableAst.add).length || Object.keys(changeTableAst.drop).length) {
@@ -1966,6 +2082,7 @@ const report = (ast, config, currentSchema) => {
         const counters = {
           column: 0,
           index: a.indexes?.length ?? 0,
+          exclude: a.excludes?.length ?? 0,
           "foreign key": a.constraints?.reduce(
             (sum, c) => c.references ? sum + 1 : sum,
             0
@@ -1984,6 +2101,9 @@ const report = (ast, config, currentSchema) => {
           if (column.data.indexes) {
             counters.index += column.data.indexes.length;
           }
+          if (column.data.excludes) {
+            counters.exclude += column.data.excludes.length;
+          }
           if (column.data.foreignKeys) {
             counters["foreign key"] += column.data.foreignKeys.length;
           }
@@ -2021,13 +2141,13 @@ const report = (ast, config, currentSchema) => {
           for (const change of changes) {
             if (change.type === "add" || change.type === "drop") {
               const column = change.item;
-              const { primaryKey, indexes, foreignKeys, check } = column.data;
+              const { primaryKey, indexes, excludes, foreignKeys, check } = column.data;
               inner.push(
                 `${change.type === "add" ? green("+ add column") : red("- drop column")} ${key} ${column.data.alias ?? getColumnDbType(column, currentSchema)}${column.data.isNullable ? " nullable" : ""}${primaryKey ? " primary key" : ""}${foreignKeys ? ` references ${foreignKeys.map((fk) => {
                   return `${fnOrTableToString(
                     fk.fnOrTable
                   )}(${fk.foreignColumns.join(", ")})`;
-                }).join(", ")}` : ""}${indexes?.length ? indexes.length === 1 ? ", has index" : `, has ${indexes.length} indexes` : ""}${check ? `, checks ${check.sql.toSQL({ values: [] })}` : ""}`
+                }).join(", ")}` : ""}${indexes?.length ? indexes.length === 1 ? ", has index" : `, has ${indexes.length} indexes` : ""}${excludes?.length ? excludes.length === 1 ? ", has exclude" : `, has ${excludes.length} excludes` : ""}${check ? `, checks ${check.sql.toSQL({ values: [] })}` : ""}`
               );
             } else if (change.type === "change") {
               const name = change.from.column?.data.name ?? key;
@@ -2068,6 +2188,13 @@ const report = (ast, config, currentSchema) => {
             );
           }
         }
+        if (a.drop.excludes) {
+          for (const exclude of a.drop.excludes) {
+            inner.push(
+              `${red(`- drop exclude`)} on (${exclude.columns.map((c) => "column" in c ? c.column : c.expression).join(", ")})`
+            );
+          }
+        }
         if (a.drop.constraints) {
           for (const { references } of a.drop.constraints) {
             if (!references) continue;
@@ -2107,6 +2234,13 @@ const report = (ast, config, currentSchema) => {
             );
           }
         }
+        if (a.add.excludes) {
+          for (const exclude of a.add.excludes) {
+            inner.push(
+              `${green(`+ add exclude`)} on (${exclude.columns.map((c) => "column" in c ? c.column : c.expression).join(", ")})`
+            );
+          }
+        }
         if (a.add.constraints) {
           for (const { references } of a.add.constraints) {
             if (!references) continue;
@@ -2354,6 +2488,7 @@ const migrateAndPullStructures = async (options, config, afterPull) => {
         tables: [],
         views: [],
         indexes: [],
+        excludes: [],
         constraints: [],
         triggers: [],
         extensions: [],
@@ -2592,7 +2727,7 @@ const appCodeGenTable = (tableInfos, fkeys, ast, baseTablePath, baseTableExporte
     props.push("noPrimaryKey = true;");
   }
   const hasTableData = Boolean(
-    ast.primaryKey || ast.indexes?.length || ast.constraints?.length
+    ast.primaryKey || ast.indexes?.length || ast.excludes?.length || ast.constraints?.length
   );
   const shapeCode = pqb.columnsShapeToCode({ t: "t", table: ast.name }, ast.shape);
   props.push(