pg-migration-engine 0.1.0

package/src/introspection/queries/foreign-data.js

@@ -0,0 +1,136 @@
+const FDW_QUERY = `
+SELECT
+  f.oid,
+  f.fdwname AS name,
+  pg_catalog.pg_get_userbyid(f.fdwowner) AS owner,
+  f.fdwhandler::regproc::text AS handler,
+  f.fdwvalidator::regproc::text AS validator,
+  f.fdwoptions AS options,
+  f.fdwacl AS privileges,
+  pg_catalog.obj_description(f.oid, 'pg_foreign_data_wrapper') AS comment
+FROM pg_catalog.pg_foreign_data_wrapper f
+ORDER BY f.fdwname
+`;
+
+const FOREIGN_SERVERS_QUERY = `
+SELECT
+  s.oid,
+  s.srvname AS name,
+  pg_catalog.pg_get_userbyid(s.srvowner) AS owner,
+  s.srvtype AS type,
+  s.srvversion AS version,
+  f.fdwname AS fdw,
+  s.srvoptions AS options,
+  s.srvacl AS privileges,
+  pg_catalog.obj_description(s.oid, 'pg_foreign_server') AS comment
+FROM pg_catalog.pg_foreign_server s
+JOIN pg_catalog.pg_foreign_data_wrapper f ON f.oid = s.srvfdw
+ORDER BY s.srvname
+`;
+
+const USER_MAPPINGS_QUERY = `
+SELECT
+  u.oid,
+  pg_catalog.pg_get_userbyid(u.umuser) AS user,
+  s.srvname AS server,
+  u.umoptions AS options
+FROM pg_catalog.pg_user_mapping u
+JOIN pg_catalog.pg_foreign_server s ON s.oid = u.umserver
+ORDER BY s.srvname, u.umuser
+`;
+
+const FOREIGN_TABLES_QUERY = `
+SELECT
+  c.oid,
+  n.nspname AS schema,
+  c.relname AS name,
+  s.srvname AS server_name,
+  f.ftoptions AS options,
+  pg_catalog.obj_description(c.oid, 'pg_class') AS comment,
+  c.relacl AS privileges
+FROM pg_catalog.pg_foreign_table f
+JOIN pg_catalog.pg_class c ON c.oid = f.ftrelid
+JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+JOIN pg_catalog.pg_foreign_server s ON s.oid = f.ftserver
+WHERE n.nspname NOT IN ('pg_catalog', 'information_schema')
+  AND n.nspname NOT LIKE 'pg_temp_%'
+ORDER BY n.nspname, c.relname
+`;
+
+const FOREIGN_TABLE_COLUMNS_QUERY = `
+SELECT
+  n.nspname AS schema,
+  c.relname AS table_name,
+  a.attname AS column_name,
+  a.attfdwoptions AS options
+FROM pg_catalog.pg_attribute a
+JOIN pg_catalog.pg_class c ON c.oid = a.attrelid
+JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+JOIN pg_catalog.pg_foreign_table f ON f.ftrelid = c.oid
+WHERE a.attnum > 0 AND NOT a.attisdropped
+  AND a.attfdwoptions IS NOT NULL
+  AND n.nspname NOT IN ('pg_catalog', 'information_schema')
+  AND n.nspname NOT LIKE 'pg_temp_%'
+ORDER BY n.nspname, c.relname, a.attnum
+`;
+
+/**
+ * @param {import('pg').Pool} pool
+ * @returns {Promise<Array>}
+ */
+export async function queryForeignDataWrappers(pool) {
+  try {
+    const result = await pool.query(FDW_QUERY);
+    return result.rows;
+  } catch (error) {
+    return [];
+  }
+}
+
+/**
+ * @param {import('pg').Pool} pool
+ * @returns {Promise<Array>}
+ */
+export async function queryForeignServers(pool) {
+  try {
+    const result = await pool.query(FOREIGN_SERVERS_QUERY);
+    return result.rows;
+  } catch (error) {
+    return [];
+  }
+}
+
+/**
+ * @param {import('pg').Pool} pool
+ * @returns {Promise<Array>}
+ */
+export async function queryUserMappings(pool) {
+  try {
+    const result = await pool.query(USER_MAPPINGS_QUERY);
+    return result.rows;
+  } catch (error) {
+    return [];
+  }
+}
+
+/**
+ * @param {import('pg').Pool} pool
+ * @returns {Promise<{tables: Array, columnOptions: Array}>}
+ */
+export async function queryForeignTables(pool) {
+  try {
+    const tablesResult = await pool.query(FOREIGN_TABLES_QUERY);
+    let columnsResult = { rows: [] };
+    try {
+      columnsResult = await pool.query(FOREIGN_TABLE_COLUMNS_QUERY);
+    } catch (e) {
+      // Column options query may fail on older PG versions
+    }
+    return {
+      tables: tablesResult.rows,
+      columnOptions: columnsResult.rows,
+    };
+  } catch (error) {
+    return { tables: [], columnOptions: [] };
+  }
+}

