neon 8.4.5 → 8.6.0

package/dist/vendor/postgres-meta/lib/sql/functions.sql.js

@@ -0,0 +1,141 @@
+//#region src/vendor/postgres-meta/lib/sql/functions.sql.ts
+const FUNCTIONS_SQL = (props) => `
+-- CTE with sane arg_modes, arg_names, and arg_types.
+-- All three are always of the same length.
+-- All three include all args, including OUT and TABLE args.
+with functions as (
+  select
+    p.*,
+    -- proargmodes is null when all arg modes are IN
+    coalesce(
+      p.proargmodes,
+      array_fill('i'::text, array[cardinality(coalesce(p.proallargtypes, p.proargtypes))])
+    ) as arg_modes,
+    -- proargnames is null when all args are unnamed
+    coalesce(
+      p.proargnames,
+      array_fill(''::text, array[cardinality(coalesce(p.proallargtypes, p.proargtypes))])
+    ) as arg_names,
+    -- proallargtypes is null when all arg modes are IN
+    coalesce(p.proallargtypes, p.proargtypes) as arg_types,
+    array_cat(
+      array_fill(false, array[pronargs - pronargdefaults]),
+      array_fill(true, array[pronargdefaults])) as arg_has_defaults
+  from
+    pg_proc as p
+    ${props.schemaFilter ? `join pg_namespace n on p.pronamespace = n.oid` : ""}
+  where
+    ${props.schemaFilter ? `n.nspname ${props.schemaFilter} AND` : ""}
+    ${props.idsFilter ? `p.oid ${props.idsFilter} AND` : ""}
+    ${props.nameFilter ? `p.proname ${props.nameFilter} AND` : ""}
+    ${props.args === void 0 ? "" : props.args.length > 0 ? `p.proargtypes::text = ${props.args.length ? `(
+          SELECT STRING_AGG(type_oid::text, ' ') FROM (
+            SELECT (
+              split_args.arr[
+                array_length(
+                  split_args.arr,
+                  1
+                )
+              ]::regtype::oid
+            ) AS type_oid FROM (
+              SELECT STRING_TO_ARRAY(
+                UNNEST(
+                  ARRAY[${props.args}]
+                ),
+                ' '
+              ) AS arr
+            ) AS split_args
+          ) args
+    )` : "''"} AND` : ""}
+    p.prokind = 'f'
+)
+select
+  f.oid::int8 as id,
+  n.nspname as schema,
+  f.proname as name,
+  l.lanname as language,
+  case
+    when l.lanname = 'internal' then ''
+    else f.prosrc
+  end as definition,
+  case
+    when l.lanname = 'internal' then f.prosrc
+    else pg_get_functiondef(f.oid)
+  end as complete_statement,
+  coalesce(f_args.args, '[]') as args,
+  pg_get_function_arguments(f.oid) as argument_types,
+  pg_get_function_identity_arguments(f.oid) as identity_argument_types,
+  f.prorettype::int8 as return_type_id,
+  pg_get_function_result(f.oid) as return_type,
+  nullif(rt.typrelid::int8, 0) as return_type_relation_id,
+  f.proretset as is_set_returning_function,
+  case
+    when f.proretset then nullif(f.prorows, 0)
+    else null
+  end as prorows,
+  case
+    when f.provolatile = 'i' then 'IMMUTABLE'
+    when f.provolatile = 's' then 'STABLE'
+    when f.provolatile = 'v' then 'VOLATILE'
+  end as behavior,
+  f.prosecdef as security_definer,
+  f_config.config_params as config_params
+from
+  functions f
+  left join pg_namespace n on f.pronamespace = n.oid
+  left join pg_language l on f.prolang = l.oid
+  left join pg_type rt on rt.oid = f.prorettype
+  left join (
+    select
+      oid,
+      jsonb_object_agg(param, value) filter (where param is not null) as config_params
+    from
+      (
+        select
+          oid,
+          (string_to_array(unnest(proconfig), '='))[1] as param,
+          (string_to_array(unnest(proconfig), '='))[2] as value
+        from
+          functions
+      ) as t
+    group by
+      oid
+  ) f_config on f_config.oid = f.oid
+  left join (
+    select
+      oid,
+      jsonb_agg(jsonb_build_object(
+        'mode', t2.mode,
+        'name', name,
+        'type_id', type_id,
+        'has_default', has_default
+      )) as args
+    from
+      (
+        select
+          oid,
+          unnest(arg_modes) as mode,
+          unnest(arg_names) as name,
+          unnest(arg_types)::int8 as type_id,
+          unnest(arg_has_defaults) as has_default
+        from
+          functions
+      ) as t1,
+      lateral (
+        select
+          case
+            when t1.mode = 'i' then 'in'
+            when t1.mode = 'o' then 'out'
+            when t1.mode = 'b' then 'inout'
+            when t1.mode = 'v' then 'variadic'
+            else 'table'
+          end as mode
+      ) as t2
+    group by
+      t1.oid
+  ) f_args on f_args.oid = f.oid
+${props.limit ? `limit ${props.limit}` : ""}
+${props.offset ? `offset ${props.offset}` : ""}
+`;
+//#endregion
+export { FUNCTIONS_SQL };

