neon 8.4.5 → 8.6.0

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

@@ -0,0 +1,64 @@
+//#region src/vendor/postgres-meta/lib/sql/triggers.sql.ts
+const TRIGGERS_SQL = (props) => `
+SELECT
+  pg_t.oid AS id,
+  pg_t.tgrelid AS table_id,
+  CASE
+    WHEN pg_t.tgenabled = 'D' THEN 'DISABLED'
+    WHEN pg_t.tgenabled = 'O' THEN 'ORIGIN'
+    WHEN pg_t.tgenabled = 'R' THEN 'REPLICA'
+    WHEN pg_t.tgenabled = 'A' THEN 'ALWAYS'
+    END AS enabled_mode,
+  (
+    STRING_TO_ARRAY(
+      ENCODE(pg_t.tgargs, 'escape'), '\\000'
+    )
+  )[:pg_t.tgnargs] AS function_args,
+  is_t.trigger_name AS name,
+  is_t.event_object_table AS table,
+  is_t.event_object_schema AS schema,
+  is_t.action_condition AS condition,
+  is_t.action_orientation AS orientation,
+  is_t.action_timing AS activation,
+  ARRAY_AGG(is_t.event_manipulation)::text[] AS events,
+  pg_p.proname AS function_name,
+  pg_n.nspname AS function_schema
+FROM
+  pg_trigger AS pg_t
+JOIN
+  pg_class AS pg_c
+ON pg_t.tgrelid = pg_c.oid
+JOIN pg_namespace AS table_ns
+ON pg_c.relnamespace = table_ns.oid
+JOIN information_schema.triggers AS is_t
+ON is_t.trigger_name = pg_t.tgname
+AND pg_c.relname = is_t.event_object_table
+AND pg_c.relnamespace = (quote_ident(is_t.event_object_schema))::regnamespace
+JOIN pg_proc AS pg_p
+ON pg_t.tgfoid = pg_p.oid
+JOIN pg_namespace AS pg_n
+ON pg_p.pronamespace = pg_n.oid
+WHERE
+  ${props.schemaFilter ? `table_ns.nspname ${props.schemaFilter}` : "true"}
+  ${props.tableNameFilter ? `AND pg_c.relname ${props.tableNameFilter}` : ""}
+  ${props.nameFilter ? `AND is_t.trigger_name ${props.nameFilter}` : ""}
+  ${props.idsFilter ? `AND pg_t.oid ${props.idsFilter}` : ""}
+GROUP BY
+  pg_t.oid,
+  pg_t.tgrelid,
+  pg_t.tgenabled,
+  pg_t.tgargs,
+  pg_t.tgnargs,
+  is_t.trigger_name,
+  is_t.event_object_table,
+  is_t.event_object_schema,
+  is_t.action_condition,
+  is_t.action_orientation,
+  is_t.action_timing,
+  pg_p.proname,
+  pg_n.nspname
+${props.limit ? `limit ${props.limit}` : ""}
+${props.offset ? `offset ${props.offset}` : ""}
+`;
+//#endregion
+export { TRIGGERS_SQL };

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

@@ -0,0 +1,65 @@
+//#region src/vendor/postgres-meta/lib/sql/types.sql.ts
+const TYPES_SQL = (props) => `
+select
+  t.oid::int8 as id,
+  t.typname as name,
+  n.nspname as schema,
+  format_type (t.oid, null) as format,
+  coalesce(t_enums.enums, '[]') as enums,
+  coalesce(t_attributes.attributes, '[]') as attributes,
+  obj_description (t.oid, 'pg_type') as comment,
+  nullif(t.typrelid::int8, 0) as type_relation_id
+from
+  pg_type t
+  left join pg_namespace n on n.oid = t.typnamespace
+  left join (
+    select
+      enumtypid,
+      jsonb_agg(enumlabel order by enumsortorder) as enums
+    from
+      pg_enum
+    group by
+      enumtypid
+  ) as t_enums on t_enums.enumtypid = t.oid
+  left join (
+    select
+      oid,
+      jsonb_agg(
+        jsonb_build_object('name', a.attname, 'type_id', a.atttypid::int8)
+        order by a.attnum asc
+      ) as attributes
+    from
+      pg_class c
+      join pg_attribute a on a.attrelid = c.oid
+    where
+      c.relkind = 'c' and not a.attisdropped
+    group by
+      c.oid
+  ) as t_attributes on t_attributes.oid = t.typrelid
+  where
+      (
+        t.typrelid = 0
+        or (
+          select
+            c.relkind ${props.includeTableTypes ? `in ('c', 'r', 'v', 'm', 'p')` : `= 'c'`}
+          from
+            pg_class c
+          where
+            c.oid = t.typrelid
+        )
+      )
+      ${!props.includeArrayTypes ? `and not exists (
+                 select
+                 from
+                   pg_type el
+                 where
+                   el.oid = t.typelem
+                   and el.typarray = t.oid
+               )` : ""}
+      ${props.schemaFilter ? `and n.nspname ${props.schemaFilter}` : ""}
+      ${props.idsFilter ? `and t.oid ${props.idsFilter}` : ""}
+${props.limit ? `limit ${props.limit}` : ""}
+${props.offset ? `offset ${props.offset}` : ""}
+`;
+//#endregion
+export { TYPES_SQL };

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

