rake-db 2.23.17 → 2.23.19

package/dist/index.js

@@ -7,21 +7,21 @@ var node_url = require('node:url');
 var fs = require('fs/promises');
 
 const getFirstWordAndRest = (input) => {
-  const index = input.search(/(?=[A-Z])|[-_]/);
-  if (index !== -1) {
-    const restStart = input[index] === "-" || input[index] === "_" ? index + 1 : index;
+  const i = input.search(/(?=[A-Z])|[-_]/);
+  if (i !== -1) {
+    const restStart = input[i] === "-" || input[i] === "_" ? i + 1 : i;
     const rest = input.slice(restStart);
-    return [input.slice(0, index), rest[0].toLowerCase() + rest.slice(1)];
+    return [input.slice(0, i), rest[0].toLowerCase() + rest.slice(1)];
   } else {
     return [input];
   }
 };
 const getTextAfterRegExp = (input, regex, length) => {
-  let index = input.search(regex);
-  if (index === -1) return;
-  if (input[index] === "-" || input[index] === "_") index++;
-  index += length;
-  const start = input[index] == "-" || input[index] === "_" ? index + 1 : index;
+  let i = input.search(regex);
+  if (i === -1) return;
+  if (input[i] === "-" || input[i] === "_") i++;
+  i += length;
+  const start = input[i] == "-" || input[i] === "_" ? i + 1 : i;
   const text = input.slice(start);
   return text[0].toLowerCase() + text.slice(1);
 };
@@ -46,8 +46,8 @@ const quoteWithSchema = ({
 }) => quoteTable(schema, name);
 const quoteTable = (schema, table) => schema ? `"${schema}"."${table}"` : `"${table}"`;
 const getSchemaAndTableFromName = (name) => {
-  const index = name.indexOf(".");
-  return index !== -1 ? [name.slice(0, index), name.slice(index + 1)] : [void 0, name];
+  const i = name.indexOf(".");
+  return i !== -1 ? [name.slice(0, i), name.slice(i + 1)] : [void 0, name];
 };
 const quoteNameFromString = (string) => {
   return quoteTable(...getSchemaAndTableFromName(string));
@@ -193,6 +193,16 @@ const addColumnIndex = (indexes, name, item) => {
     );
   }
 };