package/dist/vendor/postgres-meta/lib/sql/indexes.sql.js

@@ -0,0 +1,51 @@
+//#region src/vendor/postgres-meta/lib/sql/indexes.sql.ts
+const INDEXES_SQL = (props) => `
+SELECT
+    idx.indexrelid::int8 AS id,
+    idx.indrelid::int8 AS table_id,
+    n.nspname AS schema,
+    idx.indnatts AS number_of_attributes,
+    idx.indnkeyatts AS number_of_key_attributes,
+    idx.indisunique AS is_unique,
+    idx.indisprimary AS is_primary,
+    idx.indisexclusion AS is_exclusion,
+    idx.indimmediate AS is_immediate,
+    idx.indisclustered AS is_clustered,
+    idx.indisvalid AS is_valid,
+    idx.indcheckxmin AS check_xmin,
+    idx.indisready AS is_ready,
+    idx.indislive AS is_live,
+    idx.indisreplident AS is_replica_identity,
+    idx.indkey::smallint[] AS key_attributes,
+    idx.indcollation::integer[] AS collation,
+    idx.indclass::integer[] AS class,
+    idx.indoption::smallint[] AS options,
+    idx.indpred AS index_predicate,
+    obj_description(idx.indexrelid, 'pg_class') AS comment,
+    ix.indexdef as index_definition,
+    am.amname AS access_method,
+    jsonb_agg(
+      jsonb_build_object(
+        'attribute_number', a.attnum,
+        'attribute_name', a.attname,
+        'data_type', format_type(a.atttypid, a.atttypmod)
+      )
+      ORDER BY a.attnum
+    ) AS index_attributes
+  FROM
+    pg_index idx
+    JOIN pg_class c ON c.oid = idx.indexrelid
+    JOIN pg_namespace n ON c.relnamespace = n.oid
+    JOIN pg_am am ON c.relam = am.oid
+    JOIN pg_attribute a ON a.attrelid = c.oid AND a.attnum = ANY(idx.indkey)
+    JOIN pg_indexes ix ON c.relname = ix.indexname
+  WHERE
+    ${props.schemaFilter ? `n.nspname ${props.schemaFilter}` : "true"}
+    ${props.idsFilter ? `AND idx.indexrelid ${props.idsFilter}` : ""}
+  GROUP BY
+    idx.indexrelid, idx.indrelid, n.nspname, idx.indnatts, idx.indnkeyatts, idx.indisunique, idx.indisprimary, idx.indisexclusion, idx.indimmediate, idx.indisclustered, idx.indisvalid, idx.indcheckxmin, idx.indisready, idx.indislive, idx.indisreplident, idx.indkey, idx.indcollation, idx.indclass, idx.indoption, idx.indexprs, idx.indpred, ix.indexdef, am.amname
+${props.limit ? `limit ${props.limit}` : ""}
+${props.offset ? `offset ${props.offset}` : ""}
+`;
+//#endregion
+export { INDEXES_SQL };