@@ -0,0 +1,15 @@
+//#region src/vendor/postgres-meta/lib/sql/version.sql.ts
+const VERSION_SQL = () => `
+SELECT
+  version(),
+  current_setting('server_version_num') :: int8 AS version_number,
+  (
+    SELECT
+      COUNT(*) AS active_connections
+    FROM
+      pg_stat_activity
+  ) AS active_connections,
+  current_setting('max_connections') :: int8 AS max_connections
+`;
+//#endregion
+export { VERSION_SQL };

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

@@ -0,0 +1,22 @@
+//#region src/vendor/postgres-meta/lib/sql/views.sql.ts
+const VIEWS_SQL = (props) => `
+SELECT
+  c.oid :: int8 AS id,
+  n.nspname AS schema,
+  c.relname AS name,
+  -- See definition of information_schema.views
+  (pg_relation_is_updatable(c.oid, false) & 20) = 20 AS is_updatable,
+  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.viewIdentifierFilter ? `(n.nspname || '.' || c.relname) ${props.viewIdentifierFilter} AND` : ""}
+  c.relkind = 'v'
+${props.limit ? `limit ${props.limit}` : ""}
+${props.offset ? `offset ${props.offset}` : ""}
+`;
+//#endregion
+export { VIEWS_SQL };

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