package/src/introspection/queries/functions.js

@@ -0,0 +1,75 @@
+const FUNCTIONS_QUERY = `
+SELECT p.oid,
+       n.nspname AS schema,
+       p.proname AS name,
+       pg_catalog.pg_get_function_identity_arguments(p.oid) AS argument_types,
+       p.proargnames AS argument_names,
+       p.proargdefaults AS argument_defaults,
+       p.proargmodes AS argument_modes,
+       pg_catalog.pg_get_function_result(p.oid) AS return_type,
+       p.proretset AS return_set,
+       l.lanname AS language,
+       p.prosrc AS source,
+       p.probin AS precompiled_body,
+       CASE p.provolatile
+         WHEN 'i' THEN 'IMMUTABLE'
+         WHEN 's' THEN 'STABLE'
+         WHEN 'v' THEN 'VOLATILE'
+       END AS volatility,
+       p.proisstrict AS is_strict,
+       CASE p.prosecdef WHEN true THEN 'DEFINER' ELSE 'INVOKER' END AS security,
+       CASE p.proparallel
+         WHEN 's' THEN 'SAFE'
+         WHEN 'u' THEN 'UNSAFE'
+         WHEN 'r' THEN 'RESTRICTED'
+       END AS parallel,
+       p.proleakproof AS is_leakproof,
+       p.procost AS cost,
+       p.prorows AS rows,
+       CASE p.prokind
+         WHEN 'f' THEN 'FUNCTION'
+         WHEN 'p' THEN 'PROCEDURE'
+         WHEN 'a' THEN 'AGGREGATE'
+         WHEN 'w' THEN 'WINDOW'
+       END AS kind,
+       pg_catalog.pg_get_userbyid(p.proowner) AS owner,
+       p.proconfig AS configuration,
+       p.proacl AS privileges,
+       p.prosupport::regproc::text AS support_function,
+       pg_catalog.obj_description(p.oid, 'pg_proc') AS comment,
+       a.aggtransfn::text AS agg_sfunc,
+       a.aggfinalfn::text AS agg_finalfunc,
+       a.aggcombinefn::text AS agg_combinefunc,
+       a.aggtranstype::regtype::text AS agg_stype,
+       a.agginitval AS agg_initcond,
+       a.aggtransspace AS agg_sspace,
+       a.aggfinalextra AS agg_finalfunc_extra,
+       CASE a.aggfinalmodify
+         WHEN 'r' THEN 'READ_ONLY'
+         WHEN 's' THEN 'SHAREABLE'
+         WHEN 'w' THEN 'READ_WRITE'
+       END AS agg_finalfunc_modify,
+       a.aggserialfn::text AS agg_serialfunc,
+       a.aggdeserialfn::text AS agg_deserialfunc,
+       a.aggsortop::regoper::text AS agg_sortop,
+       CASE a.aggkind
+         WHEN 'n' THEN false
+         WHEN 'h' THEN true
+       END AS agg_hypothetical
+FROM pg_catalog.pg_proc p
+JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace
+JOIN pg_catalog.pg_language l ON l.oid = p.prolang
+LEFT JOIN pg_catalog.pg_aggregate a ON a.aggfnoid = p.oid
+WHERE n.nspname NOT IN ('pg_catalog', 'information_schema')
+  AND n.nspname NOT LIKE 'pg_temp_%'
+ORDER BY n.nspname, p.proname
+`;
+
+/**
+ * @param {import('pg').Pool} pool
+ * @returns {Promise<Array>}
+ */
+export async function queryFunctions(pool) {
+  const result = await pool.query(FUNCTIONS_QUERY);
+  return result.rows;
+}