package/dist/vendor/postgres-meta/lib/sql/materialized_views.sql.js

@@ -0,0 +1,21 @@
+//#region src/vendor/postgres-meta/lib/sql/materialized_views.sql.ts
+const MATERIALIZED_VIEWS_SQL = (props) => `
+select
+  c.oid::int8 as id,
+  n.nspname as schema,
+  c.relname as name,
+  c.relispopulated as is_populated,
+  obj_description(c.oid) as comment
+from
+  pg_class c
+  join pg_namespace n on n.oid = c.relnamespace
+where
+  ${props.schemaFilter ? `n.nspname ${props.schemaFilter} AND` : ""}
+  ${props.idsFilter ? `c.oid ${props.idsFilter} AND` : ""}
+  ${props.materializedViewIdentifierFilter ? `(n.nspname || '.' || c.relname) ${props.materializedViewIdentifierFilter} AND` : ""}
+  c.relkind = 'm'
+${props.limit ? `limit ${props.limit}` : ""}
+${props.offset ? `offset ${props.offset}` : ""}
+`;
+//#endregion
+export { MATERIALIZED_VIEWS_SQL };

package/dist/vendor/postgres-meta/lib/sql/policies.sql.js

@@ -0,0 +1,53 @@
+//#region src/vendor/postgres-meta/lib/sql/policies.sql.ts
+const POLICIES_SQL = (props) => `
+SELECT
+  pol.oid :: int8 AS id,
+  n.nspname AS schema,
+  c.relname AS table,
+  c.oid :: int8 AS table_id,
+  pol.polname AS name,
+  CASE
+    WHEN pol.polpermissive THEN 'PERMISSIVE' :: text
+    ELSE 'RESTRICTIVE' :: text
+  END AS action,
+  CASE
+    WHEN pol.polroles = '{0}' :: oid [] THEN array_to_json(
+      string_to_array('public' :: text, '' :: text) :: name []
+    )
+    ELSE array_to_json(
+      ARRAY(
+        SELECT
+          pg_roles.rolname
+        FROM
+          pg_roles
+        WHERE
+          pg_roles.oid = ANY (pol.polroles)
+        ORDER BY
+          pg_roles.rolname
+      )
+    )
+  END AS roles,
+  CASE
+    pol.polcmd
+    WHEN 'r' :: "char" THEN 'SELECT' :: text
+    WHEN 'a' :: "char" THEN 'INSERT' :: text
+    WHEN 'w' :: "char" THEN 'UPDATE' :: text
+    WHEN 'd' :: "char" THEN 'DELETE' :: text
+    WHEN '*' :: "char" THEN 'ALL' :: text
+    ELSE NULL :: text
+  END AS command,
+  pg_get_expr(pol.polqual, pol.polrelid) AS definition,
+  pg_get_expr(pol.polwithcheck, pol.polrelid) AS check
+FROM
+  pg_policy pol
+  JOIN pg_class c ON c.oid = pol.polrelid
+  LEFT JOIN pg_namespace n ON n.oid = c.relnamespace
+WHERE
+  ${props.schemaFilter ? `n.nspname ${props.schemaFilter}` : "true"}
+  ${props.idsFilter ? `AND pol.oid ${props.idsFilter}` : ""}
+  ${props.functionNameIdentifierFilter ? `AND (c.relname || '.' || pol.polname) ${props.functionNameIdentifierFilter}` : ""}
+${props.limit ? `limit ${props.limit}` : ""}
+${props.offset ? `offset ${props.offset}` : ""}
+`;
+//#endregion
+export { POLICIES_SQL };

package/dist/vendor/postgres-meta/lib/sql/publications.sql.js