+const addColumnExclude = (excludes, name, item) => {
+  if (item.data.excludes) {
+    excludes.push(
+      ...item.data.excludes.map(({ with: w, ...exclude }) => ({
+        columns: [{ ...exclude.options, column: name, with: w }],
+        ...exclude
+      }))
+    );
+  }
+};
 const addColumnComment = (comments, name, item) => {
   if (item.data.comment) {
     comments.push({ column: name, comment: item.data.comment });
@@ -283,29 +293,27 @@ const makeConstraintName = (table, columns, suffix) => {
   }
   return `long_ass_table_${suffix}`;
 };
-const getIndexName = (table, columns) => {
-  return makeConstraintName(
-    table,
-    columns.map(
-      (it) => "column" in it ? it.column : "expression"
-    ),
-    "idx"
-  );
-};
+const getIndexOrExcludeName = (table, columns, suffix) => makeConstraintName(
+  table,
+  columns.map(
+    (it) => "column" in it ? it.column : "expression"
+  ),
+  suffix
+);
+const getIndexName = (table, columns) => getIndexOrExcludeName(table, columns, "idx");
+const getExcludeName = (table, columns) => getIndexOrExcludeName(table, columns, "exclude");
 const indexesToQuery = (up, { schema, name: tableName }, indexes, snakeCase, language) => {
-  return indexes.map(({ columns, options, name }) => {
-    let include = options.include ? orchidCore.toArray(options.include) : void 0;
-    if (snakeCase) {
-      columns = columns.map(
-        (c) => "column" in c ? { ...c, column: orchidCore.toSnakeCase(c.column) } : c
-      );
-      if (include) include = include.map(orchidCore.toSnakeCase);
-    }
-    const indexName = name || getIndexName(tableName, columns);
+  return indexes.map((index) => {
+    const { options } = index;
+    const { columns, include, name } = getIndexOrExcludeMainOptions(
+      tableName,
+      index,
+      getIndexName,
+      snakeCase
+    );
     if (!up) {
       return {
-        text: `DROP INDEX "${indexName}"${options.dropMode ? ` ${options.dropMode}` : ""}`,
-        values: []
+        text: `DROP INDEX "${name}"${options.dropMode ? ` ${options.dropMode}` : ""}`
       };
     }
     const values = [];
@@ -313,28 +321,20 @@ const indexesToQuery = (up, { schema, name: tableName }, indexes, snakeCase, lan
     if (options.unique) {
       sql.push("UNIQUE");
     }
-    sql.push(`INDEX "${indexName}" ON ${quoteTable(schema, tableName)}`);
+    sql.push(`INDEX "${name}" ON ${quoteTable(schema, tableName)}`);
     const u = options.using || options.tsVector && "GIN";
     if (u) {
       sql.push(`USING ${u}`);
     }
-    const columnsSql = [];
     const lang = options.tsVector && options.languageColumn ? `"${options.languageColumn}"` : options.language ? `'${options.language}'` : `'${language || "english"}'`;
     let hasWeight = options.tsVector && columns.some((column) => !!column.weight);
-    for (const column of columns) {
-      const columnSql = [
-        "column" in column ? `"${column.column}"` : `(${column.expression})`
-      ];
-      if (column.collate) {
-        columnSql.push(`COLLATE ${quoteNameFromString(column.collate)}`);
-      }
-      if (column.opclass) {
-        columnSql.push(column.opclass);
-      }
-      if (column.order) {
-        columnSql.push(column.order);
-      }
-      let sql2 = columnSql.join(" ");
+    const columnsSql = columns.map((column) => {
+      let sql2 = [
+        "column" in column ? `"${column.column}"` : `(${column.expression})`,
+        column.collate && `COLLATE ${quoteNameFromString(column.collate)}`,
+        column.opclass,
+        column.order
+      ].filter((x) => !!x).join(" ");
       if (hasWeight) {
         sql2 = `to_tsvector(${lang}, coalesce(${sql2}, ''))`;
         if (column.weight) {
@@ -342,8 +342,8 @@ const indexesToQuery = (up, { schema, name: tableName }, indexes, snakeCase, lan
           sql2 = `setweight(${sql2}, '${column.weight}')`;
         }
       }
-      columnsSql.push(sql2);
-    }
+      return sql2;
+    });
     let columnList;
     if (hasWeight) {
       columnList = `(${columnsSql.join(" || ")})`;
@@ -353,9 +353,9 @@ const indexesToQuery = (up, { schema, name: tableName }, indexes, snakeCase, lan
       columnList = columnsSql.join(", ");
     }
     sql.push(`(${columnList})`);
-    if (options.include) {
+    if (include && include.length) {
       sql.push(
-        `INCLUDE (${orchidCore.toArray(include).map((column) => `"${column}"`).join(", ")})`
+        `INCLUDE (${include.map((column) => `"${column}"`).join(", ")})`
       );
     }
     if (options.nullsNotDistinct) {
@@ -375,6 +375,63 @@ const indexesToQuery = (up, { schema, name: tableName }, indexes, snakeCase, lan
     return { text: sql.join(" "), values };
   });
 };
+const excludesToQuery = (up, { schema, name: tableName }, excludes, snakeCase) => {
+  return excludes.map((exclude) => {
+    const { options } = exclude;
+    const { columns, include, name } = getIndexOrExcludeMainOptions(
+      tableName,
+      exclude,
+      getExcludeName,
+      snakeCase
+    );
+    if (!up) {
+      return {
+        text: `ALTER TABLE ${quoteTable(
+          schema,
+          tableName
+        )} DROP CONSTRAINT "${name}"${options.dropMode ? ` ${options.dropMode}` : ""}`
+      };
+    }
+    const columnList = columns.map(
+      (column) => [
+        "column" in column ? `"${column.column}"` : `(${column.expression})`,
+        column.collate && `COLLATE ${quoteNameFromString(column.collate)}`,
+        column.opclass,
+        column.order,
+        `WITH ${column.with}`
+      ].filter((x) => !!x).join(" ")
+    ).join(", ");
+    const values = [];
+    const text = [
+      `ALTER TABLE ${quoteTable(
+        schema,
+        tableName
+      )} ADD CONSTRAINT "${name}" EXCLUDE`,
+      options.using && `USING ${options.using}`,
+      `(${columnList})`,
+      include?.length && `INCLUDE (${include.map((column) => `"${column}"`).join(", ")})`,
+      options.with && `WITH (${options.with})`,
+      options.tablespace && `USING INDEX TABLESPACE ${options.tablespace}`,
+      options.where && `WHERE ${orchidCore.isRawSQL(options.where) ? options.where.toSQL({ values }) : options.where}`
+    ].filter((x) => !!x).join(" ");
+    return { text, values };
+  });
+};
+const getIndexOrExcludeMainOptions = (tableName, item, getName, snakeCase) => {
+  let include = item.options.include ? orchidCore.toArray(item.options.include) : void 0;
+  let { columns } = item;
+  if (snakeCase) {
+    columns = columns.map(
+      (c) => "column" in c ? { ...c, column: orchidCore.toSnakeCase(c.column) } : c
+    );
+    if (include) include = include.map(orchidCore.toSnakeCase);
+  }
+  return {
+    columns,
+    include,
+    name: item.name || getName(tableName, columns)
+  };
+};
 const commentsToQuery = (schemaTable, comments) => {
   return comments.map(({ column, comment }) => ({
     text: `COMMENT ON COLUMN ${quoteWithSchema(
@@ -537,11 +594,13 @@ const astToQueries$1 = (ast, snakeCase, language) => {
   const lines = [];
   const values = [];
   const indexes = [];
+  const excludes = [];
   const comments = [];
   for (const key in shape) {
     const item = shape[key];
     const name = getColumnName(item, key, snakeCase);
     addColumnIndex(indexes, name, item);
+    addColumnExclude(excludes, name, item);
     addColumnComment(comments, name, item);
     lines.push(
       `
@@ -579,17 +638,8 @@ const astToQueries$1 = (ast, snakeCase, language) => {
       )}`
     );
   });
-  indexes.push(
-    ...ast.indexes?.map((index) => ({
-      ...index,
-      columns: index.columns.map((item) => ({
-        ...item,
-        ..."column" in item ? {
-          column: getColumnName(shape[item.column], item.column, snakeCase)
-        } : {}
-      }))
-    })) || []
-  );
+  pushIndexesOrExcludesFromAst(indexes, ast.indexes, shape, snakeCase);
+  pushIndexesOrExcludesFromAst(excludes, ast.excludes, shape, snakeCase);
   queries.push(
     {
       text: `CREATE TABLE${ast.createIfNotExists ? " IF NOT EXISTS" : ""} ${quoteWithSchema(ast)} (${lines.join(",")}
@@ -597,6 +647,7 @@ const astToQueries$1 = (ast, snakeCase, language) => {
       values
     },
     ...indexesToQuery(true, ast, indexes, snakeCase, language),
+    ...excludesToQuery(true, ast, excludes, snakeCase),
     ...commentsToQuery(ast, comments)
   );
   if (ast.comment) {
@@ -608,6 +659,19 @@ const astToQueries$1 = (ast, snakeCase, language) => {
   }
   return queries;
 };
+const pushIndexesOrExcludesFromAst = (arr, inAst, shape, snakeCase) => {
+  arr.push(
+    ...inAst?.map((x) => ({
+      ...x,
+      columns: x.columns.map((item) => ({
+        ...item,
+        ..."column" in item ? {
+          column: getColumnName(shape[item.column], item.column, snakeCase)
+        } : {}
+      }))
+    })) || []
+  );
+};
 
 const newChangeTableData = () => ({
   add: {},
@@ -929,6 +993,8 @@ const astToQueries = (ast, snakeCase, language) => {
   const values = [];
   const addIndexes = ast.add.indexes ?? [];
   const dropIndexes = ast.drop.indexes ?? [];
+  const addExcludes = ast.add.excludes ?? [];
+  const dropExcludes = ast.drop.excludes ?? [];
   const addConstraints = ast.add.constraints ?? [];
   const dropConstraints = ast.drop.constraints ?? [];
   const comments = [];
@@ -946,6 +1012,8 @@ const astToQueries = (ast, snakeCase, language) => {
           addPrimaryKeys,
           addIndexes,
           dropIndexes,
+          addExcludes,
+          dropExcludes,
           addConstraints,
           dropConstraints,
           comments,
@@ -963,6 +1031,8 @@ const astToQueries = (ast, snakeCase, language) => {
         addPrimaryKeys,
         addIndexes,
         dropIndexes,
+        addExcludes,
+        dropExcludes,
         addConstraints,
         dropConstraints,
         comments,
@@ -1014,6 +1084,8 @@ const astToQueries = (ast, snakeCase, language) => {
   }
   queries.push(...indexesToQuery(false, ast, dropIndexes, snakeCase, language));
   queries.push(...indexesToQuery(true, ast, addIndexes, snakeCase, language));
+  queries.push(...excludesToQuery(false, ast, dropExcludes, snakeCase));
+  queries.push(...excludesToQuery(true, ast, addExcludes, snakeCase));
   queries.push(...commentsToQuery(ast, comments));
   return queries;
 };
@@ -1058,11 +1130,12 @@ const handlePrerequisitesForTableItem = (key, item, queries, addPrimaryKeys, dro
     }
   }
 };
-const handleTableItemChange = (key, item, ast, alterTable, renameItems, values, addPrimaryKeys, addIndexes, dropIndexes, addConstraints, dropConstraints, comments, snakeCase) => {
+const handleTableItemChange = (key, item, ast, alterTable, renameItems, values, addPrimaryKeys, addIndexes, dropIndexes, addExcludes, dropExcludes, addConstraints, dropConstraints, comments, snakeCase) => {
   if (item.type === "add") {
     const column = item.item;
     const name = getColumnName(column, key, snakeCase);
     addColumnIndex(addIndexes, name, column);
+    addColumnExclude(addExcludes, name, column);
     addColumnComment(comments, name, column);
     alterTable.push(
       `ADD COLUMN ${columnToSql(
@@ -1167,38 +1240,15 @@ const handleTableItemChange = (key, item, ast, alterTable, renameItems, values,
         }
       }
     }
-    const indexesLen = Math.max(
-      from.indexes?.length || 0,
-      to.indexes?.length || 0
+    pushIndexesOrExcludes("indexes", from, to, name, addIndexes, dropIndexes);
+    pushIndexesOrExcludes(
+      "excludes",
+      from,
+      to,
+      name,
+      addExcludes,
+      dropExcludes
     );
-    for (let i = 0; i < indexesLen; i++) {
-      const fromIndex = from.indexes?.[i];
-      const toIndex = to.indexes?.[i];
-      if ((fromIndex || toIndex) && (!fromIndex || !toIndex || !orchidCore.deepCompare(fromIndex, toIndex))) {
-        if (fromIndex) {
-          dropIndexes.push({
-            ...fromIndex,
-            columns: [
-              {
-                column: name,
-                ...fromIndex.options
-              }
-            ]
-          });
-        }
-        if (toIndex) {
-          addIndexes.push({
-            ...toIndex,
-            columns: [
-              {
-                column: name,
-                ...toIndex.options
-              }
-            ]
-          });
-        }
-      }
-    }
     if (from.comment !== to.comment) {
       comments.push({ column: name, comment: to.comment || null });
     }
@@ -1208,6 +1258,39 @@ const handleTableItemChange = (key, item, ast, alterTable, renameItems, values,
     );
   }
 };
+const pushIndexesOrExcludes = (key, from, to, name, add2, drop2) => {
+  const len = Math.max(from[key]?.length || 0, to[key]?.length || 0);
+  for (let i = 0; i < len; i++) {
+    const fromItem = from[key]?.[i];
+    const toItem = to[key]?.[i];
+    if ((fromItem || toItem) && (!fromItem || !toItem || !orchidCore.deepCompare(fromItem, toItem))) {
+      if (fromItem) {
+        drop2.push({
+          ...fromItem,
+          columns: [
+            {
+              column: name,
+              ...fromItem.options,
+              with: fromItem.with
+            }
+          ]
+        });
+      }
+      if (toItem) {
+        add2.push({
+          ...toItem,
+          columns: [
+            {
+              column: name,
+              ...toItem.options,
+              with: toItem.with
+            }
+          ]
+        });
+      }
+    }
+  }
+};
 const getChangeColumnName = (what, change, key, snakeCase) => {
   return change.name || (change[what].column ? (
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
@@ -3912,9 +3995,8 @@ async function introspectDbSchema(db) {
     }
   }
   const indexes = [];
+  const excludes = [];
   for (const index of result.indexes) {
-    if (index.exclude) continue;
-    indexes.push(index);
     nullsToUndefined(index);
     for (const column of index.columns) {
       if (!("expression" in column)) continue;
@@ -3972,8 +4054,10 @@ async function introspectDbSchema(db) {
         }
       }
     }
+    (index.exclude ? excludes : indexes).push(index);
   }
   result.indexes = indexes;
+  result.excludes = excludes;
   return result;
 }
 const nullsToUndefined = (obj) => {
@@ -4173,7 +4257,7 @@ const instantiateColumnByDbType = (ctx, type, isSerial, params) => {
 const tableToAst = (ctx, data, table, action, domains) => {
   const { schemaName, name: tableName } = table;
   const tableData = getDbStructureTableData(data, table);
-  const { primaryKey, indexes, constraints } = tableData;
+  const { primaryKey, constraints } = tableData;
   return {
     type: "table",
     action,
@@ -4183,25 +4267,16 @@ const tableToAst = (ctx, data, table, action, domains) => {
     shape: makeDbStructureColumnsShape(ctx, data, domains, table, tableData),
     noPrimaryKey: tableData.primaryKey ? "error" : "ignore",
     primaryKey: primaryKey && primaryKey.columns.length > 1 ? { ...primaryKey, columns: primaryKey.columns.map(orchidCore.toCamelCase) } : void 0,
-    indexes: indexes.reduce((acc, index) => {
-      if (index.columns.length > 1 || index.columns.some((it) => "expression" in it)) {
-        const { name, ...options } = makeIndexOptions(tableName, index);
-        acc.push({
-          columns: index.columns.map((it) => ({
-            ..."column" in it ? { column: orchidCore.toCamelCase(it.column) } : { expression: it.expression },
-            collate: it.collate,
-            opclass: it.opclass,
-            order: it.order
-          })),
-          options: {
-            ...options,
-            include: index.include?.map(orchidCore.toCamelCase)
-          },
-          name
-        });
-      }
-      return acc;
-    }, []),
+    indexes: indexesOrExcludesToAst(
+      tableName,
+      tableData,
+      "indexes"
+    ),
+    excludes: indexesOrExcludesToAst(
+      tableName,
+      tableData,
+      "excludes"
+    ),
     constraints: constraints.reduce((acc, it) => {
       if (it.check && it.references || it.check && it.check.columns?.length !== 1 || it.references && it.references.columns.length !== 1 && !checkIfIsOuterRecursiveFkey(data, table, it.references)) {
         acc.push(dbConstraintToTableConstraint(ctx, table, it));
@@ -4210,22 +4285,47 @@ const tableToAst = (ctx, data, table, action, domains) => {
     }, [])
   };
 };
+const indexesOrExcludesToAst = (tableName, tableData, key) => {
+  return tableData[key].reduce((acc, item) => {
+    if (item.columns.length > 1 || item.columns.some((it) => "expression" in it)) {
+      const { name, ...options } = makeIndexOrExcludeOptions(
+        tableName,
+        item,
+        key
+      );
+      acc.push({
+        columns: item.columns.map((it, i) => ({
+          with: "exclude" in item && item.exclude ? item.exclude[i] : void 0,
+          ..."column" in it ? { column: orchidCore.toCamelCase(it.column) } : { expression: it.expression },
+          collate: it.collate,
+          opclass: it.opclass,
+          order: it.order
+        })),
+        options: {
+          ...options,
+          include: item.include?.map(orchidCore.toCamelCase)
+        },
+        name
+      });
+    }
+    return acc;
+  }, []);
+};
 const getDbStructureTableData = (data, { name, schemaName }) => {
-  const constraints = data.constraints.filter(
-    (c) => c.tableName === name && c.schemaName === schemaName
-  );
+  const filterFn = filterByTableSchema(name, schemaName);
+  const constraints = data.constraints.filter(filterFn);
   const primaryKey = constraints.find((c) => c.primaryKey);
   return {
     primaryKey: primaryKey?.primaryKey ? {
       columns: primaryKey.primaryKey,
       name: primaryKey.name === `${name}_pkey` ? void 0 : primaryKey.name
     } : void 0,
-    indexes: data.indexes.filter(
-      (it) => it.tableName === name && it.schemaName === schemaName
-    ),
+    indexes: data.indexes.filter(filterFn),
+    excludes: data.excludes.filter(filterFn),
     constraints
   };
 };
+const filterByTableSchema = (tableName, schemaName) => (x) => x.tableName === tableName && x.schemaName === schemaName;
 const constraintToAst = (ctx, item) => {
   const result = {};
   const { references, check } = item;
@@ -4309,7 +4409,6 @@ const getDbTableColumnsChecks = (tableData) => tableData.constraints.reduce((acc
   return acc;
 }, {});
 const dbColumnToAst = (ctx, data, domains, tableName, item, table, tableData, checks) => {
-  var _a;
   let column = instantiateDbColumn(ctx, data, domains, item);
   column.data.name = item.name;
   if (item.identity) {
@@ -4319,24 +4418,14 @@ const dbColumnToAst = (ctx, data, domains, tableName, item, table, tableData, ch
   if (tableData?.primaryKey?.columns?.length === 1 && tableData?.primaryKey?.columns[0] === item.name) {
     column = column.primaryKey();
   }
-  if (tableData?.indexes) {
-    const columnIndexes = tableData?.indexes.filter(
-      (it) => it.columns.length === 1 && "column" in it.columns[0] && it.columns[0].column === item.name
-    );
-    for (const index of columnIndexes) {
-      const columnOptions = index.columns[0];
-      const { name, ...indexOptions } = makeIndexOptions(tableName, index);
-      ((_a = column.data).indexes ?? (_a.indexes = [])).push({
-        options: {
-          collate: columnOptions.collate,
-          opclass: columnOptions.opclass,
-          order: columnOptions.order,
-          ...indexOptions
-        },
-        name
-      });
-    }
-  }
+  collectColumnIndexesOrExcludes(item, column, tableName, tableData, "indexes");
+  collectColumnIndexesOrExcludes(
+    item,
+    column,
+    tableName,
+    tableData,
+    "excludes"
+  );
   if (table) {
     for (const it of data.constraints) {
       if (it.tableName !== table.name || it.schemaName !== table.schemaName || it.check || it.references?.columns.length !== 1 || it.references.columns[0] !== item.name || checkIfIsOuterRecursiveFkey(data, table, it.references)) {
@@ -4365,6 +4454,32 @@ const dbColumnToAst = (ctx, data, domains, tableName, item, table, tableData, ch
   }
   return [camelCaseName, column];
 };
+const collectColumnIndexesOrExcludes = (dbColumn, column, tableName, tableData, key) => {
+  var _a;
+  const items = tableData?.[key];
+  if (!items) return;
+  const columnItems = items.filter(
+    (it) => it.columns.length === 1 && "column" in it.columns[0] && it.columns[0].column === dbColumn.name
+  );
+  for (const item of columnItems) {
+    const columnOptions = item.columns[0];
+    const { name, ...itemOptions } = makeIndexOrExcludeOptions(
+      tableName,
+      item,
+      key
+    );
+    ((_a = column.data)[key] ?? (_a[key] = [])).push({
+      with: "exclude" in item && item.exclude ? item.exclude[0] : void 0,
+      options: {
+        collate: columnOptions.collate,
+        opclass: columnOptions.opclass,
+        order: columnOptions.order,
+        ...itemOptions
+      },
+      name
+    });
+  }
+};
 const dbConstraintToTableConstraint = (ctx, table, item) => {
   const { references, check } = item;
   const constraint = {
@@ -4389,9 +4504,12 @@ const dbConstraintToTableConstraint = (ctx, table, item) => {
   }
   return constraint;
 };
-const makeIndexOptions = (tableName, index) => {
+const makeIndexOrExcludeOptions = (tableName, index, key) => {
   return {
-    name: index.name !== getIndexName(tableName, index.columns) ? index.name : void 0,
+    name: index.name !== (key === "indexes" ? getIndexName : getExcludeName)(
+      tableName,
+      index.columns
+    ) ? index.name : void 0,
     using: index.using === "btree" ? void 0 : index.using,
     unique: index.unique || void 0,
     include: index.include,
@@ -4605,16 +4723,8 @@ const analyzeTableColumns = (config, currentSchema, schema, table, deps, resolve
     if (primaryKey) {
       keys.push(`${table}_pkey`);
     }
-    const indexes = change.indexes || change.column?.data.indexes;
-    if (indexes) {
-      for (const index of indexes) {
-        keys.push(
-          index.name ? `${schema}.${index.name}` : getIndexName(table, [
-            { column: change.column?.data.name ?? name }
-          ])
-        );
-      }
-    }
+    pushIndexOrExcludeKeys(change, keys, schema, table, name, "indexes");
+    pushIndexOrExcludeKeys(change, keys, schema, table, name, "excludes");
     const foreignKeys = change.foreignKeys || change.column?.data.foreignKeys;
     if (foreignKeys) {
       for (const fkey of foreignKeys) {
@@ -4633,18 +4743,33 @@ const analyzeTableColumns = (config, currentSchema, schema, table, deps, resolve
     }
   }
 };
+const pushIndexOrExcludeKeys = (change, keys, schema, table, name, key) => {
+  const items = change[key] || change.column?.data[key];
+  if (items) {
+    const getName = key === "indexes" ? getIndexName : getExcludeName;
+    for (const x of items) {
+      keys.push(
+        x.name ? `${schema}.${x.name}` : getName(table, [{ column: change.column?.data.name ?? name }])
+      );
+    }
+  }
+};
+const pushIndexesOrExcludesKeys = (keys, schema, table, data, key) => {
+  const arr = data[key];
+  if (arr) {
+    const getName = key === "indexes" ? getIndexName : getExcludeName;
+    for (const x of arr) {
+      keys.push(x.name ? `${schema}.${x.name}` : getName(table, x.columns));
+    }
+  }
+};
 const analyzeTableData = (config, currentSchema, schema, table, keys, deps, data) => {
   if (data.primaryKey) {
     const name = data.primaryKey.name;
     keys.push(name ? `${schema}.${name}` : `${table}_pkey`);
   }
-  if (data.indexes) {
-    for (const index of data.indexes) {
-      keys.push(
-        index.name ? `${schema}.${index.name}` : getIndexName(table, index.columns)
-      );
-    }
-  }
+  pushIndexesOrExcludesKeys(keys, schema, table, data, "indexes");
+  pushIndexesOrExcludesKeys(keys, schema, table, data, "excludes");
   if (data.constraints) {
     for (const constraint of data.constraints) {
       keys.push(
@@ -4781,7 +4906,7 @@ const astEncoders = {
     const result = code;
     const hasOptions = Boolean(ast.comment || ast.noPrimaryKey === "ignore");
     const hasTableData = Boolean(
-      ast.primaryKey || ast.indexes?.length || ast.constraints?.length
+      ast.primaryKey || ast.indexes?.length || ast.excludes?.length || ast.constraints?.length
     );
     const isShifted = hasOptions || hasTableData;
     if (isShifted) {
@@ -4938,15 +5063,20 @@ const astEncoders = {
       if (timestamps.hasAnyTimestamps) {
         orchidCore.addCode(code, [`...t.${key}(${timestampsToCode(timestamps)}),`]);
       }
-      const { primaryKey, indexes, constraints } = ast[key];
+      const { primaryKey, indexes, excludes, constraints } = ast[key];
       if (primaryKey) {
         orchidCore.addCode(code, [
           `...t.${key}(${pqb.primaryKeyInnerToCode(primaryKey, "t")}),`
         ]);
       }
       if (indexes) {
-        for (const index of indexes) {
-          orchidCore.addCode(code, [`...t.${key}(`, pqb.indexInnerToCode(index, "t"), "),"]);
+        for (const item of indexes) {
+          orchidCore.addCode(code, [`...t.${key}(`, pqb.indexInnerToCode(item, "t"), "),"]);
+        }
+      }
+      if (excludes) {
+        for (const item of excludes) {
+          orchidCore.addCode(code, [`...t.${key}(`, pqb.excludeInnerToCode(item, "t"), "),"]);
         }
       }
       if (constraints) {
@@ -5655,6 +5785,7 @@ exports.Migration = Migration;
 exports.NoMigrationsTableError = NoMigrationsTableError;
 exports.RAKE_DB_LOCK_KEY = RAKE_DB_LOCK_KEY;
 exports.addColumnComment = addColumnComment;
+exports.addColumnExclude = addColumnExclude;
 exports.addColumnIndex = addColumnIndex;
 exports.addOrDropEnumValues = addOrDropEnumValues;
 exports.astToMigration = astToMigration;
@@ -5673,6 +5804,7 @@ exports.dbColumnToAst = dbColumnToAst;
 exports.deleteMigratedVersion = deleteMigratedVersion;
 exports.dropDb = dropDb;
 exports.encodeColumnDefault = encodeColumnDefault;
+exports.excludesToQuery = excludesToQuery;
 exports.exhaustive = exhaustive;
 exports.generateTimeStamp = generateTimeStamp;
 exports.getColumnName = getColumnName;
@@ -5681,6 +5813,7 @@ exports.getCurrentChanges = getCurrentChanges;
 exports.getDatabaseAndUserFromOptions = getDatabaseAndUserFromOptions;
 exports.getDbStructureTableData = getDbStructureTableData;
 exports.getDbTableColumnsChecks = getDbTableColumnsChecks;
+exports.getExcludeName = getExcludeName;
 exports.getFirstWordAndRest = getFirstWordAndRest;
 exports.getForeignKeyTable = getForeignKeyTable;
 exports.getIndexName = getIndexName;