@supabase/pg-delta 1.0.0-alpha.2 → 1.0.0-alpha.20

package/dist/core/objects/table/changes/table.comment.d.ts

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
 import type { ColumnProps } from "../../base.model.ts";
 import type { Table, TableConstraintProps } from "../table.model.ts";
 import { CreateTableChange, DropTableChange } from "./table.base.ts";
@@ -29,7 +30,7 @@ export declare class CreateCommentOnTable extends CreateTableChange {
     });
     get creates(): `comment:${string}`[];
     get requires(): `table:${string}`[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }
 /**
  * COMMENT ON TABLE ... IS ...
@@ -42,7 +43,7 @@ export declare class DropCommentOnTable extends DropTableChange {
     });
     get drops(): `comment:${string}`[];
     get requires(): (`comment:${string}` | `table:${string}`)[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }
 /**
  * COMMENT ON COLUMN ... IS ...
@@ -57,7 +58,7 @@ export declare class CreateCommentOnColumn extends CreateTableChange {
     });
     get creates(): `comment:${string}`[];
     get requires(): `column:${string}.${string}.${string}`[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }
 /**
  * COMMENT ON COLUMN ... IS ...
@@ -72,7 +73,7 @@ export declare class DropCommentOnColumn extends DropTableChange {
     });
     get drops(): `comment:${string}`[];
     get requires(): (`column:${string}.${string}.${string}` | `comment:${string}`)[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }
 /**
  * COMMENT ON CONSTRAINT ... IS ...
@@ -87,7 +88,7 @@ export declare class CreateCommentOnConstraint extends CreateTableChange {
     });
     get creates(): `comment:${string}`[];
     get requires(): `constraint:${string}.${string}.${string}`[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }
 /**
  * COMMENT ON CONSTRAINT ... IS ...
@@ -102,5 +103,5 @@ export declare class DropCommentOnConstraint extends DropTableChange {
     });
     get drops(): `comment:${string}`[];
     get requires(): (`constraint:${string}.${string}.${string}` | `comment:${string}`)[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }

package/dist/core/objects/table/changes/table.comment.js

@@ -17,7 +17,7 @@ export class CreateCommentOnTable extends CreateTableChange {
     get requires() {
         return [this.table.stableId];
     }
-    serialize() {
+    serialize(_options) {
         return [
             "COMMENT ON TABLE",
             `${this.table.schema}.${this.table.name}`,
@@ -43,7 +43,7 @@ export class DropCommentOnTable extends DropTableChange {
     get requires() {
         return [stableId.comment(this.table.stableId), this.table.stableId];
     }
-    serialize() {
+    serialize(_options) {
         return [
             "COMMENT ON TABLE",
             `${this.table.schema}.${this.table.name}`,
@@ -72,7 +72,7 @@ export class CreateCommentOnColumn extends CreateTableChange {
             stableId.column(this.table.schema, this.table.name, this.column.name),
         ];
     }
-    serialize() {
+    serialize(_options) {
         return [
             "COMMENT ON COLUMN",
             `${this.table.schema}.${this.table.name}.${this.column.name}`,
@@ -102,7 +102,7 @@ export class DropCommentOnColumn extends DropTableChange {
         const columnStableId = stableId.column(this.table.schema, this.table.name, this.column.name);
         return [stableId.comment(columnStableId), columnStableId];
     }
-    serialize() {
+    serialize(_options) {
         return [
             "COMMENT ON COLUMN",
             `${this.table.schema}.${this.table.name}.${this.column.name}`,
@@ -131,7 +131,7 @@ export class CreateCommentOnConstraint extends CreateTableChange {
             stableId.constraint(this.table.schema, this.table.name, this.constraint.name),
         ];
     }
-    serialize() {
+    serialize(_options) {
         return [
             "COMMENT ON CONSTRAINT",
             this.constraint.name,
@@ -163,7 +163,7 @@ export class DropCommentOnConstraint extends DropTableChange {
         const constraintStableId = stableId.constraint(this.table.schema, this.table.name, this.constraint.name);
         return [stableId.comment(constraintStableId), constraintStableId];
     }
-    serialize() {
+    serialize(_options) {
         return [
             "COMMENT ON CONSTRAINT",
             this.constraint.name,

package/dist/core/objects/table/changes/table.create.d.ts

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
 import type { Table } from "../table.model.ts";
 import { CreateTableChange } from "./table.base.ts";
 /**
@@ -29,5 +30,5 @@ export declare class CreateTable extends CreateTableChange {
     });
     get creates(): (`column:${string}.${string}.${string}` | `table:${string}`)[];
     get requires(): string[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }

package/dist/core/objects/table/changes/table.create.js

@@ -64,10 +64,13 @@ export class CreateTable extends CreateTableChange {
                     }
                 }
             }
+            // Function dependencies from DEFAULT expressions are handled by pg_depend
+            // catalog constraints in the sort pipeline, which provides exact argument
+            // types and covers all expression contexts (not just column defaults).
         }
         return Array.from(dependencies);
     }
-    serialize() {
+    serialize(_options) {
         const parts = ["CREATE"];
         // Add TEMPORARY/UNLOGGED based on persistence
         if (this.table.persistence === "t") {

package/dist/core/objects/table/changes/table.drop.d.ts

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
 import type { Table } from "../table.model.ts";
 import { DropTableChange } from "./table.base.ts";
 /**
@@ -13,10 +14,22 @@ import { DropTableChange } from "./table.base.ts";
 export declare class DropTable extends DropTableChange {
     readonly table: Table;
     readonly scope: "object";
+    /**
+     * Names of constraints on this table that are dropped explicitly by a
+     * separate `AlterTableDropConstraint` change. Those constraints must not be
+     * claimed by `DropTable.drops` / `.requires`, otherwise catalog edges tied
+     * to the constraint stableId will attach to this DropTable node instead of
+     * the dedicated AlterTableDropConstraint node. When two tables with mutual
+     * FK references are dropped in the same phase, that misattribution
+     * produces an unbreakable cycle between the two DropTable changes.
+     */
+    readonly externallyDroppedConstraints: ReadonlySet<string>;
     constructor(props: {
         table: Table;
+        externallyDroppedConstraints?: ReadonlySet<string>;
     });