@@ -0,0 +1,46 @@
+//#region src/vendor/postgres-meta/lib/sql/publications.sql.ts
+const PUBLICATIONS_SQL = (props) => `
+SELECT
+  p.oid :: int8 AS id,
+  p.pubname AS name,
+  p.pubowner::regrole::text AS owner,
+  p.pubinsert AS publish_insert,
+  p.pubupdate AS publish_update,
+  p.pubdelete AS publish_delete,
+  p.pubtruncate AS publish_truncate,
+  CASE
+    WHEN p.puballtables THEN NULL
+    ELSE pr.tables
+  END AS tables
+FROM
+  pg_catalog.pg_publication AS p
+  LEFT JOIN LATERAL (
+    SELECT
+      COALESCE(
+        array_agg(
+          json_build_object(
+            'id',
+            c.oid :: int8,
+            'name',
+            c.relname,
+            'schema',
+            nc.nspname
+          )
+        ),
+        '{}'
+      ) AS tables
+    FROM
+      pg_catalog.pg_publication_rel AS pr
+      JOIN pg_class AS c ON pr.prrelid = c.oid
+      join pg_namespace as nc on c.relnamespace = nc.oid
+    WHERE
+      pr.prpubid = p.oid
+  ) AS pr ON 1 = 1
+WHERE
+  ${props.idsFilter ? `p.oid ${props.idsFilter}` : "true"}
+  ${props.nameFilter ? `AND p.pubname ${props.nameFilter}` : ""}
+${props.limit ? `limit ${props.limit}` : ""}
+${props.offset ? `offset ${props.offset}` : ""}
+`;
+//#endregion
+export { PUBLICATIONS_SQL };

package/dist/vendor/postgres-meta/lib/sql/roles.sql.js

@@ -0,0 +1,40 @@
+//#region src/vendor/postgres-meta/lib/sql/roles.sql.ts
+const ROLES_SQL = (props) => `
+-- TODO: Consider using pg_authid vs. pg_roles for unencrypted password field
+SELECT
+  oid :: int8 AS id,
+  rolname AS name,
+  rolsuper AS is_superuser,
+  rolcreatedb AS can_create_db,
+  rolcreaterole AS can_create_role,
+  rolinherit AS inherit_role,
+  rolcanlogin AS can_login,
+  rolreplication AS is_replication_role,
+  rolbypassrls AS can_bypass_rls,
+  (
+    SELECT
+      COUNT(*)
+    FROM
+      pg_stat_activity
+    WHERE
+      pg_roles.rolname = pg_stat_activity.usename
+  ) AS active_connections,
+  CASE WHEN rolconnlimit = -1 THEN current_setting('max_connections') :: int8
+       ELSE rolconnlimit
+  END AS connection_limit,
+  rolpassword AS password,
+  rolvaliduntil AS valid_until,
+  rolconfig AS config
+FROM
+  pg_roles
+WHERE
+  ${props.idsFilter ? `oid ${props.idsFilter}` : "true"}
+  -- All default/predefined roles start with pg_: https://www.postgresql.org/docs/15/predefined-roles.html
+  -- The pg_ prefix is also reserved.
+  ${!props.includeDefaultRoles ? `AND NOT pg_catalog.starts_with(rolname, 'pg_')` : ""}
+  ${props.nameFilter ? `AND rolname ${props.nameFilter}` : ""}
+${props.limit ? `limit ${props.limit}` : ""}
+${props.offset ? `offset ${props.offset}` : ""}
+`;
+//#endregion
+export { ROLES_SQL };

package/dist/vendor/postgres-meta/lib/sql/schemas.sql.js

@@ -0,0 +1,26 @@
+//#region src/vendor/postgres-meta/lib/sql/schemas.sql.ts
+const SCHEMAS_SQL = (props) => `
+-- Adapted from information_schema.schemata
+select
+  n.oid::int8 as id,
+  n.nspname as name,
+  u.rolname as owner
+from
+  pg_namespace n,
+  pg_roles u
+where
+  n.nspowner = u.oid
+  ${props.idsFilter ? `and n.oid ${props.idsFilter}` : ""}
+  ${props.nameFilter ? `and n.nspname ${props.nameFilter}` : ""}
+  ${!props.includeSystemSchemas ? `and not pg_catalog.starts_with(n.nspname, 'pg_')` : ""}
+  and (
+    pg_has_role(n.nspowner, 'USAGE')
+    or has_schema_privilege(n.oid, 'CREATE, USAGE')
+  )
+  and not pg_catalog.starts_with(n.nspname, 'pg_temp_')
+  and not pg_catalog.starts_with(n.nspname, 'pg_toast_temp_')
+${props.limit ? `limit ${props.limit}` : ""}
+${props.offset ? `offset ${props.offset}` : ""}
+`;
+//#endregion
+export { SCHEMAS_SQL };