@@ -0,0 +1,198 @@
+//#region src/vendor/postgres-meta/lib/sql/views_key_dependencies.sql.ts
+const VIEWS_KEY_DEPENDENCIES_SQL = (props) => `
+-- Adapted from
+-- https://github.com/PostgREST/postgrest/blob/f9f0f79fa914ac00c11fbf7f4c558e14821e67e2/src/PostgREST/SchemaCache.hs#L820
+with recursive
+pks_fks as (
+  -- pk + fk referencing col
+  select
+    contype::text as contype,
+    conname,
+    array_length(conkey, 1) as ncol,
+    conrelid as resorigtbl,
+    col as resorigcol,
+    ord
+  from pg_constraint
+  left join lateral unnest(conkey) with ordinality as _(col, ord) on true
+  where contype IN ('p', 'f')
+  union
+  -- fk referenced col
+  select
+    concat(contype, '_ref') as contype,
+    conname,
+    array_length(confkey, 1) as ncol,
+    confrelid,
+    col,
+    ord
+  from pg_constraint
+  left join lateral unnest(confkey) with ordinality as _(col, ord) on true
+  where contype='f'
+  ${props.schemaFilter ? `and connamespace::regnamespace::text ${props.schemaFilter}` : ""}
+),
+views as (
+  select
+    c.oid       as view_id,
+    n.nspname   as view_schema,
+    c.relname   as view_name,
+    r.ev_action as view_definition
+  from pg_class c
+  join pg_namespace n on n.oid = c.relnamespace
+  join pg_rewrite r on r.ev_class = c.oid
+  where c.relkind in ('v', 'm') 
+    ${props.schemaFilter ? `and n.nspname ${props.schemaFilter}` : ""}
+),
+transform_json as (
+  select
+    view_id, view_schema, view_name,
+    -- the following formatting is without indentation on purpose
+    -- to allow simple diffs, with less whitespace noise
+    replace(
+      replace(
+      replace(
+      replace(
+      replace(
+      replace(
+      replace(
+      regexp_replace(
+      replace(
+      replace(
+      replace(
+      replace(
+      replace(
+      replace(
+      replace(
+      replace(
+      replace(
+      replace(
+      replace(
+        view_definition::text,
+      -- This conversion to json is heavily optimized for performance.
+      -- The general idea is to use as few regexp_replace() calls as possible.
+      -- Simple replace() is a lot faster, so we jump through some hoops
+      -- to be able to use regexp_replace() only once.
+      -- This has been tested against a huge schema with 250+ different views.
+      -- The unit tests do NOT reflect all possible inputs. Be careful when changing this!
+      -- -----------------------------------------------
+      -- pattern           | replacement         | flags
+      -- -----------------------------------------------
+      -- <> in pg_node_tree is the same as null in JSON, but due to very poor performance of json_typeof
+      -- we need to make this an empty array here to prevent json_array_elements from throwing an error
+      -- when the targetList is null.
+      -- We'll need to put it first, to make the node protection below work for node lists that start with
+      -- null: (<> ..., too. This is the case for coldefexprs, when the first column does not have a default value.
+         '<>'              , '()'
+      -- , is not part of the pg_node_tree format, but used in the regex.
+      -- This removes all , that might be part of column names.
+      ), ','               , ''
+      -- The same applies for { and }, although those are used a lot in pg_node_tree.
+      -- We remove the escaped ones, which might be part of column names again.
+      ), E'\\\\{'            , ''
+      ), E'\\\\}'            , ''
+      -- The fields we need are formatted as json manually to protect them from the regex.
+      ), ' :targetList '   , ',"targetList":'
+      ), ' :resno '        , ',"resno":'
+      ), ' :resorigtbl '   , ',"resorigtbl":'
+      ), ' :resorigcol '   , ',"resorigcol":'
+      -- Make the regex also match the node type, e.g. \`{QUERY ...\`, to remove it in one pass.
+      ), '{'               , '{ :'
+      -- Protect node lists, which start with \`({\` or \`((\` from the greedy regex.
+      -- The extra \`{\` is removed again later.
+      ), '(('              , '{(('
+      ), '({'              , '{({'
+      -- This regex removes all unused fields to avoid the need to format all of them correctly.
+      -- This leads to a smaller json result as well.
+      -- Removal stops at \`,\` for used fields (see above) and \`}\` for the end of the current node.
+      -- Nesting can't be parsed correctly with a regex, so we stop at \`{\` as well and
+      -- add an empty key for the followig node.
+      ), ' :[^}{,]+'       , ',"":'              , 'g'
+      -- For performance, the regex also added those empty keys when hitting a \`,\` or \`}\`.
+      -- Those are removed next.
+      ), ',"":}'           , '}'
+      ), ',"":,'           , ','
+      -- This reverses the "node list protection" from above.
+      ), '{('              , '('
+      -- Every key above has been added with a \`,\` so far. The first key in an object doesn't need it.
+      ), '{,'              , '{'
+      -- pg_node_tree has \`()\` around lists, but JSON uses \`[]\`
+      ), '('               , '['
+      ), ')'               , ']'
+      -- pg_node_tree has \` \` between list items, but JSON uses \`,\`
+      ), ' '             , ','
+    )::json as view_definition
+  from views
+),
+target_entries as(
+  select
+    view_id, view_schema, view_name,
+    json_array_elements(view_definition->0->'targetList') as entry
+  from transform_json
+),
+results as(
+  select
+    view_id, view_schema, view_name,
+    (entry->>'resno')::int as view_column,
+    (entry->>'resorigtbl')::oid as resorigtbl,
+    (entry->>'resorigcol')::int as resorigcol
+  from target_entries
+),
+-- CYCLE detection according to PG docs: https://www.postgresql.org/docs/current/queries-with.html#QUERIES-WITH-CYCLE
+-- Can be replaced with CYCLE clause once PG v13 is EOL.
+recursion(view_id, view_schema, view_name, view_column, resorigtbl, resorigcol, is_cycle, path) as(
+  select
+    r.*,
+    false,
+    ARRAY[resorigtbl]
+  from results r
+  where ${props.schemaFilter ? `view_schema ${props.schemaFilter}` : "true"}
+  union all
+  select
+    view.view_id,
+    view.view_schema,
+    view.view_name,
+    view.view_column,
+    tab.resorigtbl,
+    tab.resorigcol,
+    tab.resorigtbl = ANY(path),
+    path || tab.resorigtbl
+  from recursion view
+  join results tab on view.resorigtbl=tab.view_id and view.resorigcol=tab.view_column
+  where not is_cycle
+),
+repeated_references as(
+  select
+    view_id,
+    view_schema,
+    view_name,
+    resorigtbl,
+    resorigcol,
+    array_agg(attname) as view_columns
+  from recursion
+  join pg_attribute vcol on vcol.attrelid = view_id and vcol.attnum = view_column
+  group by
+    view_id,
+    view_schema,
+    view_name,
+    resorigtbl,
+    resorigcol
+)
+select
+  sch.nspname as table_schema,
+  tbl.relname as table_name,
+  rep.view_schema,
+  rep.view_name,
+  pks_fks.conname as constraint_name,
+  pks_fks.contype as constraint_type,
+  jsonb_agg(
+    jsonb_build_object('table_column', col.attname, 'view_columns', view_columns) order by pks_fks.ord
+  ) as column_dependencies
+from repeated_references rep
+join pks_fks using (resorigtbl, resorigcol)
+join pg_class tbl on tbl.oid = rep.resorigtbl
+join pg_attribute col on col.attrelid = tbl.oid and col.attnum = rep.resorigcol
+join pg_namespace sch on sch.oid = tbl.relnamespace
+group by sch.nspname, tbl.relname,  rep.view_schema, rep.view_name, pks_fks.conname, pks_fks.contype, pks_fks.ncol
+-- make sure we only return key for which all columns are referenced in the view - no partial PKs or FKs
+having ncol = array_length(array_agg(row(col.attname, view_columns) order by pks_fks.ord), 1)
+`;
+//#endregion
+export { VIEWS_KEY_DEPENDENCIES_SQL };

package/dist/vendor/postgres-meta/lib/types.js

@@ -0,0 +1 @@
+export {};