@supabase/pg-delta 0.0.0 → 1.0.0-alpha.0

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

@@ -0,0 +1,182 @@
+import { diffObjects } from "../base.diff.js";
+import { deepEqual, hasNonAlterableChanges } from "../utils.js";
+import { AlterIndexSetStatistics, AlterIndexSetStorageParams, AlterIndexSetTablespace, } from "./changes/index.alter.js";
+import { CreateCommentOnIndex, DropCommentOnIndex, } from "./changes/index.comment.js";
+import { CreateIndex } from "./changes/index.create.js";
+import { DropIndex } from "./changes/index.drop.js";
+/**
+ * Diff two sets of indexes from main and branch catalogs.
+ *
+ * @param main - The indexes in the main catalog.
+ * @param branch - The indexes in the branch catalog.
+ * @param branchIndexableObjects - Table-like objects (tables, materialized views) in branch.
+ * @returns A list of changes to apply to main to make it match branch.
+ */
+export function diffIndexes(main, branch, branchIndexableObjects) {
+    const { created, dropped, altered } = diffObjects(main, branch);
+    const changes = [];
+    for (const indexId of created) {
+        const index = branch[indexId];
+        // Skip constraint-owned or primary indexes; they are created by constraint DDL
+        if (index.is_owned_by_constraint || index.is_primary) {
+            continue;
+        }
+        // Skip index partitions - they are automatically created when the parent partitioned index is created
+        if (index.is_index_partition) {
+            continue;
+        }
+        changes.push(new CreateIndex({
+            index,
+            indexableObject: branchIndexableObjects[index.tableStableId],
+        }));
+        if (index.comment !== null) {
+            changes.push(new CreateCommentOnIndex({ index }));
+        }
+    }
+    for (const indexId of dropped) {
+        const index = main[indexId];
+        // Constraint-owned or primary indexes are handled by constraint/table drops
+        if (index.is_owned_by_constraint ||
+            index.is_primary ||
+            !branchIndexableObjects[index.tableStableId]) {
+            continue;
+        }
+        // Skip index partitions - they are automatically dropped when the parent partitioned index is dropped
+        if (index.is_index_partition) {
+            continue;
+        }
+        changes.push(new DropIndex({ index: main[indexId] }));
+    }
+    for (const indexId of altered) {
+        const mainIndex = main[indexId];
+        const branchIndex = branch[indexId];
+        // Constraint-owned or primary indexes are handled by constraint/table DDL
+        if (mainIndex.is_owned_by_constraint || mainIndex.is_primary) {
+            continue;
+        }
+        if (branchIndex.is_owned_by_constraint || branchIndex.is_primary) {
+            continue;
+        }
+        // Skip index partitions - they are automatically updated when the parent partitioned index is updated
+        if (mainIndex.is_index_partition || branchIndex.is_index_partition) {
+            continue;
+        }
+        // Check if non-alterable properties have changed
+        // These require dropping and recreating the index
+        // Note: key_columns is excluded because it contains attribute numbers that can differ
+        // between databases even when indexes are logically identical. The definition field
+        // already captures the logical structure using column names, so we compare by definition instead.
+        const NON_ALTERABLE_FIELDS = [
+            "index_type",
+            "is_unique",
+            "is_primary",
+            "is_exclusion",
+            "nulls_not_distinct",
+            "immediate",
+            "is_clustered",
+            "is_replica_identity",
+            "column_collations",
+            "operator_classes",
+            "column_options",
+            "index_expressions",
+            "partial_predicate",
+            "definition", // Compare by definition instead of key_columns
+        ];
+        const nonAlterablePropsChanged = hasNonAlterableChanges(mainIndex, branchIndex, NON_ALTERABLE_FIELDS, {
+            column_collations: deepEqual,
+            operator_classes: deepEqual,
+            column_options: deepEqual,
+            definition: (a, b) => {
+                // Normalize definitions by removing "USING btree" (default) for comparison
+                const normalize = (def) => def.replace(/\s+USING\s+btree/gi, "");
+                return normalize(a) === normalize(b);
+            },
+        });
+        if (nonAlterablePropsChanged) {
+            // Replace the entire index (drop + create)
+            changes.push(new DropIndex({ index: mainIndex }), new CreateIndex({
+                index: branchIndex,
+                indexableObject: branchIndexableObjects[branchIndex.tableStableId],
+            }));
+        }
+        else {
+            // Only alterable properties changed - check each one
+            // STORAGE PARAMS
+            if (JSON.stringify(mainIndex.storage_params) !==
+                JSON.stringify(branchIndex.storage_params)) {
+                const parseOptions = (options) => {
+                    const map = new Map();
+                    for (const opt of options) {
+                        const eqIndex = opt.indexOf("=");
+                        const key = opt.slice(0, eqIndex);
+                        const value = opt.slice(eqIndex + 1);
+                        map.set(key, value);
+                    }
+                    return map;
+                };
+                const mainMap = parseOptions(mainIndex.storage_params);
+                const branchMap = parseOptions(branchIndex.storage_params);
+                const keysToReset = [];
+                for (const key of mainMap.keys()) {
+                    if (!branchMap.has(key)) {
+                        keysToReset.push(key);
+                    }
+                }
+                const paramsToSet = [];
+                for (const [key, newValue] of branchMap.entries()) {
+                    const oldValue = mainMap.get(key);
+                    const changed = oldValue !== newValue;
+                    if (changed) {
+                        paramsToSet.push(`${key}=${newValue}`);
+                    }
+                }
+                changes.push(new AlterIndexSetStorageParams({
+                    index: mainIndex,
+                    paramsToSet,
+                    keysToReset,
+                }));
+            }
+            // STATISTICS TARGET
+            if (JSON.stringify(mainIndex.statistics_target) !==
+                JSON.stringify(branchIndex.statistics_target)) {
+                const columnTargets = [];
+                const mainTargets = mainIndex.statistics_target;
+                const branchTargets = branchIndex.statistics_target;
+                const length = Math.max(mainTargets.length, branchTargets.length);
+                for (let i = 0; i < length; i++) {
+                    const oldVal = mainTargets[i];
+                    const newVal = branchTargets[i];
+                    if (oldVal !== newVal && newVal !== undefined) {
+                        columnTargets.push({ columnNumber: i + 1, statistics: newVal });
+                    }
+                }
+                if (columnTargets.length > 0) {
+                    changes.push(new AlterIndexSetStatistics({ index: mainIndex, columnTargets }));
+                }
+            }
+            // TABLESPACE
+            if (mainIndex.tablespace !== branchIndex.tablespace) {
+                const nextTablespace = branchIndex.tablespace;
+                if (nextTablespace !== null) {
+                    changes.push(new AlterIndexSetTablespace({
+                        index: mainIndex,
+                        tablespace: nextTablespace,
+                    }));
+                }
+            }
+            // COMMENT
+            if (mainIndex.comment !== branchIndex.comment) {
+                if (branchIndex.comment === null) {
+                    changes.push(new DropCommentOnIndex({ index: mainIndex }));
+                }
+                else {
+                    changes.push(new CreateCommentOnIndex({ index: branchIndex }));
+                }
+            }
+            // Note: Index renaming would also use ALTER INDEX ... RENAME TO ...
+            // But since our Index model uses 'name' as the identity field,
+            // a name change would be handled as drop + create by diffObjects()
+        }
+    }
+    return changes;
+}