package/dist/vendor/postgres-meta/lib/sql/table.sql.js

@@ -0,0 +1,109 @@
+//#region src/vendor/postgres-meta/lib/sql/table.sql.ts
+const TABLES_SQL = (props) => `
+SELECT
+  c.oid :: int8 AS id,
+  nc.nspname AS schema,
+  c.relname AS name,
+  c.relrowsecurity AS rls_enabled,
+  c.relforcerowsecurity AS rls_forced,
+  CASE
+    WHEN c.relreplident = 'd' THEN 'DEFAULT'
+    WHEN c.relreplident = 'i' THEN 'INDEX'
+    WHEN c.relreplident = 'f' THEN 'FULL'
+    ELSE 'NOTHING'
+  END AS replica_identity,
+  pg_total_relation_size(format('%I.%I', nc.nspname, c.relname)) :: int8 AS bytes,
+  pg_size_pretty(
+    pg_total_relation_size(format('%I.%I', nc.nspname, c.relname))
+  ) AS size,
+  pg_stat_get_live_tuples(c.oid) AS live_rows_estimate,
+  pg_stat_get_dead_tuples(c.oid) AS dead_rows_estimate,
+  obj_description(c.oid) AS comment,
+  coalesce(pk.primary_keys, '[]') as primary_keys,
+  coalesce(
+    jsonb_agg(relationships) filter (where relationships is not null),
+    '[]'
+  ) as relationships
+FROM
+  pg_namespace nc
+  JOIN pg_class c ON nc.oid = c.relnamespace
+  left join (
+    select
+      c.oid::int8 as table_id,
+      jsonb_agg(
+        jsonb_build_object(
+          'table_id', c.oid::int8,
+          'schema', n.nspname,
+          'table_name', c.relname,
+          'name', a.attname
+        )
+        order by array_position(i.indkey, a.attnum)
+      ) as primary_keys
+    from
+      pg_index i
+      join pg_class c on i.indrelid = c.oid
+      join pg_namespace n on c.relnamespace = n.oid
+      join pg_attribute a on a.attrelid = c.oid and a.attnum = any(i.indkey)
+    where
+      ${props.schemaFilter ? `n.nspname ${props.schemaFilter} AND` : ""}
+      ${props.tableIdentifierFilter ? `n.nspname || '.' || c.relname ${props.tableIdentifierFilter} AND` : ""}
+      i.indisprimary
+    group by c.oid
+  ) as pk
+  on pk.table_id = c.oid
+  left join (
+    select
+      c.oid :: int8 as id,
+      c.conname as constraint_name,
+      nsa.nspname as source_schema,
+      csa.relname as source_table_name,
+      sa.attname as source_column_name,
+      nta.nspname as target_table_schema,
+      cta.relname as target_table_name,
+      ta.attname as target_column_name
+    from
+      pg_constraint c
+    join (
+      pg_attribute sa
+      join pg_class csa on sa.attrelid = csa.oid
+      join pg_namespace nsa on csa.relnamespace = nsa.oid
+    ) on sa.attrelid = c.conrelid and sa.attnum = any (c.conkey)
+    join (
+      pg_attribute ta
+      join pg_class cta on ta.attrelid = cta.oid
+      join pg_namespace nta on cta.relnamespace = nta.oid
+    ) on ta.attrelid = c.confrelid and ta.attnum = any (c.confkey)
+    where
+      ${props.schemaFilter ? `nsa.nspname ${props.schemaFilter} OR nta.nspname ${props.schemaFilter} AND` : ""}
+      ${props.tableIdentifierFilter ? `(nsa.nspname || '.' || csa.relname) ${props.tableIdentifierFilter} OR (nta.nspname || '.' || cta.relname) ${props.tableIdentifierFilter} AND` : ""}
+      c.contype = 'f'
+  ) as relationships
+  on (relationships.source_schema = nc.nspname and relationships.source_table_name = c.relname)
+  or (relationships.target_table_schema = nc.nspname and relationships.target_table_name = c.relname)
+WHERE
+  ${props.schemaFilter ? `nc.nspname ${props.schemaFilter} AND` : ""}
+  ${props.idsFilter ? `c.oid ${props.idsFilter} AND` : ""}
+  ${props.tableIdentifierFilter ? `nc.nspname || '.' || c.relname ${props.tableIdentifierFilter} AND` : ""}
+  c.relkind IN ('r', 'p')
+  AND NOT pg_is_other_temp_schema(nc.oid)
+  AND (
+    pg_has_role(c.relowner, 'USAGE')
+    OR has_table_privilege(
+      c.oid,
+      'SELECT, INSERT, UPDATE, DELETE, TRUNCATE, REFERENCES, TRIGGER'
+    )
+    OR has_any_column_privilege(c.oid, 'SELECT, INSERT, UPDATE, REFERENCES')
+  )
+group by
+  c.oid,
+  c.relname,
+  c.relrowsecurity,
+  c.relforcerowsecurity,
+  c.relreplident,
+  nc.nspname,
+  pk.primary_keys
+${props.limit ? `limit ${props.limit}` : ""}
+${props.offset ? `offset ${props.offset}` : ""}
+`;
+//#endregion
+export { TABLES_SQL };