-    get drops(): (`column:${string}.${string}.${string}` | `table:${string}`)[];
-    get requires(): (`column:${string}.${string}.${string}` | `table:${string}`)[];
-    serialize(): string;
+    private get claimedConstraints();
+    get drops(): (`column:${string}.${string}.${string}` | `constraint:${string}.${string}.${string}` | `table:${string}`)[];
+    get requires(): (`column:${string}.${string}.${string}` | `constraint:${string}.${string}.${string}` | `table:${string}`)[];
+    serialize(_options?: SerializeOptions): string;
 }

package/dist/core/objects/table/changes/table.drop.js

@@ -13,23 +13,46 @@ import { DropTableChange } from "./table.base.js";
 export class DropTable extends DropTableChange {
     table;
     scope = "object";
+    /**
+     * Names of constraints on this table that are dropped explicitly by a
+     * separate `AlterTableDropConstraint` change. Those constraints must not be
+     * claimed by `DropTable.drops` / `.requires`, otherwise catalog edges tied
+     * to the constraint stableId will attach to this DropTable node instead of
+     * the dedicated AlterTableDropConstraint node. When two tables with mutual
+     * FK references are dropped in the same phase, that misattribution
+     * produces an unbreakable cycle between the two DropTable changes.
+     */
+    externallyDroppedConstraints;
     constructor(props) {
         super();
         this.table = props.table;
+        this.externallyDroppedConstraints =
+            props.externallyDroppedConstraints ?? new Set();
+    }
+    get claimedConstraints() {
+        return this.table.constraints.filter((constraint) => !this.externallyDroppedConstraints.has(constraint.name));
     }
     get drops() {
         return [
             this.table.stableId,
             ...this.table.columns.map((column) => stableId.column(this.table.schema, this.table.name, column.name)),
+            // Include constraint stableIds so FK relationships that only exist at the
+            // constraint level still affect whole-table drop ordering. Skip any
+            // constraint that the diff layer is dropping via a dedicated
+            // AlterTableDropConstraint change — that node owns the stableId.
+            ...this.claimedConstraints.map((constraint) => stableId.constraint(this.table.schema, this.table.name, constraint.name)),
         ];
     }
     get requires() {
         return [
             this.table.stableId,
             ...this.table.columns.map((col) => stableId.column(this.table.schema, this.table.name, col.name)),
+            // Mirror the dropped constraint ids in requires so drop-phase graph
+            // consumers can connect catalog FK edges back to this table drop.
+            ...this.claimedConstraints.map((constraint) => stableId.constraint(this.table.schema, this.table.name, constraint.name)),
         ];
     }
-    serialize() {
+    serialize(_options) {
         return ["DROP TABLE", `${this.table.schema}.${this.table.name}`].join(" ");
     }
 }

package/dist/core/objects/table/changes/table.privilege.d.ts

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
 import type { Table } from "../table.model.ts";
 import { AlterTableChange } from "./table.base.ts";
 export type TablePrivilege = GrantTablePrivileges | RevokeTablePrivileges | RevokeGrantOptionTablePrivileges;
@@ -38,7 +39,7 @@ export declare class GrantTablePrivileges extends AlterTableChange {
     });
     get creates(): `acl:${string}::grantee:${string}`[];
     get requires(): (`role:${string}` | `table:${string}`)[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }
 /**
  * Revoke privileges on a table.
@@ -79,7 +80,7 @@ export declare class RevokeTablePrivileges extends AlterTableChange {
     });
     get drops(): `acl:${string}::grantee:${string}`[];
     get requires(): (`acl:${string}::grantee:${string}` | `role:${string}` | `table:${string}`)[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }
 /**
  * Revoke grant option for privileges on a table.
@@ -103,5 +104,5 @@ export declare class RevokeGrantOptionTablePrivileges extends AlterTableChange {
         version?: number;
     });
     get requires(): (`acl:${string}::grantee:${string}` | `role:${string}` | `table:${string}`)[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }

package/dist/core/objects/table/changes/table.privilege.js

@@ -37,7 +37,7 @@ export class GrantTablePrivileges extends AlterTableChange {
     get requires() {
         return [this.table.stableId, stableId.role(this.grantee)];
     }
-    serialize() {
+    serialize(_options) {
         const hasGrantable = this.privileges.some((p) => p.grantable);
         const hasBase = this.privileges.some((p) => !p.grantable);
         if (hasGrantable && hasBase) {
@@ -98,7 +98,7 @@ export class RevokeTablePrivileges extends AlterTableChange {
             stableId.role(this.grantee),
         ];
     }
-    serialize() {
+    serialize(_options) {
         const kindPrefix = getObjectKindPrefix("TABLE");
         const list = this.privileges.map((p) => p.privilege);
         const privSql = formatObjectPrivilegeList("TABLE", list, this.version);
@@ -138,7 +138,7 @@ export class RevokeGrantOptionTablePrivileges extends AlterTableChange {
             stableId.role(this.grantee),
         ];
     }
-    serialize() {
+    serialize(_options) {
         const kindPrefix = getObjectKindPrefix("TABLE");
         const privSql = formatObjectPrivilegeList("TABLE", this.privilegeNames, this.version);
         const tableName = `${this.table.schema}.${this.table.name}`;

package/dist/core/objects/table/changes/table.types.d.ts

@@ -3,4 +3,5 @@ import type { CommentTable } from "./table.comment.ts";
 import type { CreateTable } from "./table.create.ts";
 import type { DropTable } from "./table.drop.ts";
 import type { TablePrivilege } from "./table.privilege.ts";
+/** Union of all table-related change variants (`objectType: "table"`). @category Change Types */
 export type TableChange = AlterTable | CommentTable | CreateTable | DropTable | TablePrivilege;

