relq 1.0.2 → 1.0.4

package/dist/esm/cli/utils/schema-comparator.js

@@ -1,14 +1,18 @@
 import { createChange } from "./change-tracker.js";
+function arraysEqual(a, b) {
+    if (a.length !== b.length)
+        return false;
+    return a.every((val, idx) => val === b[idx]);
+}
 export function compareSchemas(before, after) {
     const changes = [];
     changes.push(...compareExtensions(before.extensions || [], after.extensions || []));
     changes.push(...compareEnums(before.enums || [], after.enums || []));
     changes.push(...compareDomains(before.domains || [], after.domains || []));
     changes.push(...compareCompositeTypes(before.compositeTypes || [], after.compositeTypes || []));
+    changes.push(...compareSequences(before.sequences || [], after.sequences || []));
     changes.push(...compareTables(before.tables, after.tables));
-    const beforeViews = before.views || [];
-    const afterViews = after.views || [];
-    changes.push(...compareViews(beforeViews, afterViews));
+    changes.push(...compareViews(before.views || [], after.views || []));
     changes.push(...compareFunctions(before.functions || [], after.functions || []));
     changes.push(...compareTriggers(before.triggers || [], after.triggers || []));
     return changes;
@@ -98,6 +102,38 @@ function compareCompositeTypes(before, after) {
     }
     return changes;
 }