package/src/introspection/queries/grants.js

@@ -0,0 +1,38 @@
+const GRANTS_QUERY = `
+SELECT n.nspname AS schema,
+       c.relname AS object,
+       CASE c.relkind
+         WHEN 'r' THEN 'TABLE'
+         WHEN 'p' THEN 'TABLE'
+         WHEN 'v' THEN 'VIEW'
+         WHEN 'm' THEN 'MATERIALIZED_VIEW'
+         WHEN 'S' THEN 'SEQUENCE'
+         WHEN 'f' THEN 'FOREIGN_TABLE'
+       END AS object_type,
+       a.grantee::regrole::text AS grantee,
+       a.grantor::regrole::text AS grantor,
+       a.privilege_type AS privilege,
+       a.is_grantable
+FROM pg_catalog.pg_class c
+JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+CROSS JOIN LATERAL aclexplode(
+  CASE c.relkind
+    WHEN 'S' THEN c.relacl
+    ELSE c.relacl
+  END
+) a
+WHERE c.relkind IN ('r', 'p', 'v', 'm', 'S', 'f')
+  AND n.nspname NOT IN ('pg_catalog', 'information_schema', 'pg_toast')
+  AND n.nspname NOT LIKE 'pg_temp_%'
+  AND a.grantee::regrole::text != a.grantor::regrole::text
+ORDER BY n.nspname, c.relname, a.grantee::regrole::text
+`;
+
+/**
+ * @param {import('pg').Pool} pool
+ * @returns {Promise<Array>}
+ */
+export async function queryGrants(pool) {
+  const result = await pool.query(GRANTS_QUERY);
+  return result.rows;
+}

package/src/introspection/queries/index.js

@@ -0,0 +1,33 @@
+export { querySchemas, queryTables, queryColumns, queryToastOptions } from './tables.js';
+export { queryConstraints } from './constraints.js';
+export { queryIndexes, queryIndexColumns } from './indexes.js';
+export { queryFunctions } from './functions.js';
+export { queryTriggers } from './triggers.js';
+export { queryTypes } from './types.js';
+export { queryViews } from './views.js';
+export { querySequences } from './sequences.js';
+export { queryPartitions } from './partitions.js';
+export { queryPolicies } from './policies.js';
+export { queryExtensions } from './extensions.js';
+export { queryInheritance } from './inheritance.js';
+export { queryComments } from './comments.js';
+export { queryGrants } from './grants.js';
+export { queryPg18Features } from './pg18-19.js';
+export { queryPublications } from './publications.js';
+export { querySubscriptions } from './subscriptions.js';
+export { queryStatistics } from './statistics.js';
+export { queryCollations } from './collations.js';
+export { queryConversions } from './conversions.js';
+export { queryOperators, queryOperatorClasses, queryOperatorFamilies } from './operators.js';
+export { queryTextSearchConfigs, queryTextSearchDictionaries, queryTextSearchParsers, queryTextSearchTemplates } from './text-search.js';
+export { queryForeignDataWrappers, queryForeignServers, queryUserMappings, queryForeignTables } from './foreign-data.js';
+export { queryCasts } from './casts.js';
+export { queryEventTriggers } from './event-triggers.js';
+export { queryRules } from './rules.js';
+export { queryRoles } from './roles.js';
+export { queryInterfaceTablespaces } from './tablespaces.js';
+export { queryInterfaceAccessMethods } from './access-methods.js';
+export { queryInterfaceDatabases } from './databases.js';
+export { queryDefaultPrivileges } from './default-privileges.js';
+export { queryProceduralLanguages } from './procedural-languages.js';
+export { queryMultiranges } from './multiranges.js';

package/src/introspection/queries/indexes.js