package/dist/core/objects/table/table.diff.d.ts

@@ -1,5 +1,4 @@
-import type { DefaultPrivilegeState } from "../base.default-privileges.ts";
-import type { Role } from "../role/role.model.ts";
+import type { ObjectDiffContext } from "../diff-context.ts";
 import type { TableChange } from "./changes/table.types.ts";
 import { Table } from "./table.model.ts";
 /**
@@ -10,9 +9,4 @@ import { Table } from "./table.model.ts";
  * @param branch - The tables in the branch catalog.
  * @returns A list of changes to apply to main to make it match branch.
  */
-export declare function diffTables(ctx: {
-    version: number;
-    currentUser: string;
-    defaultPrivilegeState: DefaultPrivilegeState;
-    mainRoles: Record<string, Role>;
-}, main: Record<string, Table>, branch: Record<string, Table>): TableChange[];
+export declare function diffTables(ctx: Pick<ObjectDiffContext, "version" | "currentUser" | "defaultPrivilegeState">, main: Record<string, Table>, branch: Record<string, Table>): TableChange[];

package/dist/core/objects/table/table.diff.js

@@ -1,7 +1,7 @@
 import { diffObjects } from "../base.diff.js";
-import { diffPrivileges, groupPrivilegesByColumns, } from "../base.privilege-diff.js";
+import { diffPrivileges, emitColumnPrivilegeChanges, } from "../base.privilege-diff.js";
 import { deepEqual } from "../utils.js";