package/dist/vendor/postgres-meta/lib/sql/table_privileges.sql.js

@@ -0,0 +1,85 @@
+//#region src/vendor/postgres-meta/lib/sql/table_privileges.sql.ts
+const TABLE_PRIVILEGES_SQL = (props) => `
+-- Despite the name \`table_privileges\`, this includes other kinds of relations:
+-- views, matviews, etc. "Relation privileges" just doesn't roll off the tongue.
+--
+-- For each relation, get its relacl in a jsonb format,
+-- e.g.
+--
+-- '{postgres=arwdDxt/postgres}'
+--
+-- becomes
+--
+-- [
+--   {
+--     "grantee": "postgres",
+--     "grantor": "postgres",
+--     "is_grantable": false,
+--     "privilege_type": "INSERT"
+--   },
+--   ...
+-- ]
+select
+  c.oid as relation_id,
+  nc.nspname as schema,
+  c.relname as name,
+  case
+    when c.relkind = 'r' then 'table'
+    when c.relkind = 'v' then 'view'
+    when c.relkind = 'm' then 'materialized_view'
+    when c.relkind = 'f' then 'foreign_table'
+    when c.relkind = 'p' then 'partitioned_table'
+  end as kind,
+  coalesce(
+    jsonb_agg(
+      jsonb_build_object(
+        'grantor', grantor.rolname,
+        'grantee', grantee.rolname,
+        'privilege_type', _priv.privilege_type,
+        'is_grantable', _priv.is_grantable
+      )
+    ) filter (where _priv is not null),
+    '[]'
+  ) as privileges
+from pg_class c
+join pg_namespace as nc
+  on nc.oid = c.relnamespace
+left join lateral (
+  select grantor, grantee, privilege_type, is_grantable
+  from aclexplode(coalesce(c.relacl, acldefault('r', c.relowner)))
+) as _priv on true
+left join pg_roles as grantor
+  on grantor.oid = _priv.grantor
+left join (
+  select
+    pg_roles.oid,
+    pg_roles.rolname
+  from pg_roles
+  union all
+  select
+    (0)::oid as oid, 'PUBLIC'
+) as grantee (oid, rolname)
+  on grantee.oid = _priv.grantee
+where c.relkind in ('r', 'v', 'm', 'f', 'p')
+  ${props.schemaFilter ? `and nc.nspname ${props.schemaFilter}` : ""}
+  ${props.idsFilter ? `and c.oid ${props.idsFilter}` : ""}
+  ${props.nameIdentifierFilter ? `and (nc.nspname || '.' || c.relname) ${props.nameIdentifierFilter}` : ""}
+  and not pg_is_other_temp_schema(c.relnamespace)
+  and (
+    pg_has_role(c.relowner, 'USAGE')
+    or has_table_privilege(
+      c.oid,
+      'SELECT, INSERT, UPDATE, DELETE, TRUNCATE, REFERENCES, TRIGGER, MAINTAIN'
+    )
+    or has_any_column_privilege(c.oid, 'SELECT, INSERT, UPDATE, REFERENCES')
+  )
+group by
+  c.oid,
+  nc.nspname,
+  c.relname,
+  c.relkind
+${props.limit ? `limit ${props.limit}` : ""}
+${props.offset ? `offset ${props.offset}` : ""}
+`;
+//#endregion
+export { TABLE_PRIVILEGES_SQL };