@@ -0,0 +1,99 @@
+const INDEXES_QUERY = `
+SELECT c.relname AS index_name,
+       n.nspname AS schema,
+       c.relname AS index_relname,
+       t.relname AS table_name,
+       tn.nspname AS table_schema,
+       c.relowner::regrole::text AS owner,
+       ix.indisunique AS is_unique,
+       ix.indisprimary AS is_primary,
+       am.amname AS method,
+       ix.indkey AS column_indices,
+       pg_catalog.pg_get_indexdef(ix.indexrelid) AS definition,
+       CASE WHEN ix.indpred IS NOT NULL THEN pg_catalog.pg_get_expr(ix.indpred, ix.indrelid) ELSE NULL END AS where_clause,
+       CASE WHEN c.reltablespace != 0 THEN (SELECT spcname FROM pg_catalog.pg_tablespace WHERE oid = c.reltablespace) ELSE NULL END AS tablespace,
+       c.reloptions AS storage_options,
+       pg_catalog.obj_description(ix.indexrelid, 'pg_class') AS comment,
+       ix.indisvalid AS is_valid,
+       ix.indisready AS is_ready,
+       ix.indislive AS is_live,
+       ix.indisreplident AS is_replica_identity,
+       ix.indisclustered AS is_clustered,
+       ix.indnkeyatts AS number_of_key_columns,
+       ix.indoption AS column_options,
+       (SELECT (regexp_matches(unnest_opt, 'pages_per_range=(\d+)'))[1]::int
+        FROM unnest(COALESCE(c.reloptions, ARRAY[]::text[])) AS unnest_opt
+        WHERE unnest_opt LIKE 'pages_per_range=%'
+        LIMIT 1
+       ) AS brin_pages_per_range
+FROM pg_catalog.pg_index ix
+JOIN pg_catalog.pg_class c ON c.oid = ix.indexrelid
+JOIN pg_catalog.pg_class t ON t.oid = ix.indrelid
+JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+JOIN pg_catalog.pg_namespace tn ON tn.oid = t.relnamespace
+JOIN pg_catalog.pg_am am ON am.oid = c.relam
+WHERE n.nspname NOT IN ('pg_catalog', 'information_schema', 'pg_toast')
+  AND n.nspname NOT LIKE 'pg_temp_%'
+ORDER BY tn.nspname, t.relname, c.relname
+`;
+
+
+const INDEX_COLUMNS_QUERY = `
+WITH index_keys AS (
+  SELECT 
+    i.indexrelid,
+    i.indrelid,
+    i.indkey,
+    i.indoption,
+    i.indcollation,
+    i.indclass,
+    i.indexprs,
+    t.idx,
+    t.ordinality,
+    t.ordinality - 1 AS idx_offset
+  FROM pg_catalog.pg_index i
+  CROSS JOIN LATERAL unnest(i.indkey) WITH ORDINALITY AS t(idx, ordinality)
+)
+SELECT 
+  ik.indexrelid::regclass::text AS index_name,
+  n.nspname AS schema,
+  c.relname AS index_relname,
+  ik.idx AS attnum,
+  CASE WHEN ik.idx = 0 THEN NULL ELSE a.attname END AS column_name,
+  ik.ordinality AS position,
+  COALESCE(coll.collname, NULL) AS collation,
+  COALESCE(opc.opcname, NULL) AS opclass,
+  CASE WHEN (ik.indoption[ik.idx_offset] & 1) = 1 THEN 'DESC' ELSE 'ASC' END AS direction,
+  CASE WHEN (ik.indoption[ik.idx_offset] & 2) = 2 THEN 'NULLS FIRST' ELSE 'NULLS LAST' END AS nulls_order,
+  pg_catalog.col_description(a.attrelid, a.attnum) AS column_comment,
+  CASE WHEN ik.idx = 0 AND ik.indexprs IS NOT NULL THEN
+    pg_catalog.pg_get_indexdef(ik.indexrelid, (ik.idx_offset + 1)::integer, true)
+  ELSE NULL END AS expression
+FROM index_keys ik
+JOIN pg_catalog.pg_class c ON c.oid = ik.indexrelid
+JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+LEFT JOIN pg_catalog.pg_attribute a ON a.attrelid = ik.indrelid AND a.attnum = ik.idx
+LEFT JOIN pg_catalog.pg_collation coll ON coll.oid = ik.indcollation[ik.idx_offset]
+LEFT JOIN pg_catalog.pg_opclass opc ON opc.oid = ik.indclass[ik.idx_offset]
+WHERE n.nspname NOT IN ('pg_catalog', 'information_schema', 'pg_toast')
+  AND n.nspname NOT LIKE 'pg_temp_%'
+ORDER BY n.nspname, c.relname, ik.ordinality
+`;
+
+/**
+ * @param {import('pg').Pool} pool
+ * @returns {Promise<Array>}
+ */
+export async function queryIndexes(pool) {
+  const result = await pool.query(INDEXES_QUERY);
+  return result.rows;
+}
+
+/**
+ * @param {import('pg').Pool} pool
+ * @returns {Promise<Array>}
+ */
+export async function queryIndexColumns(pool) {
+  const result = await pool.query(INDEX_COLUMNS_QUERY);
+  return result.rows;
+}