-import { AlterTableAddColumn, AlterTableAddConstraint, AlterTableAlterColumnDropDefault, AlterTableAlterColumnDropNotNull, AlterTableAlterColumnSetDefault, AlterTableAlterColumnSetNotNull, AlterTableAlterColumnType, AlterTableAttachPartition, AlterTableChangeOwner, AlterTableDetachPartition, AlterTableDisableRowLevelSecurity, AlterTableDropColumn, AlterTableDropConstraint, AlterTableEnableRowLevelSecurity, AlterTableForceRowLevelSecurity, AlterTableNoForceRowLevelSecurity, AlterTableResetStorageParams, AlterTableSetLogged, AlterTableSetReplicaIdentity, AlterTableSetStorageParams, AlterTableSetUnlogged, AlterTableValidateConstraint, } from "./changes/table.alter.js";
+import { AlterTableAddColumn, AlterTableAddConstraint, AlterTableAlterColumnAddIdentity, AlterTableAlterColumnDropDefault, AlterTableAlterColumnDropIdentity, AlterTableAlterColumnDropNotNull, AlterTableAlterColumnSetDefault, AlterTableAlterColumnSetGenerated, AlterTableAlterColumnSetNotNull, AlterTableAlterColumnType, AlterTableAttachPartition, AlterTableChangeOwner, AlterTableDetachPartition, AlterTableDisableRowLevelSecurity, AlterTableDropColumn, AlterTableDropConstraint, AlterTableEnableRowLevelSecurity, AlterTableForceRowLevelSecurity, AlterTableNoForceRowLevelSecurity, AlterTableResetStorageParams, AlterTableSetLogged, AlterTableSetReplicaIdentity, AlterTableSetStorageParams, AlterTableSetUnlogged, AlterTableValidateConstraint, } from "./changes/table.alter.js";
 import { CreateCommentOnColumn, CreateCommentOnConstraint, CreateCommentOnTable, DropCommentOnColumn, DropCommentOnConstraint, DropCommentOnTable, } from "./changes/table.comment.js";
 import { CreateTable } from "./changes/table.create.js";
 import { DropTable } from "./changes/table.drop.js";