package/dist/core/objects/index/index.model.d.ts

@@ -0,0 +1,150 @@
+import type { Sql } from "postgres";
+import z from "zod";
+import { BasePgModel } from "../base.model.ts";
+declare const indexPropsSchema: z.ZodObject<{
+    schema: z.ZodString;
+    table_name: z.ZodString;
+    name: z.ZodString;
+    storage_params: z.ZodArray<z.ZodString>;
+    statistics_target: z.ZodArray<z.ZodNumber>;
+    index_type: z.ZodString;
+    tablespace: z.ZodNullable<z.ZodString>;
+    is_unique: z.ZodBoolean;
+    is_primary: z.ZodBoolean;
+    is_exclusion: z.ZodBoolean;
+    nulls_not_distinct: z.ZodBoolean;
+    immediate: z.ZodBoolean;
+    is_clustered: z.ZodBoolean;
+    is_replica_identity: z.ZodBoolean;
+    key_columns: z.ZodArray<z.ZodNumber>;
+    column_collations: z.ZodArray<z.ZodString>;
+    operator_classes: z.ZodArray<z.ZodString>;
+    column_options: z.ZodArray<z.ZodNumber>;
+    index_expressions: z.ZodNullable<z.ZodString>;
+    partial_predicate: z.ZodNullable<z.ZodString>;
+    is_owned_by_constraint: z.ZodBoolean;
+    table_relkind: z.ZodEnum<{
+        r: "r";
+        m: "m";
+        p: "p";
+    }>;
+    is_partitioned_index: z.ZodBoolean;
+    is_index_partition: z.ZodBoolean;
+    parent_index_name: z.ZodNullable<z.ZodString>;
+    definition: z.ZodString;
+    comment: z.ZodNullable<z.ZodString>;
+    owner: z.ZodString;
+}, z.z.core.$strip>;
+/**
+ * All properties exposed by CREATE INDEX statement are included in diff output.
+ * https://www.postgresql.org/docs/current/sql-createindex.html
+ *
+ * ALTER INDEX statement can only be generated for a subset of properties:
+ *  - name, storage param, statistics, tablespace, attach partition
+ * https://www.postgresql.org/docs/current/sql-alterindex.html
+ *
+ * Unsupported alter properties include
+ *  - depends on extension (all extension dependencies are excluded)
+ *
+ * Other properties require dropping and creating a new index.
+ */
+export type IndexProps = z.infer<typeof indexPropsSchema>;
+export declare class Index extends BasePgModel {
+    readonly schema: IndexProps["schema"];
+    readonly table_name: IndexProps["table_name"];
+    readonly name: IndexProps["name"];
+    readonly storage_params: IndexProps["storage_params"];
+    readonly statistics_target: IndexProps["statistics_target"];
+    readonly index_type: IndexProps["index_type"];
+    readonly tablespace: IndexProps["tablespace"];
+    readonly is_unique: IndexProps["is_unique"];
+    readonly is_primary: IndexProps["is_primary"];
+    readonly is_exclusion: IndexProps["is_exclusion"];
+    readonly nulls_not_distinct: IndexProps["nulls_not_distinct"];
+    readonly immediate: IndexProps["immediate"];
+    readonly is_clustered: IndexProps["is_clustered"];
+    readonly is_replica_identity: IndexProps["is_replica_identity"];
+    readonly key_columns: IndexProps["key_columns"];
+    readonly column_collations: IndexProps["column_collations"];
+    readonly operator_classes: IndexProps["operator_classes"];
+    readonly column_options: IndexProps["column_options"];
+    readonly index_expressions: IndexProps["index_expressions"];
+    readonly partial_predicate: IndexProps["partial_predicate"];
+    readonly table_relkind: IndexProps["table_relkind"];
+    readonly is_owned_by_constraint: IndexProps["is_owned_by_constraint"];
+    readonly is_partitioned_index: IndexProps["is_partitioned_index"];
+    readonly is_index_partition: IndexProps["is_index_partition"];
+    readonly parent_index_name: IndexProps["parent_index_name"];
+    readonly definition: IndexProps["definition"];
+    readonly comment: IndexProps["comment"];
+    readonly owner: IndexProps["owner"];
+    constructor(props: IndexProps);
+    get stableId(): `index:${string}`;
+    get tableStableId(): `table:${string}` | `materializedView:${string}`;
+    get identityFields(): {
+        schema: string;
+        table_name: string;
+        name: string;
+    };
+    get dataFields(): {
+        storage_params: string[];
+        statistics_target: number[];
+        index_type: string;
+        tablespace: string | null;
+        is_unique: boolean;
+        is_primary: boolean;
+        is_exclusion: boolean;
+        nulls_not_distinct: boolean;
+        immediate: boolean;
+        is_clustered: boolean;
+        is_replica_identity: boolean;
+        column_collations: string[];
+        operator_classes: string[];
+        column_options: number[];
+        index_expressions: string | null;
+        partial_predicate: string | null;
+        table_relkind: "r" | "m" | "p";
+        is_owned_by_constraint: boolean;
+        is_partitioned_index: boolean;
+        is_index_partition: boolean;
+        parent_index_name: string | null;
+        definition: string;
+        comment: string | null;
+        owner: string;
+    };
+    stableSnapshot(): {
+        identity: {
+            schema: string;
+            table_name: string;
+            name: string;
+        };
+        data: {
+            statistics_target: unknown;
+            column_options: unknown;
+            column_collations: unknown;
+            operator_classes: unknown;
+            storage_params: string[];
+            index_type: string;
+            tablespace: string | null;
+            is_unique: boolean;
+            is_primary: boolean;
+            is_exclusion: boolean;
+            nulls_not_distinct: boolean;
+            immediate: boolean;
+            is_clustered: boolean;
+            is_replica_identity: boolean;
+            index_expressions: string | null;
+            partial_predicate: string | null;
+            table_relkind: "r" | "m" | "p";
+            is_owned_by_constraint: boolean;
+            is_partitioned_index: boolean;
+            is_index_partition: boolean;
+            parent_index_name: string | null;
+            definition: string;
+            comment: string | null;
+            owner: string;
+        };
+    };
+}
+export declare function extractIndexes(sql: Sql): Promise<Index[]>;
+export {};