package/src/introspection/queries/inheritance.js

@@ -0,0 +1,24 @@
+const INHERITANCE_QUERY = `
+SELECT child.relname AS child_table,
+       cn.nspname AS child_schema,
+       parent.relname AS parent_table,
+       pn.nspname AS parent_schema
+FROM pg_catalog.pg_inherits i
+JOIN pg_catalog.pg_class child ON child.oid = i.inhrelid
+JOIN pg_catalog.pg_namespace cn ON cn.oid = child.relnamespace
+JOIN pg_catalog.pg_class parent ON parent.oid = i.inhparent
+JOIN pg_catalog.pg_namespace pn ON pn.oid = parent.relnamespace
+WHERE parent.relkind != 'p'
+  AND cn.nspname NOT IN ('pg_catalog', 'information_schema', 'pg_toast')
+  AND cn.nspname NOT LIKE 'pg_temp_%'
+ORDER BY cn.nspname, child.relname, pn.nspname, parent.relname
+`;
+
+/**
+ * @param {import('pg').Pool} pool
+ * @returns {Promise<Array>}
+ */
+export async function queryInheritance(pool) {
+  const result = await pool.query(INHERITANCE_QUERY);
+  return result.rows;
+}

package/src/introspection/queries/multiranges.js

@@ -0,0 +1,37 @@
+const MULTIRANGES_QUERY = `
+SELECT
+  t.oid,
+  n.nspname AS schema,
+  t.typname AS name,
+  pg_catalog.pg_get_userbyid(t.typowner) AS owner,
+  format_type(t.typbasetype, NULL) AS range_type,
+  pg_catalog.obj_description(t.oid, 'pg_type') AS comment
+FROM pg_catalog.pg_type t
+JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
+WHERE t.typtype = 'm'
+  AND n.nspname NOT IN ('pg_catalog', 'information_schema')
+ORDER BY n.nspname, t.typname
+`;
+
+/**
+ * @param {import('pg').Pool} pool
+ * @param {number} version
+ * @returns {Promise<Array>}
+ */
+export async function queryMultiranges(pool, version) {
+  if (version < 140000) return [];
+
+  try {
+    const result = await pool.query(MULTIRANGES_QUERY);
+    
+    return result.rows.map(row => ({
+      schema: row.schema,
+      name: row.name,
+      owner: row.owner,
+      range_type: row.range_type,
+      comment: row.comment || undefined,
+    }));
+  } catch (error) {
+    return [];
+  }
+}

package/src/introspection/queries/operators.js