@@ -66,6 +66,7 @@ function createAlterConstraintChange(mainTable, branchTable) {
             mainC.validated !== branchC.validated ||
             mainC.is_local !== branchC.is_local ||
             mainC.no_inherit !== branchC.no_inherit ||
+            mainC.is_temporal !== branchC.is_temporal ||
             JSON.stringify(mainC.key_columns) !==
                 JSON.stringify(branchC.key_columns) ||
             JSON.stringify(mainC.foreign_key_columns) !==
@@ -149,6 +150,16 @@ export function diffTables(ctx, main, branch) {
         if (branchTable.force_row_security) {
             changes.push(new AlterTableForceRowLevelSecurity({ table: branchTable }));
         }
+        // REPLICA IDENTITY: If non-default, emit ALTER TABLE ... REPLICA IDENTITY
+        if (branchTable.replica_identity !== "d") {
+            // Skip 'i' (USING INDEX) — handled by index changes
+            if (branchTable.replica_identity !== "i") {
+                changes.push(new AlterTableSetReplicaIdentity({
+                    table: branchTable,
+                    mode: branchTable.replica_identity,
+                }));
+            }
+        }
         changes.push(...createAlterConstraintChange(
         // Create a dummy table with no constraints do diff constraints against
         new Table({
@@ -171,86 +182,18 @@ export function diffTables(ctx, main, branch) {
         // We compare default privileges against desired privileges to generate REVOKE/GRANT statements
         // needed to reach the final desired state.
         const effectiveDefaults = ctx.defaultPrivilegeState.getEffectiveDefaults(ctx.currentUser, "table", branchTable.schema ?? "");
+        const creatorFilteredDefaults = branchTable.owner !== ctx.currentUser
+            ? effectiveDefaults.filter((p) => p.grantee !== ctx.currentUser)
+            : effectiveDefaults;
         const desiredPrivileges = branchTable.privileges;
         // Filter out owner privileges - owner always has ALL privileges implicitly
         // and shouldn't be compared. Use the table owner as the reference.
-        const privilegeResults = diffPrivileges(effectiveDefaults, desiredPrivileges, branchTable.owner, ctx.mainRoles);
-        // Generate grant changes
-        for (const [grantee, result] of privilegeResults) {
-            if (result.grants.length > 0) {
-                const grantGroups = groupPrivilegesByColumns(result.grants);
-                for (const [, group] of grantGroups) {
-                    for (const [grantable, privSet] of group.byGrant) {
-                        const privileges = Array.from(privSet).map((priv) => ({
-                            privilege: priv,
-                            grantable,
-                        }));
-                        changes.push(new GrantTablePrivileges({
-                            table: branchTable,
-                            grantee,
-                            privileges,
-                            columns: group.columns,
-                            version: ctx.version,
-                        }));
-                    }
-                }
-            }
-            // Generate revoke changes
-            if (result.revokes.length > 0) {
-                const revokeGroups = groupPrivilegesByColumns(result.revokes);
-                for (const [, group] of revokeGroups) {
-                    const allPrivileges = new Set();
-                    for (const [, privSet] of group.byGrant) {
-                        for (const priv of privSet) {
-                            allPrivileges.add(priv);
-                        }
-                    }
-                    const privileges = Array.from(allPrivileges).map((priv) => ({
-                        privilege: priv,
-                        grantable: false,
-                    }));
-                    changes.push(new RevokeTablePrivileges({
-                        table: branchTable,
-                        grantee,
-                        privileges,
-                        columns: group.columns,
-                        version: ctx.version,
-                    }));
-                }
-            }
-            // Generate revoke grant option changes
-            if (result.revokeGrantOption.length > 0) {
-                const revokeGrantGroups = new Map();
-                for (const r of result.revokeGrantOption) {
-                    const originalPriv = effectiveDefaults.find((p) => p.grantee === grantee && p.privilege === r);
-                    const key = originalPriv?.columns
-                        ? originalPriv.columns.sort().join(",")
-                        : "";
-                    if (!revokeGrantGroups.has(key)) {
-                        revokeGrantGroups.set(key, {
-                            columns: originalPriv?.columns
-                                ? [...originalPriv.columns]
-                                : undefined,
-                            privileges: new Set(),
-                        });
-                    }
-                    const group = revokeGrantGroups.get(key);
-                    if (!group)
-                        continue;
-                    group.privileges.add(r);
-                }
-                for (const [, group] of revokeGrantGroups) {
-                    const privilegeNames = Array.from(group.privileges);
-                    changes.push(new RevokeGrantOptionTablePrivileges({
-                        table: branchTable,
-                        grantee,
-                        privilegeNames,
-                        columns: group.columns,
-                        version: ctx.version,
-                    }));
-                }
-            }
-        }
+        const privilegeResults = diffPrivileges(creatorFilteredDefaults, desiredPrivileges, branchTable.owner);
+        changes.push(...emitColumnPrivilegeChanges(privilegeResults, branchTable, branchTable, "table", {
+            Grant: GrantTablePrivileges,
+            Revoke: RevokeTablePrivileges,
+            RevokeGrantOption: RevokeGrantOptionTablePrivileges,
+        }, effectiveDefaults, ctx.version));
     }
     for (const tableId of dropped) {
         changes.push(new DropTable({ table: main[tableId] }));
@@ -439,6 +382,17 @@ export function diffTables(ctx, main, branch) {
                         partitionNotNullChanged &&
                         parentBranchCol.not_null === branchCol.not_null);
                 }
+                case "identity": {
+                    const parentIdentityChanged = parentMainCol.is_identity !== parentBranchCol.is_identity ||
+                        parentMainCol.is_identity_always !==
+                            parentBranchCol.is_identity_always;
+                    const partitionIdentityChanged = mainCol.is_identity !== branchCol.is_identity ||
+                        mainCol.is_identity_always !== branchCol.is_identity_always;
+                    return (parentIdentityChanged &&
+                        partitionIdentityChanged &&
+                        parentBranchCol.is_identity === branchCol.is_identity &&
+                        parentBranchCol.is_identity_always === branchCol.is_identity_always);
+                }
             }
         };
         // Helper to check if parent has the same column add/drop
@@ -508,6 +462,16 @@ export function diffTables(ctx, main, branch) {
                     }));
                 }
             }