package/dist/core/objects/index/index.model.js

@@ -0,0 +1,340 @@
+import z from "zod";
+import { BasePgModel } from "../base.model.js";
+const TableRelkindSchema = z.enum([
+    "r", // table (regular relation)
+    "m", // materialized view
+    "p", // partitioned table
+]);
+const indexPropsSchema = z.object({
+    schema: z.string(),
+    table_name: z.string(),
+    name: z.string(),
+    storage_params: z.array(z.string()),
+    statistics_target: z.array(z.number()),
+    index_type: z.string(),
+    tablespace: z.string().nullable(),
+    is_unique: z.boolean(),
+    is_primary: z.boolean(),
+    is_exclusion: z.boolean(),
+    nulls_not_distinct: z.boolean(),
+    immediate: z.boolean(),
+    is_clustered: z.boolean(),
+    is_replica_identity: z.boolean(),
+    key_columns: z.array(z.number()),
+    column_collations: z.array(z.string()),
+    operator_classes: z.array(z.string()),
+    column_options: z.array(z.number()),
+    index_expressions: z.string().nullable(),
+    partial_predicate: z.string().nullable(),
+    is_owned_by_constraint: z.boolean(),
+    table_relkind: TableRelkindSchema, // 'r' for table, 'm' for materialized view
+    is_partitioned_index: z.boolean(),
+    is_index_partition: z.boolean(),
+    parent_index_name: z.string().nullable(),
+    definition: z.string(),
+    comment: z.string().nullable(),
+    owner: z.string(),
+});
+export class Index extends BasePgModel {
+    schema;
+    table_name;
+    name;
+    storage_params;
+    statistics_target;
+    index_type;
+    tablespace;
+    is_unique;
+    is_primary;
+    is_exclusion;
+    nulls_not_distinct;
+    immediate;
+    is_clustered;
+    is_replica_identity;
+    key_columns;
+    column_collations;
+    operator_classes;
+    column_options;
+    index_expressions;
+    partial_predicate;
+    table_relkind;
+    is_owned_by_constraint;
+    is_partitioned_index;
+    is_index_partition;
+    parent_index_name;
+    definition;
+    comment;
+    owner;
+    constructor(props) {
+        super();
+        // Identity fields
+        this.schema = props.schema;
+        this.table_name = props.table_name;
+        this.name = props.name;
+        // Data fields
+        this.storage_params = props.storage_params;
+        this.statistics_target = props.statistics_target;
+        this.index_type = props.index_type;
+        this.tablespace = props.tablespace;
+        this.is_unique = props.is_unique;
+        this.is_primary = props.is_primary;
+        this.is_exclusion = props.is_exclusion;
+        this.nulls_not_distinct = props.nulls_not_distinct;
+        this.immediate = props.immediate;
+        this.is_clustered = props.is_clustered;
+        this.is_replica_identity = props.is_replica_identity;
+        this.key_columns = props.key_columns;
+        this.column_collations = props.column_collations;
+        this.operator_classes = props.operator_classes;
+        this.column_options = props.column_options;
+        this.index_expressions = props.index_expressions;
+        this.partial_predicate = props.partial_predicate;
+        this.table_relkind = props.table_relkind;
+        this.is_owned_by_constraint = props.is_owned_by_constraint;
+        this.is_partitioned_index = props.is_partitioned_index;
+        this.is_index_partition = props.is_index_partition;
+        this.parent_index_name = props.parent_index_name;
+        this.definition = props.definition;
+        this.comment = props.comment;
+        this.owner = props.owner;
+    }
+    get stableId() {
+        return `index:${this.schema}.${this.table_name}.${this.name}`;
+    }
+    get tableStableId() {
+        // Materialized views use a different stableId prefix
+        if (this.table_relkind === "m") {
+            return `materializedView:${this.schema}.${this.table_name}`;
+        }
+        return `table:${this.schema}.${this.table_name}`;
+    }
+    get identityFields() {
+        return {
+            schema: this.schema,
+            table_name: this.table_name,
+            name: this.name,
+        };
+    }
+    get dataFields() {
+        return {
+            storage_params: this.storage_params,
+            statistics_target: this.statistics_target,
+            index_type: this.index_type,
+            tablespace: this.tablespace,
+            is_unique: this.is_unique,
+            is_primary: this.is_primary,
+            is_exclusion: this.is_exclusion,
+            nulls_not_distinct: this.nulls_not_distinct,
+            immediate: this.immediate,
+            is_clustered: this.is_clustered,
+            is_replica_identity: this.is_replica_identity,
+            // key_columns excluded: contains attribute numbers that can differ between databases
+            // even when indexes are logically identical. The definition field already captures
+            // the logical structure using column names, so we compare by definition instead.
+            column_collations: this.column_collations,
+            operator_classes: this.operator_classes,
+            column_options: this.column_options,
+            index_expressions: this.index_expressions,
+            partial_predicate: this.partial_predicate,
+            table_relkind: this.table_relkind,
+            is_owned_by_constraint: this.is_owned_by_constraint,
+            is_partitioned_index: this.is_partitioned_index,
+            is_index_partition: this.is_index_partition,
+            parent_index_name: this.parent_index_name,
+            definition: this.definition,
+            comment: this.comment,
+            owner: this.owner,
+        };
+    }
+    stableSnapshot() {
+        const normalizeArray = (arr) => {
+            if (!Array.isArray(arr))
+                return arr;
+            return [...arr].map((v) => normalizeValue(v));
+        };
+        const normalizeValue = (v) => {
+            if (Array.isArray(v))
+                return normalizeArray(v);
+            if (v && typeof v === "object") {
+                return Object.fromEntries(Object.entries(v).map(([k, val]) => [
+                    k,
+                    normalizeValue(val),
+                ]));
+            }
+            return v;
+        };
+        return {
+            identity: this.identityFields,
+            data: {
+                ...this.dataFields,
+                statistics_target: normalizeArray(this.statistics_target),
+                column_options: normalizeArray(this.column_options),
+                column_collations: normalizeArray(this.column_collations),
+                operator_classes: normalizeArray(this.operator_classes),
+            },
+        };
+    }
+}
+export async function extractIndexes(sql) {
+    return sql.begin(async (sql) => {
+        await sql `set search_path = ''`;
+        const indexRows = await sql `
+      with extension_oids as (
+        select objid
+        from pg_depend d
+        where d.refclassid = 'pg_extension'::regclass
+          and d.classid   = 'pg_class'::regclass
+      ),
+      -- align every per-column array by ordinality (1..indnatts)
+      -- this is used to ensure that key_columns, column_collations, operator_classes, and column_options are aligned
+      idx_cols as (
+        select
+          i.indexrelid,
+          i.indrelid,
+          k.ord,
+          k.attnum,
+          -- collation: only for key cols; 0 for none/default
+          case when k.ord <= i.indnkeyatts then coalesce(coll.oid, 0) else 0 end as coll_oid,
+          -- opclass: one per column
+          coalesce(cls.oid, 0) as cls_oid,
+          -- options: only for key cols; 0 for include cols
+          case when k.ord <= i.indnkeyatts then coalesce(opt.val, 0) else 0 end::int2 as indopt
+        from pg_index i
+        join lateral unnest(i.indkey) with ordinality as k(attnum, ord) on true
+        left join lateral unnest(i.indcollation) with ordinality as coll(oid, ordc) on ordc = k.ord
+        left join lateral unnest(i.indclass)     with ordinality as cls(oid, ordo) on ordo = k.ord
+        left join lateral unnest(i.indoption)    with ordinality as opt(val, ordi) on ordi = k.ord
+      )
+      select
+        c.relnamespace::regnamespace::text as schema,
+        quote_ident(tc.relname)            as table_name,
+        tc.relkind                         as table_relkind,
+        quote_ident(c.relname)             as name,
+        coalesce(c.reloptions, array[]::text[]) as storage_params,
+        am.amname                          as index_type,
+        quote_ident(ts.spcname)            as tablespace,
+        i.indisunique                      as is_unique,
+        i.indisprimary                     as is_primary,
+        i.indisexclusion                   as is_exclusion,
+        i.indnullsnotdistinct              as nulls_not_distinct,
+        i.indimmediate                     as immediate,
+        i.indisclustered                   as is_clustered,
+        i.indisreplident                   as is_replica_identity,
+        i.indkey                           as key_columns,
+
+        -- NEW: partitioned-index / index-partition tagging
+        (c.relkind = 'I')                  as is_partitioned_index,
+        (parent_idx.oid is not null)       as is_index_partition,
+        case
+          when parent_idx.oid is not null then
+            quote_ident(parent_idx_ns.nspname) || '.' || quote_ident(parent_idx.relname)
+        end                                as parent_index_name,
+
+        -- Foreign keys don’t create/own an index; their conindid points to the referenced PK/UNIQUE index.
+        -- Mark as is_owned_by_constraint only when the owning constraint is PK/UNIQUE/EXCLUSION.
+        exists (
+          select 1
+          from pg_depend d
+          join pg_constraint pc on pc.oid = d.refobjid
+          where d.classid    = 'pg_class'::regclass
+            and d.objid      = i.indexrelid
+            and d.refclassid = 'pg_constraint'::regclass
+            and d.deptype    = 'i'
+            and pc.contype   in ('p','u','x')
+        ) as is_owned_by_constraint,
+
+        -- per-column arrays from one pass over idx_cols
+        coalesce(agg.column_collations, array[]::text[]) as column_collations,
+        coalesce(agg.operator_classes, array[]::text[])  as operator_classes,
+        coalesce(agg.column_options,   array[]::int2[])  as column_options,
+
+        -- always an array (possibly empty), ordered by index attnum
+        coalesce(st.statistics_target, array[]::int4[])  as statistics_target,
+
+        pg_get_expr(i.indexprs, i.indrelid) as index_expressions,
+        pg_get_expr(i.indpred,  i.indrelid) as partial_predicate,
+        pg_get_indexdef(i.indexrelid, 0, true) as definition,
+        obj_description(c.oid, 'pg_class') as comment,
+        c.relowner::regrole::text as owner
+
+      from pg_index i
+      join pg_class c  on c.oid  = i.indexrelid
+      join pg_class tc on tc.oid = i.indrelid
+      join pg_am am    on am.oid = c.relam
+      left join pg_tablespace ts on ts.oid = c.reltablespace
+      left join extension_oids e  on c.oid = e.objid
+      left join extension_oids e_table on tc.oid = e_table.objid
+
+      -- NEW: detect whether this index is an attached partition of a partitioned index
+      left join pg_inherits inh_idx
+        on inh_idx.inhrelid = c.oid
+      left join pg_class parent_idx
+        on parent_idx.oid = inh_idx.inhparent
+      left join pg_namespace parent_idx_ns
+        on parent_idx_ns.oid = parent_idx.relnamespace
+
+      -- single lateral aggregate keeps order by ic2.ord
+      left join lateral (
+        select
+          array_agg(
+            case
+              when ic2.coll_oid = 0 then null
+              when col.collname = 'default'
+                and col.collnamespace = 'pg_catalog'::regnamespace then null
+              else quote_ident(ns_coll.nspname) || '.' || quote_ident(col.collname)
+            end
+            order by ic2.ord
+          ) as column_collations,
+
+          -- 'default' when the AM's default opclass applies to the column's base type
+          array_agg(
+            case
+              when oc.oid is null then 'default'
+              when ic2.attnum = 0 then oc.opcnamespace::regnamespace::text || '.' || quote_ident(oc.opcname) -- expression key: no column type
+              -- in the case where the opclass is the default for the column's base type
+              when oc.opcdefault and (
+                (case when t.typtype = 'd' then t.typbasetype else a.atttypid end) = oc.opcintype
+                or exists (
+                  select 1
+                  from pg_catalog.pg_cast pc
+                  where pc.castsource = (case when t.typtype = 'd' then t.typbasetype else a.atttypid end)
+                    and pc.casttarget = oc.opcintype
+                    and pc.castcontext = 'i'  -- implicit
+                )
+              )
+              then 'default'
+              else oc.opcnamespace::regnamespace::text || '.' || quote_ident(oc.opcname)
+            end
+            order by ic2.ord
+          ) as operator_classes,
+
+          array_agg(coalesce(ic2.indopt, 0)::int2 order by ic2.ord) as column_options
+
+        from idx_cols ic2
+        left join pg_collation  col     on col.oid = ic2.coll_oid
+        left join pg_namespace  ns_coll on ns_coll.oid = col.collnamespace
+        left join pg_opclass    oc      on oc.oid = ic2.cls_oid
+        -- base type for the underlying column (domain -> base); NULL for expressions
+        left join pg_attribute  a       on a.attrelid = ic2.indrelid and a.attnum = ic2.attnum
+        left join pg_type       t       on t.oid = a.atttypid
+        where ic2.indexrelid = i.indexrelid
+      ) as agg on true
+
+      left join lateral (
+        select array_agg(coalesce(a2.attstattarget, -1) order by a2.attnum) as statistics_target
+        from pg_attribute a2
+        where a2.attrelid = i.indexrelid
+          and a2.attnum > 0
+      ) as st on true
+
+      where not c.relnamespace::regnamespace::text like any(array['pg\\_%', 'information\\_schema'])
+        and i.indislive is true
+        and e.objid is null
+        and e_table.objid is null
+
+      order by 1, 2;
+    `;
+        // Validate and parse each row using the Zod schema
+        const validatedRows = indexRows.map((row) => indexPropsSchema.parse(row));
+        return validatedRows.map((row) => new Index(row));
+    });
+}