@@ -0,0 +1,180 @@
+const OPERATORS_QUERY = `
+SELECT
+  o.oid,
+  n.nspname AS schema,
+  o.oprname AS name,
+  pg_catalog.pg_get_userbyid(o.oprowner) AS owner,
+  o.oprkind AS kind,
+  CASE WHEN o.oprleft = 0 THEN NULL ELSE format_type(o.oprleft, NULL) END AS left_type,
+  CASE WHEN o.oprright = 0 THEN NULL ELSE format_type(o.oprright, NULL) END AS right_type,
+  format_type(o.oprresult, NULL) AS result_type,
+  o.oprcode::regproc::text AS proc,
+  CASE WHEN o.oprcanhash THEN 'HASH' ELSE NULL END AS can_hash,
+  CASE WHEN o.oprcanmerge THEN 'MERGE' ELSE NULL END AS can_merge,
+  o.oprcom::regoper::text AS commutator,
+  o.oprnegate::regoper::text AS negator,
+  o.oprrest::regproc::text AS restrict_func,
+  o.oprjoin::regproc::text AS join_func,
+  pg_catalog.obj_description(o.oid, 'pg_operator') AS comment
+FROM pg_catalog.pg_operator o
+JOIN pg_catalog.pg_namespace n ON n.oid = o.oprnamespace
+WHERE n.nspname NOT IN ('pg_catalog', 'information_schema')
+ORDER BY n.nspname, o.oprname
+`;
+
+/**
+ * @param {import('pg').Pool} pool
+ * @returns {Promise<Array>}
+ */
+export async function queryOperators(pool) {
+  try {
+    const result = await pool.query(OPERATORS_QUERY);
+    
+    return result.rows.map(row => ({
+      schema: row.schema,
+      name: row.name,
+      owner: row.owner,
+      kind: row.kind,
+      left_type: row.left_type,
+      right_type: row.right_type,
+      result_type: row.result_type,
+      proc: row.proc,
+      can_hash: !!row.can_hash,
+      can_merge: !!row.can_merge,
+      commutator: row.commutator || undefined,
+      negator: row.negator || undefined,
+      restrict_function: row.restrict_func || undefined,
+      join_function: row.join_func || undefined,
+      comment: row.comment || undefined,
+    }));
+  } catch (error) {
+    return [];
+  }
+}
+
+/**
+ * @param {import('pg').Pool} pool
+ * @returns {Promise<Array>}
+ */
+export async function queryOperatorFamilies(pool) {
+  const OPERATOR_FAMILIES_QUERY = `
+    SELECT
+      of.oid,
+      n.nspname AS schema,
+      of.opfname AS name,
+      pg_catalog.pg_get_userbyid(of.opfowner) AS owner,
+      am.amname AS access_method
+    FROM pg_catalog.pg_opfamily of
+    JOIN pg_catalog.pg_namespace n ON n.oid = of.opfnamespace
+    JOIN pg_catalog.pg_am am ON am.oid = of.opfmethod
+    WHERE n.nspname NOT IN ('pg_catalog', 'information_schema')
+    ORDER BY n.nspname, of.opfname
+  `;
+
+  try {
+    const result = await pool.query(OPERATOR_FAMILIES_QUERY);
+    return result.rows;
+  } catch (error) {
+    return [];
+  }
+}
+
+/**
+ * @param {import('pg').Pool} pool
+ * @returns {Promise<Array>}
+ */
+export async function queryOperatorClasses(pool) {
+  const OPERATOR_CLASSES_QUERY = `
+    SELECT
+      oc.oid,
+      n.nspname AS schema,
+      oc.opcname AS name,
+      pg_catalog.pg_get_userbyid(oc.opcowner) AS owner,
+      of.opfname AS family,
+      format_type(oc.opcintype, NULL) AS input_type,
+      oc.opcdefault AS is_default,
+      am.amname AS access_method,
+      CASE WHEN oc.opckeytype = 0 THEN NULL ELSE format_type(oc.opckeytype, NULL) END AS storage_type,
+      pg_catalog.obj_description(oc.oid, 'pg_opclass') AS comment
+    FROM pg_catalog.pg_opclass oc
+    JOIN pg_catalog.pg_namespace n ON n.oid = oc.opcnamespace
+    JOIN pg_catalog.pg_opfamily of ON of.oid = oc.opcfamily
+    JOIN pg_catalog.pg_am am ON am.oid = oc.opcmethod
+    WHERE n.nspname NOT IN ('pg_catalog', 'information_schema')
+    ORDER BY n.nspname, oc.opcname
+  `;
+
+  const OPERATOR_CLASS_OPERATORS_QUERY = `
+    SELECT
+      n.nspname AS schema,
+      oc.opcname AS opclass_name,
+      ao.amopstrategy AS strategy,
+      CASE WHEN o.oprleft = 0 THEN NULL ELSE format_type(o.oprleft, NULL) END AS left_type,
+      CASE WHEN o.oprright = 0 THEN NULL ELSE format_type(o.oprright, NULL) END AS right_type,
+      o.oprname AS operator_name
+    FROM pg_catalog.pg_amop ao
+    JOIN pg_catalog.pg_opclass oc ON oc.oid = ao.amopfamily
+    JOIN pg_catalog.pg_namespace n ON n.oid = oc.opcnamespace
+    JOIN pg_catalog.pg_operator o ON o.oid = ao.amopopr
+    WHERE n.nspname NOT IN ('pg_catalog', 'information_schema')
+    ORDER BY n.nspname, oc.opcname, ao.amopstrategy
+  `;
+
+  const OPERATOR_CLASS_FUNCTIONS_QUERY = `
+    SELECT
+      n.nspname AS schema,
+      oc.opcname AS opclass_name,
+      ap.amprocnum AS support_num,
+      p.proname AS function_name
+    FROM pg_catalog.pg_amproc ap
+    JOIN pg_catalog.pg_opclass oc ON oc.oid = ap.amprocfamily
+    JOIN pg_catalog.pg_namespace n ON n.oid = oc.opcnamespace
+    JOIN pg_catalog.pg_proc p ON p.oid = ap.amproc
+    WHERE n.nspname NOT IN ('pg_catalog', 'information_schema')
+    ORDER BY n.nspname, oc.opcname, ap.amprocnum
+  `;
+
+  try {
+    const classesResult = await pool.query(OPERATOR_CLASSES_QUERY);
+    let opsResult = { rows: [] };
+    let funcsResult = { rows: [] };
+    
+    try {
+      opsResult = await pool.query(OPERATOR_CLASS_OPERATORS_QUERY);
+    } catch (e) {}
+    
+    try {
+      funcsResult = await pool.query(OPERATOR_CLASS_FUNCTIONS_QUERY);
+    } catch (e) {}
+
+    const operatorsMap = {};
+    for (const row of opsResult.rows) {
+      const key = `${row.schema}.${row.opclass_name}`;
+      if (!operatorsMap[key]) operatorsMap[key] = [];
+      operatorsMap[key].push({
+        strategy: row.strategy,
+        name: row.operator_name,
+        leftType: row.left_type,
+        rightType: row.right_type,
+      });
+    }
+
+    const functionsMap = {};
+    for (const row of funcsResult.rows) {
+      const key = `${row.schema}.${row.opclass_name}`;
+      if (!functionsMap[key]) functionsMap[key] = [];
+      functionsMap[key].push({
+        num: row.support_num,
+        name: row.function_name,
+      });
+    }
+
+    return classesResult.rows.map(row => ({
+      ...row,
+      operators: operatorsMap[`${row.schema}.${row.name}`] || [],
+      functions: functionsMap[`${row.schema}.${row.name}`] || [],
+    }));
+  } catch (error) {
+    return [];
+  }
+}