+function compareSequences(before, after) {
+    const changes = [];
+    const beforeMap = new Map(before.map(s => [s.name, s]));
+    const afterMap = new Map(after.map(s => [s.name, s]));
+    for (const [name, seq] of afterMap) {
+        if (!beforeMap.has(name)) {
+            changes.push(createChange('CREATE', 'SEQUENCE', name, null, seq));
+        }
+        else {
+            const beforeSeq = beforeMap.get(name);
+            if (hasSequenceChanged(beforeSeq, seq)) {
+                changes.push(createChange('ALTER', 'SEQUENCE', name, beforeSeq, seq));
+            }
+        }
+    }
+    for (const [name, seq] of beforeMap) {
+        if (!afterMap.has(name)) {
+            changes.push(createChange('DROP', 'SEQUENCE', name, seq, null));
+        }
+    }
+    return changes;
+}
+function hasSequenceChanged(before, after) {
+    return (before.dataType !== after.dataType ||
+        before.start !== after.start ||
+        before.increment !== after.increment ||
+        before.minValue !== after.minValue ||
+        before.maxValue !== after.maxValue ||
+        before.cache !== after.cache ||
+        before.cycle !== after.cycle ||
+        before.ownedBy !== after.ownedBy);
+}
 function compareTables(before, after) {
     const changes = [];
     const beforeMap = new Map(before.map(t => [t.name, t]));
@@ -105,12 +141,57 @@ function compareTables(before, after) {
     for (const [name, table] of afterMap) {
         if (!beforeMap.has(name)) {
             changes.push(createChange('CREATE', 'TABLE', name, null, tableToChangeData(table)));
+            const tableIndexes = table.indexes || [];
+            for (const idx of tableIndexes) {
+                if (!idx.isPrimary) {
+                    changes.push(createChange('CREATE', 'INDEX', idx.name, null, {
+                        name: idx.name,
+                        tableName: name,
+                        columns: Array.isArray(idx.columns) ? idx.columns : [idx.columns],
+                        isUnique: idx.isUnique,
+                        type: idx.type,
+                    }));
+                }
+            }
+            if (table.isPartitioned && table.partitionType && table.partitionKey) {
+                changes.push(createChange('CREATE', 'PARTITION', name, null, {
+                    tableName: name,
+                    type: table.partitionType,
+                    key: table.partitionKey,
+                }));
+                const childPartitions = table.childPartitions || [];
+                for (const cp of childPartitions) {
+                    changes.push(createChange('CREATE', 'PARTITION_CHILD', cp.name, null, {
+                        name: cp.name,
+                        parentTable: name,
+                        bound: cp.partitionBound,
+                    }, name));
+                }
+            }
+            if (table.comment) {
+                changes.push(createChange('CREATE', 'TABLE_COMMENT', name, null, {
+                    tableName: name,
+                    comment: table.comment,
+                }, name));
+            }
+            for (const col of table.columns) {
+                if (col.comment) {
+                    changes.push(createChange('CREATE', 'COLUMN_COMMENT', col.name, null, {
+                        tableName: name,
+                        columnName: col.name,
+                        comment: col.comment,
+                    }, name));
+                }
+            }
         }
         else {
             const beforeTable = beforeMap.get(name);
             changes.push(...compareColumns(beforeTable.columns, table.columns, name));
             changes.push(...compareIndexes(beforeTable.indexes || [], table.indexes || [], name));
             changes.push(...compareConstraints(beforeTable.constraints || [], table.constraints || [], name));
+            changes.push(...compareTableComments(beforeTable, table, name));
+            changes.push(...compareColumnComments(beforeTable.columns, table.columns, name));
+            changes.push(...comparePartitions(beforeTable, table, name));
         }
     }
     for (const [name, table] of beforeMap) {
@@ -176,10 +257,65 @@ function columnToChangeData(col) {
         scale: col.scale,
     };
 }
+function normalizeDataType(type) {
+    if (!type)
+        return '';
+    let normalized = type.toLowerCase().trim();
+    const typeMap = {
+        'int4': 'integer',
+        'int8': 'bigint',
+        'int2': 'smallint',
+        'float4': 'real',
+        'float8': 'double precision',
+        'bool': 'boolean',
+        'timestamptz': 'timestamp',
+        'timetz': 'time',
+        '_text': 'text[]',
+        '_int4': 'integer[]',
+        '_int8': 'bigint[]',
+        '_varchar': 'varchar[]',
+        '_uuid': 'uuid[]',
+        '_bool': 'boolean[]',
+        '_jsonb': 'jsonb[]',
+        'character varying': 'varchar',
+        'character': 'char',
+        'double precision': 'doubleprecision',
+    };
+    if (normalized.startsWith('_') && !typeMap[normalized]) {
+        return normalized.substring(1) + '[]';
+    }
+    return typeMap[normalized] || normalized;
+}
+function normalizeDefault(value) {
+    if (value == null)
+        return null;
+    let normalized = value.trim().toLowerCase();
+    normalized = normalized.replace(/array\[\]::([\w\[\]]+)/gi, "'empty_array'");
+    normalized = normalized.replace(/::\w+(?:\s+\w+)?(?:\[\])?/g, '');
+    normalized = normalized.replace(/^array\[\]$/i, "'empty_array'");
+    normalized = normalized.replace(/now\s*\(\s*\)/g, 'now()');
+    normalized = normalized.replace(/gen_random_uuid\s*\(\s*\)/g, 'gen_random_uuid()');
+    normalized = normalized.replace(/current_date/g, 'current_date');
+    normalized = normalized.replace(/current_timestamp/g, 'current_timestamp');
+    normalized = normalized.replace(/'\[\]'/g, "'empty_array'");
+    normalized = normalized.replace(/'\{\}'/g, "'empty_array'");
+    normalized = normalized.replace(/:\s+/g, ':');
+    normalized = normalized.replace(/,\s+/g, ',');
+    normalized = normalized.replace(/\[\s+/g, '[');
+    normalized = normalized.replace(/\s+\]/g, ']');
+    normalized = normalized.replace(/\{\s+/g, '{');
+    normalized = normalized.replace(/\s+\}/g, '}');
+    if (normalized === 'true' || normalized === "'t'" || normalized === 't')
+        normalized = 'true';
+    if (normalized === 'false' || normalized === "'f'" || normalized === 'f')
+        normalized = 'false';
+    normalized = normalized.replace(/^'([^']*)'$/, '$1');
+    return normalized || null;
+}
 function hasColumnChanged(before, after) {
-    return (before.dataType.toLowerCase() !== after.dataType.toLowerCase() ||
+    return (normalizeDataType(before.dataType) !== normalizeDataType(after.dataType) ||
         before.isNullable !== after.isNullable ||
-        before.defaultValue !== after.defaultValue ||
+        normalizeDefault(before.defaultValue) !== normalizeDefault(after.defaultValue) ||
         before.isPrimaryKey !== after.isPrimaryKey ||
         before.isUnique !== after.isUnique);
 }
@@ -211,10 +347,14 @@ function compareIndexes(before, after, tableName) {
 }
 function compareConstraints(before, after, tableName) {
     const changes = [];
-    const beforeMap = new Map(before.map(c => [c.name, c]));
-    const afterMap = new Map(after.map(c => [c.name, c]));
-    for (const [name, con] of afterMap) {
-        if (!beforeMap.has(name)) {
+    const beforeChecks = before.filter(c => c.type?.toUpperCase() === 'CHECK');
+    const afterChecks = after.filter(c => c.type?.toUpperCase() === 'CHECK');
+    const beforeOther = before.filter(c => c.type?.toUpperCase() !== 'CHECK');
+    const afterOther = after.filter(c => c.type?.toUpperCase() !== 'CHECK');
+    const beforeOtherMap = new Map(beforeOther.map(c => [c.name, c]));
+    const afterOtherMap = new Map(afterOther.map(c => [c.name, c]));
+    for (const [name, con] of afterOtherMap) {
+        if (!beforeOtherMap.has(name)) {
             const objectType = constraintTypeToObjectType(con.type);
             changes.push(createChange('CREATE', objectType, name, null, {
                 name: con.name,
@@ -222,8 +362,8 @@ function compareConstraints(before, after, tableName) {
             }, tableName));
         }
     }
-    for (const [name, con] of beforeMap) {
-        if (!afterMap.has(name)) {
+    for (const [name, con] of beforeOtherMap) {
+        if (!afterOtherMap.has(name)) {
             const objectType = constraintTypeToObjectType(con.type);
             changes.push(createChange('DROP', objectType, name, {
                 name: con.name,
@@ -231,6 +371,59 @@ function compareConstraints(before, after, tableName) {
             }, null, tableName));
         }
     }
+    const extractColumnFromCheckDef = (definition) => {
+        const enumMatch = definition.match(/\((\w+)\)::text\s*=\s*ANY/i);
+        if (enumMatch)
+            return enumMatch[1].toLowerCase();
+        const compMatch = definition.match(/\(\(?(\w+)\s*(?:>=?|<=?|<>|!=|=)/i);
+        if (compMatch)
+            return compMatch[1].toLowerCase();
+        return null;
+    };
+    const extractColumnFromCheckName = (name, tableName) => {
+        const lower = name.toLowerCase();
+        const tablePrefix = tableName.toLowerCase() + '_';
+        let colPart = lower.startsWith(tablePrefix) ? lower.slice(tablePrefix.length) : lower;
+        if (colPart.startsWith('check_'))
+            colPart = colPart.slice(6);
+        if (colPart.endsWith('_check'))
+            colPart = colPart.slice(0, -6);
+        return colPart;
+    };
+    const beforeChecksByCol = new Map();
+    const afterChecksByCol = new Map();
+    for (const c of beforeChecks) {
+        const col = extractColumnFromCheckDef(c.definition) || extractColumnFromCheckName(c.name, tableName);
+        beforeChecksByCol.set(col, c);
+    }
+    for (const c of afterChecks) {
+        const col = extractColumnFromCheckDef(c.definition) || extractColumnFromCheckName(c.name, tableName);
+        afterChecksByCol.set(col, c);
+    }
+    const matchedBefore = new Set();
+    const matchedAfter = new Set();
+    for (const [col, afterCon] of afterChecksByCol) {
+        if (beforeChecksByCol.has(col)) {
+            matchedBefore.add(beforeChecksByCol.get(col).name);
+            matchedAfter.add(afterCon.name);
+        }
+    }
+    for (const c of afterChecks) {
+        if (!matchedAfter.has(c.name)) {
+            changes.push(createChange('CREATE', 'CHECK', c.name, null, {
+                name: c.name,
+                definition: c.definition,
+            }, tableName));
+        }
+    }
+    for (const c of beforeChecks) {
+        if (!matchedBefore.has(c.name)) {
+            changes.push(createChange('DROP', 'CHECK', c.name, {
+                name: c.name,
+                definition: c.definition,
+            }, null, tableName));
+        }
+    }
     return changes;
 }
 function constraintTypeToObjectType(type) {
@@ -245,6 +438,103 @@ function constraintTypeToObjectType(type) {
         return 'EXCLUSION';
     return 'CONSTRAINT';
 }
+function compareTableComments(before, after, tableName) {
+    const changes = [];
+    const beforeComment = before.comment;
+    const afterComment = after.comment;
+    if (afterComment && !beforeComment) {
+        changes.push(createChange('CREATE', 'TABLE_COMMENT', tableName, null, {
+            tableName,
+            comment: afterComment,
+        }, tableName));
+    }
+    else if (!afterComment && beforeComment) {
+        changes.push(createChange('DROP', 'TABLE_COMMENT', tableName, {
+            tableName,
+            comment: beforeComment,
+        }, null, tableName));
+    }
+    else if (afterComment && beforeComment && afterComment !== beforeComment) {
+        changes.push(createChange('ALTER', 'TABLE_COMMENT', tableName, {
+            tableName,
+            comment: beforeComment,
+        }, {
+            tableName,
+            comment: afterComment,
+        }, tableName));
+    }
+    return changes;
+}
+function compareColumnComments(before, after, tableName) {
+    const changes = [];
+    const beforeMap = new Map(before.map(c => [c.name, c]));
+    const afterMap = new Map(after.map(c => [c.name, c]));
+    for (const [name, col] of afterMap) {
+        const afterComment = col.comment;
+        const beforeCol = beforeMap.get(name);
+        const beforeComment = beforeCol ? beforeCol.comment : undefined;
+        if (afterComment && !beforeComment) {
+            changes.push(createChange('CREATE', 'COLUMN_COMMENT', name, null, {
+                tableName,
+                columnName: name,
+                comment: afterComment,
+            }, tableName));
+        }
+        else if (!afterComment && beforeComment) {
+            changes.push(createChange('DROP', 'COLUMN_COMMENT', name, {
+                tableName,
+                columnName: name,
+                comment: beforeComment,
+            }, null, tableName));
+        }
+        else if (afterComment && beforeComment && afterComment !== beforeComment) {
+            changes.push(createChange('ALTER', 'COLUMN_COMMENT', name, {
+                tableName,
+                columnName: name,
+                comment: beforeComment,
+            }, {
+                tableName,
+                columnName: name,
+                comment: afterComment,
+            }, tableName));
+        }
+    }
+    return changes;
+}
+function comparePartitions(before, after, tableName) {
+    const changes = [];
+    const beforePartitioned = before.isPartitioned;
+    const afterPartitioned = after.isPartitioned;
+    if (afterPartitioned && !beforePartitioned) {
+        changes.push(createChange('CREATE', 'PARTITION', tableName, null, {
+            tableName,
+            type: after.partitionType,
+            key: after.partitionKey,
+        }));
+    }
+    else if (!afterPartitioned && beforePartitioned) {
+        changes.push(createChange('DROP', 'PARTITION', tableName, {
+            tableName,
+            type: before.partitionType,
+            key: before.partitionKey,
+        }, null));
+    }
+    else if (afterPartitioned && beforePartitioned) {
+        const keysMatch = arraysEqual(before.partitionKey || [], after.partitionKey || []);
+        if (before.partitionType !== after.partitionType || !keysMatch) {
+            changes.push(createChange('ALTER', 'PARTITION', tableName, {
+                tableName,
+                type: before.partitionType,
+                key: before.partitionKey,
+            }, {
+                tableName,
+                type: after.partitionType,
+                key: after.partitionKey,
+            }));
+        }
+    }
+    return changes;
+}
 function compareViews(before, after) {
     const changes = [];
     const beforeMap = new Map(before.map(v => [v.name, v]));

package/dist/esm/cli/utils/schema-diff.js

@@ -1,4 +1,203 @@
 import { colors } from "./spinner.js";
+const TYPE_ALIASES = {
+    'int': 'integer',
+    'int2': 'smallint',
+    'int4': 'integer',
+    'int8': 'bigint',
+    'integer': 'integer',
+    'smallint': 'smallint',
+    'bigint': 'bigint',
+    'serial': 'serial',
+    'serial2': 'smallserial',
+    'serial4': 'serial',
+    'serial8': 'bigserial',
+    'smallserial': 'smallserial',
+    'bigserial': 'bigserial',
+    'float': 'double precision',
+    'float4': 'real',
+    'float8': 'double precision',
+    'real': 'real',
+    'double precision': 'double precision',
+    'decimal': 'numeric',
+    'numeric': 'numeric',
+    'bool': 'boolean',
+    'boolean': 'boolean',
+    'char': 'character',
+    'character': 'character',
+    'bpchar': 'character',
+    'varchar': 'character varying',
+    'character varying': 'character varying',
+    'text': 'text',
+    'name': 'name',
+    'citext': 'citext',
+    'timestamp': 'timestamp without time zone',
+    'timestamp without time zone': 'timestamp without time zone',
+    'timestamptz': 'timestamp with time zone',
+    'timestamp with time zone': 'timestamp with time zone',
+    'date': 'date',
+    'time': 'time without time zone',
+    'time without time zone': 'time without time zone',
+    'timetz': 'time with time zone',
+    'time with time zone': 'time with time zone',
+    'interval': 'interval',
+    'abstime': 'abstime',
+    'reltime': 'reltime',
+    'tinterval': 'tinterval',
+    'bytea': 'bytea',
+    'bit': 'bit',
+    'varbit': 'bit varying',
+    'bit varying': 'bit varying',
+    'uuid': 'uuid',
+    'json': 'json',
+    'jsonb': 'jsonb',
+    'jsonpath': 'jsonpath',
+    'xml': 'xml',
+    'money': 'money',
+    'inet': 'inet',
+    'cidr': 'cidr',
+    'macaddr': 'macaddr',
+    'macaddr8': 'macaddr8',
+    'point': 'point',
+    'line': 'line',
+    'lseg': 'lseg',
+    'box': 'box',
+    'path': 'path',
+    'polygon': 'polygon',
+    'circle': 'circle',
+    'int4range': 'int4range',
+    'int8range': 'int8range',
+    'numrange': 'numrange',
+    'tsrange': 'tsrange',
+    'tstzrange': 'tstzrange',
+    'daterange': 'daterange',
+    'int4multirange': 'int4multirange',
+    'int8multirange': 'int8multirange',
+    'nummultirange': 'nummultirange',
+    'tsmultirange': 'tsmultirange',
+    'tstzmultirange': 'tstzmultirange',
+    'datemultirange': 'datemultirange',
+    'tsvector': 'tsvector',
+    'tsquery': 'tsquery',
+    'gtsvector': 'gtsvector',
+    'oid': 'oid',
+    'regclass': 'regclass',
+    'regcollation': 'regcollation',
+    'regconfig': 'regconfig',
+    'regdictionary': 'regdictionary',
+    'regnamespace': 'regnamespace',
+    'regoper': 'regoper',
+    'regoperator': 'regoperator',
+    'regproc': 'regproc',
+    'regprocedure': 'regprocedure',
+    'regrole': 'regrole',
+    'regtype': 'regtype',
+    'xid': 'xid',
+    'xid8': 'xid8',
+    'cid': 'cid',
+    'tid': 'tid',
+    'aclitem': 'aclitem',
+    'smgr': 'smgr',
+    'unknown': 'unknown',
+    'internal': 'internal',
+    'opaque': 'opaque',
+    'anyelement': 'anyelement',
+    'anyarray': 'anyarray',
+    'anynonarray': 'anynonarray',
+    'anyenum': 'anyenum',
+    'anyrange': 'anyrange',
+    'anymultirange': 'anymultirange',
+    'anycompatible': 'anycompatible',
+    'anycompatiblearray': 'anycompatiblearray',
+    'anycompatiblenonarray': 'anycompatiblenonarray',
+    'anycompatiblerange': 'anycompatiblerange',
+    'anycompatiblemultirange': 'anycompatiblemultirange',
+    'cstring': 'cstring',
+    'record': 'record',
+    'trigger': 'trigger',
+    'event_trigger': 'event_trigger',
+    'pg_lsn': 'pg_lsn',
+    'pg_snapshot': 'pg_snapshot',
+    'txid_snapshot': 'txid_snapshot',
+    'fdw_handler': 'fdw_handler',
+    'index_am_handler': 'index_am_handler',
+    'tsm_handler': 'tsm_handler',
+    'table_am_handler': 'table_am_handler',
+    'language_handler': 'language_handler',
+    'void': 'void',
+    'refcursor': 'refcursor',
+    '_int2': 'smallint[]',
+    '_int4': 'integer[]',
+    '_int8': 'bigint[]',
+    '_float4': 'real[]',
+    '_float8': 'double precision[]',
+    '_numeric': 'numeric[]',
+    '_bool': 'boolean[]',
+    '_text': 'text[]',
+    '_varchar': 'character varying[]',
+    '_bpchar': 'character[]',
+    '_char': 'character[]',
+    '_name': 'name[]',
+    '_bytea': 'bytea[]',
+    '_bit': 'bit[]',
+    '_varbit': 'bit varying[]',
+    '_uuid': 'uuid[]',
+    '_json': 'json[]',
+    '_jsonb': 'jsonb[]',
+    '_xml': 'xml[]',
+    '_money': 'money[]',
+    '_timestamp': 'timestamp without time zone[]',
+    '_timestamptz': 'timestamp with time zone[]',
+    '_date': 'date[]',
+    '_time': 'time without time zone[]',
+    '_timetz': 'time with time zone[]',
+    '_interval': 'interval[]',
+    '_inet': 'inet[]',
+    '_cidr': 'cidr[]',
+    '_macaddr': 'macaddr[]',
+    '_macaddr8': 'macaddr8[]',
+    '_point': 'point[]',
+    '_line': 'line[]',
+    '_lseg': 'lseg[]',
+    '_box': 'box[]',
+    '_path': 'path[]',
+    '_polygon': 'polygon[]',
+    '_circle': 'circle[]',
+    '_int4range': 'int4range[]',
+    '_int8range': 'int8range[]',
+    '_numrange': 'numrange[]',
+    '_tsrange': 'tsrange[]',
+    '_tstzrange': 'tstzrange[]',
+    '_daterange': 'daterange[]',
+    '_tsvector': 'tsvector[]',
+    '_tsquery': 'tsquery[]',
+    '_oid': 'oid[]',
+    '_regclass': 'regclass[]',
+    '_regtype': 'regtype[]',
+    '_regproc': 'regproc[]',
+    '_xid': 'xid[]',
+    '_cid': 'cid[]',
+    '_tid': 'tid[]',
+    '_aclitem': 'aclitem[]',
+    '_cstring': 'cstring[]',
+    '_record': 'record[]',
+    '_pg_lsn': 'pg_lsn[]',
+    '_txid_snapshot': 'txid_snapshot[]',
+    '_refcursor': 'refcursor[]',
+    '_citext': 'citext[]',
+};
+function normalizeType(type) {
+    if (!type)
+        return type;
+    let normalized = type.toLowerCase().trim();
+    if (TYPE_ALIASES[normalized]) {
+        return TYPE_ALIASES[normalized];
+    }
+    normalized = normalized.replace(' without time zone', '');
+    if (TYPE_ALIASES[normalized]) {
+        return TYPE_ALIASES[normalized];
+    }
+    return normalized;
+}
 export function diffSchemas(local, remote) {
     const tables = diffTables(local.tables, remote.tables);
     const extensions = diffExtensions(local.extensions, remote.extensions);
@@ -75,7 +274,9 @@ function diffColumns(local, remote) {
 }
 function compareColumns(local, remote) {
     const changes = [];
-    if (local.type !== remote.type) {
+    const localType = normalizeType(local.type);
+    const remoteType = normalizeType(remote.type);
+    if (localType !== remoteType) {
         changes.push({ field: 'type', from: local.type, to: remote.type });
     }
     if (local.nullable !== remote.nullable) {

package/dist/esm/cli/utils/schema-hash.js

@@ -23,8 +23,9 @@ function normalizeTable(table) {
         columns,
         indexes,
         constraints,
+        isPartitioned: table.isPartitioned,
         partitionType: table.partitionType,
-        partitionKey: table.partitionKey?.sort(),
+        partitionKey: table.partitionKey ? [...table.partitionKey] : undefined,
     };
 }
 function normalizeColumn(col) {

package/dist/esm/cli/utils/schema-introspect.js

@@ -31,7 +31,7 @@ export async function introspectDatabase(connection, onProgress, options) {
             WHERE n.nspname = 'public' AND c.relispartition = true;
         `);
         const partitionTableNames = new Set(partitionNamesResult.rows.map((r) => r.name));
-        const nonPartitionTables = tablesResult.rows.filter((r) => !partitionTableNames.has(r.table_name) && !r.table_name.startsWith('_relq'));
+        const nonPartitionTables = tablesResult.rows.filter((r) => !partitionTableNames.has(r.table_name) && !r.table_name.startsWith('_relq') && !r.table_name.startsWith('_kuery'));
         const totalTables = nonPartitionTables.length;
         let tableIndex = 0;
         for (let i = 0; i < tablesResult.rows.length; i++) {
@@ -39,9 +39,12 @@ export async function introspectDatabase(connection, onProgress, options) {
             const tableName = row.table_name;
             const tableSchema = row.table_schema;
             const rowCount = parseInt(row.row_count) || 0;
+            const isInternal = tableName.startsWith('_relq') || tableName.startsWith('_kuery');
+            if (isInternal) {
+                continue;
+            }
             const isPartition = partitionTableNames.has(tableName);
-            const isInternal = tableName.startsWith('_relq');
-            if (!isPartition && !isInternal) {
+            if (!isPartition) {
                 tableIndex++;
                 onProgress?.('parsing_table', `${tableName} (${tableIndex}/${totalTables})`);
             }
@@ -371,6 +374,7 @@ export async function introspectDatabase(connection, onProgress, options) {
             domains: [],
             compositeTypes: [],
             sequences: [],
+            collations: [],
             functions,
             triggers,
             policies,

package/dist/esm/cli/utils/snapshot-manager.js

@@ -101,6 +101,7 @@ export function snapshotToDatabaseSchema(snapshot) {
         domains: [],
         compositeTypes: [],
         sequences: [],
+        collations: [],
         functions: [],
         triggers: [],
         policies: [],