+            // PostgreSQL rejects SET DEFAULT while the column still has identity metadata,
+            // so identity removal must lead the IDENTITY -> serial/default transition.
+            if (mainCol.is_identity && !branchCol.is_identity) {
+                if (!parentHasSameColumnPropertyChange(name, "identity")) {
+                    changes.push(new AlterTableAlterColumnDropIdentity({
+                        table: branchTable,
+                        column: branchCol,
+                    }));
+                }
+            }
             // DEFAULT change
             if (mainCol.default !== branchCol.default) {
                 // Skip if parent has the same default change
@@ -523,9 +487,14 @@ export function diffTables(ctx, main, branch) {
                         // Set new default value
                         const isGeneratedColumn = branchCol.is_generated;
                         const isPostgresLowerThan17 = ctx.version < 170000;
-                        if (isGeneratedColumn && isPostgresLowerThan17) {
+                        const generatedStatusChanged = mainCol.is_generated !== branchCol.is_generated;
+                        if (isGeneratedColumn &&
+                            (isPostgresLowerThan17 || generatedStatusChanged)) {
                             // For generated columns in < PostgreSQL 17, we need to drop and recreate
-                            // instead of using SET EXPRESSION AS for computed columns
+                            // instead of using SET EXPRESSION AS for computed columns. We also
+                            // need to recreate the column when switching between regular and
+                            // generated states because SET EXPRESSION only applies to existing
+                            // generated columns.
                             // cf: https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=5d06e99a3
                             // cf: https://www.postgresql.org/docs/release/17.0/
                             // > Allow ALTER TABLE to change a column's generation expression
@@ -548,6 +517,30 @@ export function diffTables(ctx, main, branch) {
                     }
                 }
             }
+            // Serial-like defaults have to be cleared before ADD GENERATED AS IDENTITY,
+            // while mode-only flips stay in-place on an existing identity column.
+            if ((!mainCol.is_identity && branchCol.is_identity) ||
+                (mainCol.is_identity &&
+                    branchCol.is_identity &&
+                    mainCol.is_identity_always !== branchCol.is_identity_always)) {
+                // Skip if parent has the same identity change
+                if (!parentHasSameColumnPropertyChange(name, "identity")) {
+                    if (!mainCol.is_identity && branchCol.is_identity) {
+                        changes.push(new AlterTableAlterColumnAddIdentity({
+                            table: branchTable,
+                            column: branchCol,
+                        }));
+                    }
+                    else if (mainCol.is_identity &&
+                        branchCol.is_identity &&
+                        mainCol.is_identity_always !== branchCol.is_identity_always) {
+                        changes.push(new AlterTableAlterColumnSetGenerated({
+                            table: branchTable,
+                            column: branchCol,
+                        }));
+                    }
+                }
+            }
             // NOT NULL change
             if (mainCol.not_null !== branchCol.not_null) {
                 // Skip if parent has the same NOT NULL change
@@ -584,85 +577,12 @@ export function diffTables(ctx, main, branch) {
         // PRIVILEGES (unified object and column privileges)
         // Filter out owner privileges - owner always has ALL privileges implicitly
         // and shouldn't be compared. Use branch owner as the reference.
-        const privilegeResults = diffPrivileges(mainTable.privileges, branchTable.privileges, branchTable.owner, ctx.mainRoles);
-        for (const [grantee, result] of privilegeResults) {
-            // Generate grant changes
-            if (result.grants.length > 0) {
-                const grantGroups = groupPrivilegesByColumns(result.grants);
-                for (const [, group] of grantGroups) {
-                    for (const [grantable, privSet] of group.byGrant) {
-                        const privileges = Array.from(privSet).map((priv) => ({
-                            privilege: priv,
-                            grantable,
-                        }));
-                        changes.push(new GrantTablePrivileges({
-                            table: branchTable,
-                            grantee,
-                            privileges,
-                            columns: group.columns,
-                            version: ctx.version,
-                        }));
-                    }
-                }
-            }
-            // Generate revoke changes
-            if (result.revokes.length > 0) {
-                const revokeGroups = groupPrivilegesByColumns(result.revokes);
-                for (const [, group] of revokeGroups) {
-                    // Collapse all grantable groups into a single revoke (grantable: false)
-                    const allPrivileges = new Set();
-                    for (const [, privSet] of group.byGrant) {
-                        for (const priv of privSet) {
-                            allPrivileges.add(priv);
-                        }
-                    }
-                    const privileges = Array.from(allPrivileges).map((priv) => ({
-                        privilege: priv,
-                        grantable: false,
-                    }));
-                    changes.push(new RevokeTablePrivileges({
-                        table: mainTable,
-                        grantee,
-                        privileges,
-                        columns: group.columns,
-                        version: ctx.version,
-                    }));
-                }
-            }
-            // Generate revoke grant option changes
-            if (result.revokeGrantOption.length > 0) {
-                const revokeGrantGroups = new Map();
-                for (const r of result.revokeGrantOption) {
-                    // For revoke grant option, we need to find the columns from the original privilege
-                    const originalPriv = mainTable.privileges.find((p) => p.grantee === grantee && p.privilege === r);
-                    const key = originalPriv?.columns
-                        ? originalPriv.columns.sort().join(",")
-                        : "";
-                    if (!revokeGrantGroups.has(key)) {
-                        revokeGrantGroups.set(key, {
-                            columns: originalPriv?.columns
-                                ? [...originalPriv.columns]
-                                : undefined,
-                            privileges: new Set(),
-                        });
-                    }
-                    const group = revokeGrantGroups.get(key);
-                    if (!group)
-                        continue;
-                    group.privileges.add(r);
-                }
-                for (const [, group] of revokeGrantGroups) {
-                    const privilegeNames = Array.from(group.privileges);
-                    changes.push(new RevokeGrantOptionTablePrivileges({
-                        table: mainTable,
-                        grantee,
-                        privilegeNames,
-                        columns: group.columns,
-                        version: ctx.version,
-                    }));
-                }
-            }
-        }
+        const privilegeResults = diffPrivileges(mainTable.privileges, branchTable.privileges, branchTable.owner);
+        changes.push(...emitColumnPrivilegeChanges(privilegeResults, branchTable, mainTable, "table", {
+            Grant: GrantTablePrivileges,
+            Revoke: RevokeTablePrivileges,
+            RevokeGrantOption: RevokeGrantOptionTablePrivileges,
+        }, mainTable.privileges, ctx.version));
     }
     return changes;
 }