package/src/introspection/queries/partitions.js

@@ -0,0 +1,42 @@
+const PARTITIONS_QUERY = `
+SELECT parent.relname AS parent_table,
+       pn.nspname AS parent_schema,
+       child.relname AS child_table,
+       cn.nspname AS child_schema,
+       pt.partstrat AS strategy,
+       pt.partnatts AS num_columns,
+       array_agg(pa.attname ORDER BY array_position(pt.partattrs, pa.attnum)) AS partition_columns,
+       pg_catalog.pg_get_expr(child.relpartbound, child.oid) AS partition_bound,
+       child.relispartition AS is_partition,
+       COALESCE(
+         (SELECT true FROM pg_catalog.pg_partitioned_table cp WHERE cp.partrelid = child.oid),
+         false
+       ) AS is_default,
+       pg_catalog.pg_get_expr(pt.partexprs, pt.partrelid) AS partition_expression
+FROM pg_catalog.pg_inherits i
+JOIN pg_catalog.pg_class parent ON parent.oid = i.inhparent
+JOIN pg_catalog.pg_namespace pn ON pn.oid = parent.relnamespace
+JOIN pg_catalog.pg_class child ON child.oid = i.inhrelid
+JOIN pg_catalog.pg_namespace cn ON cn.oid = child.relnamespace
+JOIN pg_catalog.pg_partitioned_table pt ON pt.partrelid = parent.oid
+LEFT JOIN pg_catalog.pg_attribute pa ON pa.attrelid = parent.oid
+  AND pa.attnum = ANY(pt.partattrs)
+  AND pa.attnum > 0
+  AND NOT pa.attisdropped
+WHERE parent.relkind = 'p'
+  AND pn.nspname NOT IN ('pg_catalog', 'information_schema', 'pg_toast')
+  AND pn.nspname NOT LIKE 'pg_temp_%'
+GROUP BY parent.oid, parent.relname, pn.nspname,
+         child.oid, child.relname, cn.nspname,
+         pt.partstrat, pt.partnatts, child.relpartbound, child.relispartition, pt.partexprs
+ORDER BY pn.nspname, parent.relname, child.relname
+`;
+
+/**
+ * @param {import('pg').Pool} pool
+ * @returns {Promise<Array>}
+ */
+export async function queryPartitions(pool) {
+  const result = await pool.query(PARTITIONS_QUERY);
+  return result.rows;
+}