package/dist/vendor/postgres-meta/lib/sql/table_relationships.sql.js

@@ -0,0 +1,52 @@
+//#region src/vendor/postgres-meta/lib/sql/table_relationships.sql.ts
+const TABLE_RELATIONSHIPS_SQL = (props) => `
+-- Adapted from
+-- https://github.com/PostgREST/postgrest/blob/f9f0f79fa914ac00c11fbf7f4c558e14821e67e2/src/PostgREST/SchemaCache.hs#L722
+WITH
+pks_uniques_cols AS (
+  SELECT
+    connamespace,
+    conrelid,
+    jsonb_agg(column_info.cols) as cols
+  FROM pg_constraint
+  JOIN lateral (
+    SELECT array_agg(cols.attname order by cols.attnum) as cols
+    FROM ( select unnest(conkey) as col) _
+    JOIN pg_attribute cols on cols.attrelid = conrelid and cols.attnum = col
+  ) column_info ON TRUE
+  WHERE
+    contype IN ('p', 'u') and
+    connamespace::regnamespace::text <> 'pg_catalog'
+    ${props.schemaFilter ? `and connamespace::regnamespace::text ${props.schemaFilter}` : ""}
+  GROUP BY connamespace, conrelid
+)
+SELECT
+  traint.conname AS foreign_key_name,
+  ns1.nspname AS schema,
+  tab.relname AS relation,
+  column_info.cols AS columns,
+  ns2.nspname AS referenced_schema,
+  other.relname AS referenced_relation,
+  column_info.refs AS referenced_columns,
+  (column_info.cols IN (SELECT * FROM jsonb_array_elements(pks_uqs.cols))) AS is_one_to_one
+FROM pg_constraint traint
+JOIN LATERAL (
+  SELECT
+    jsonb_agg(cols.attname order by ord) AS cols,
+    jsonb_agg(refs.attname order by ord) AS refs
+  FROM unnest(traint.conkey, traint.confkey) WITH ORDINALITY AS _(col, ref, ord)
+  JOIN pg_attribute cols ON cols.attrelid = traint.conrelid AND cols.attnum = col
+  JOIN pg_attribute refs ON refs.attrelid = traint.confrelid AND refs.attnum = ref
+  WHERE ${props.schemaFilter ? `traint.connamespace::regnamespace::text ${props.schemaFilter}` : "true"}
+) AS column_info ON TRUE
+JOIN pg_namespace ns1 ON ns1.oid = traint.connamespace
+JOIN pg_class tab ON tab.oid = traint.conrelid
+JOIN pg_class other ON other.oid = traint.confrelid
+JOIN pg_namespace ns2 ON ns2.oid = other.relnamespace
+LEFT JOIN pks_uniques_cols pks_uqs ON pks_uqs.connamespace = traint.connamespace AND pks_uqs.conrelid = traint.conrelid
+WHERE traint.contype = 'f'
+AND traint.conparentid = 0
+${props.schemaFilter ? `and ns1.nspname ${props.schemaFilter}` : ""}
+`;
+//#endregion
+export { TABLE_RELATIONSHIPS_SQL };