JLDLaughlin/hasura_postgres_connection_logs.csv

## hasura_postgres_connection_logs.csv

          
            2020-09-03 14:50:39.705 EDT
            root
            jessicalaughlin
            82223
            127.0.0.1:54813
            5f513aff.1412f
            1
            startup
            2020-09-03 14:50:39 EDT
            4/853
            0
            FATAL
            28000
            role "root" does not exist

            
              2020-09-03 14:50:39.813 EDT
              root
              jessicalaughlin
              82224
              127.0.0.1:54814
              5f513aff.14130
              1
              startup
              2020-09-03 14:50:39 EDT
              4/854
              0
              FATAL
              28000
              role "root" does not exist

            
              2020-09-03 14:52:46.870 EDT
              jessicalaughlin
              jessicalaughlin
              62561
              [local]
              5f500d7b.f461
              4
              idle
              2020-09-02 17:24:11 EDT
              3/5
              0
              ERROR
              42601
              syntax error at or near "/"
              
              
              
              
              
              /conninfo
;
              1
              
              psql

            
              2020-09-03 14:52:48.086 EDT
              jessicalaughlin
              jessicalaughlin
              62561
              [local]
              5f500d7b.f461
              5
              idle
              2020-09-02 17:24:11 EDT
              3/6
              0
              LOG
              00000
              statement: ;
              
              
              
              
              
              
              
              
              psql

            
              2020-09-03 14:52:56.177 EDT
              jessicalaughlin
              jessicalaughlin
              62561
              [local]
              5f500d7b.f461
              6
              idle
              2020-09-02 17:24:11 EDT
              3/7
              0
              LOG
              00000
              statement: select current_user;
              
              
              
              
              
              
              
              
              psql

            
              2020-09-03 14:53:06.367 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              1
              idle
              2020-09-03 14:53:06 EDT
              4/862
              0
              LOG
              00000
              statement: SET client_encoding = 'UTF8';SET client_min_messages TO WARNING;

            
              2020-09-03 14:53:06.368 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              2
              BEGIN
              2020-09-03 14:53:06 EDT
              4/864
              0
              LOG
              00000
              execute 0: BEGIN ISOLATION LEVEL SERIALIZABLE READ WRITE

            
              2020-09-03 14:53:06.371 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              3
              SET
              2020-09-03 14:53:06 EDT
              4/864
              0
              LOG
              00000
              execute <unnamed>: SET LOCAL "hasura.user" = '{}'

            
              2020-09-03 14:53:06.389 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              4
              SELECT
              2020-09-03 14:53:06 EDT
              4/864
              0
              LOG
              00000
              execute <unnamed>:
        SELECT EXISTS
        ( SELECT 1 FROM information_schema.schemata
          WHERE schema_name = $1
        ) 
              parameters: $1 = 'hdb_catalog'

            
              2020-09-03 14:53:06.389 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              5
              CREATE SCHEMA
              2020-09-03 14:53:06 EDT
              4/864
              0
              LOG
              00000
              execute <unnamed>: CREATE SCHEMA hdb_catalog

            
              2020-09-03 14:53:06.392 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              6
              CREATE SCHEMA
              2020-09-03 14:53:06 EDT
              4/864
              2093
              LOG
              00000
              execute <unnamed>: CREATE SCHEMA hdb_views

            
              2020-09-03 14:53:06.395 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              7
              SELECT
              2020-09-03 14:53:06 EDT
              4/864
              2093
              LOG
              00000
              execute <unnamed>:
        SELECT EXISTS
        ( SELECT 1 FROM pg_catalog.pg_available_extensions
          WHERE name = $1
        ) 
              parameters: $1 = 'pgcrypto'

            
              2020-09-03 14:53:06.412 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              8
              CREATE EXTENSION
              2020-09-03 14:53:06 EDT
              4/864
              2093
              LOG
              00000
              execute <unnamed>: CREATE EXTENSION IF NOT EXISTS pgcrypto SCHEMA public

            
              2020-09-03 14:53:06.538 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              9
              idle in transaction
              2020-09-03 14:53:06 EDT
              4/864
              2093
              LOG
              00000
              statement: CREATE TABLE hdb_catalog.hdb_version (
    hasura_uuid UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    version TEXT NOT NULL,
    upgraded_on TIMESTAMPTZ NOT NULL,
    cli_state JSONB NOT NULL DEFAULT '{}'::jsonb,
    console_state JSONB NOT NULL DEFAULT '{}'::jsonb
);
CREATE UNIQUE INDEX hdb_version_one_row
ON hdb_catalog.hdb_version((version IS NOT NULL));
/* Note [Reference system columns using type name]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
While working on #3394, I (Alexis) discovered that Postgres seems to sometimes generate very bad
query plans when joining against the system catalogs if we store things like table/schema names
using type `text` rather than type `name`, the latter of which is used internally. The two types are
compatible in the sense that Postgres will willingly widen `name` to `type` automatically, but
`name`s are restricted to 64 bytes.
Using `name` for ordinary user data would be a deep sin, but using it to store references to actual
Postgres identifiers makes a lot of sense, so using `name` in those places is alright. And by doing
so, we make Postgres much more likely to take advantage of certain indexes that can significantly
improve query performance. */
CREATE TABLE hdb_catalog.hdb_table
(
    table_schema name, -- See Note [Reference system columns using type name]
    table_name name,
    configuration jsonb,
    is_system_defined boolean default false,
    is_enum boolean NOT NULL DEFAULT false,
    PRIMARY KEY (table_schema, table_name)
);
CREATE TABLE hdb_catalog.hdb_relationship
(
    table_schema name, -- See Note [Reference system columns using type name]
    table_name name,
    rel_name   TEXT,
    rel_type   TEXT CHECK (rel_type IN ('object', 'array')),
    rel_def    JSONB NOT NULL,
    comment    TEXT NULL,
    is_system_defined boolean default false,
    PRIMARY KEY (table_schema, table_name, rel_name),
    FOREIGN KEY (table_schema, table_name) REFERENCES hdb_catalog.hdb_table(table_schema, table_name) ON UPDATE CASCADE
);
CREATE TABLE hdb_catalog.hdb_remote_relationship
(
  remote_relationship_name TEXT NOT NULL,
  table_schema name NOT NULL,
  table_name name NOT NULL,
  definition JSONB NOT NULL,
  PRIMARY KEY (remote_relationship_name, table_schema, table_name),
  FOREIGN KEY (table_schema, table_name) REFERENCES hdb_catalog.hdb_table(table_schema, table_name) ON UPDATE CASCADE
);
CREATE TABLE hdb_catalog.hdb_permission
(
    table_schema name, -- See Note [Reference system columns using type name]
    table_name name,
    role_name  TEXT,
    perm_type  TEXT CHECK(perm_type IN ('insert', 'select', 'update', 'delete')),
    perm_def   JSONB NOT NULL,
    comment    TEXT NULL,
    is_system_defined boolean default false,
    PRIMARY KEY (table_schema, table_name, role_name, perm_type),
    FOREIGN KEY (table_schema, table_name) REFERENCES hdb_catalog.hdb_table(table_schema, table_name) ON UPDATE CASCADE
);
CREATE VIEW hdb_catalog.hdb_permission_agg AS
SELECT
    table_schema,
    table_name,
    role_name,
    json_object_agg(perm_type, perm_def) as permissions
FROM
    hdb_catalog.hdb_permission
GROUP BY
    table_schema, table_name, role_name;
CREATE VIEW hdb_catalog.hdb_foreign_key_constraint AS
SELECT
    q.table_schema :: text,
    q.table_name :: text,
    q.constraint_name :: text,
    min(q.constraint_oid) :: integer as constraint_oid,
    min(q.ref_table_table_schema) :: text as ref_table_table_schema,
    min(q.ref_table) :: text as ref_table,
    json_object_agg(ac.attname, afc.attname) as column_mapping,
    min(q.confupdtype) :: text as on_update,
    min(q.confdeltype) :: text as on_delete,
    json_agg(ac.attname) as columns,
    json_agg(afc.attname) as ref_columns
FROM
    (SELECT
        ctn.nspname AS table_schema,
        ct.relname AS table_name,
        r.conrelid AS table_id,
        r.conname as constraint_name,
        r.oid as constraint_oid,
        cftn.nspname AS ref_table_table_schema,
        cft.relname as ref_table,
        r.confrelid as ref_table_id,
        r.confupdtype,
        r.confdeltype,
        UNNEST (r.conkey) AS column_id,
        UNNEST (r.confkey) AS ref_column_id
    FROM
        pg_catalog.pg_constraint r
        JOIN pg_catalog.pg_class ct
          ON r.conrelid = ct.oid
        JOIN pg_catalog.pg_namespace ctn
          ON ct.relnamespace = ctn.oid
        JOIN pg_catalog.pg_class cft
          ON r.confrelid = cft.oid
        JOIN pg_catalog.pg_namespace cftn
          ON cft.relnamespace = cftn.oid
    WHERE
        r.contype = 'f'
    ) q
    JOIN pg_catalog.pg_attribute ac
      ON q.column_id = ac.attnum
         AND q.table_id = ac.attrelid
    JOIN pg_catalog.pg_attribute afc
      ON q.ref_column_id = afc.attnum
         AND q.ref_table_id = afc.attrelid
GROUP BY q.table_schema, q.table_name, q.constraint_name;
CREATE VIEW hdb_catalog.hdb_check_constraint AS
SELECT
    n.nspname :: text AS table_schema,
    ct.relname :: text AS table_name,
    r.conname :: text as constraint_name,
    pg_catalog.pg_get_constraintdef(r.oid, true) as check
FROM
    pg_catalog.pg_constraint r
    JOIN pg_catalog.pg_class ct
      ON r.conrelid = ct.oid
    JOIN pg_catalog.pg_namespace n
      ON ct.relnamespace = n.oid
WHERE
    r.contype = 'c';
CREATE VIEW hdb_catalog.hdb_unique_constraint AS
SELECT
    tc.table_name,
    tc.constraint_schema AS table_schema,
    tc.constraint_name as constraint_name,
    json_agg(kcu.column_name) AS columns
FROM
    information_schema.table_constraints tc
    JOIN information_schema.key_column_usage AS kcu
    USING (constraint_schema, constraint_name)
WHERE
    constraint_type = 'UNIQUE'
GROUP BY
    tc.table_name, tc.constraint_schema, tc.constraint_name;
CREATE VIEW hdb_catalog.hdb_primary_key AS
SELECT
  tc.table_schema,
  tc.table_name,
  tc.constraint_name,
  json_agg(constraint_column_usage.column_name) AS columns
FROM
  (
    information_schema.table_constraints tc
    JOIN (
      SELECT
        x.tblschema AS table_schema,
        x.tblname AS table_name,
        x.colname AS column_name,
        x.cstrname AS constraint_name
      FROM
        (
          SELECT
            DISTINCT nr.nspname,
            r.relname,
            a.attname,
            c.conname
          FROM
            pg_namespace nr,
            pg_class r,
            pg_attribute a,
            pg_depend d,
            pg_namespace nc,
            pg_constraint c
          WHERE
            (
              (nr.oid = r.relnamespace)
              AND (r.oid = a.attrelid)
              AND (d.refclassid = ('pg_class' :: regclass) :: oid)
              AND (d.refobjid = r.oid)
              AND (d.refobjsubid = a.attnum)
              AND (d.classid = ('pg_constraint' :: regclass) :: oid)
              AND (d.objid = c.oid)
              AND (c.connamespace = nc.oid)
              AND (c.contype = 'c' :: "char")
              AND (
                r.relkind = ANY (ARRAY ['r'::"char", 'p'::"char"])
              )
              AND (NOT a.attisdropped)
            )
          UNION ALL
          SELECT
            nr.nspname,
            r.relname,
            a.attname,
            c.conname
          FROM
            pg_namespace nr,
            pg_class r,
            pg_attribute a,
            pg_namespace nc,
            pg_constraint c
          WHERE
            (
              (nr.oid = r.relnamespace)
              AND (r.oid = a.attrelid)
              AND (nc.oid = c.connamespace)
              AND (
                r.oid = CASE
                  c.contype
                  WHEN 'f' :: "char" THEN c.confrelid
                  ELSE c.conrelid
                END
              )
              AND (
                a.attnum = ANY (
                  CASE
                    c.contype
                    WHEN 'f' :: "char" THEN c.confkey
                    ELSE c.conkey
                  END
                )
              )
              AND (NOT a.attisdropped)
              AND (
                c.contype = ANY (ARRAY ['p'::"char", 'u'::"char", 'f'::"char"])
              )
              AND (
                r.relkind = ANY (ARRAY ['r'::"char", 'p'::"char"])
              )
            )
        ) x(
          tblschema,
          tblname,
          colname,
          cstrname
        )
    ) constraint_column_usage ON (
      (
        (tc.constraint_name) :: text = (constraint_column_usage.constraint_name) :: text
        AND (tc.table_schema) :: text = (constraint_column_usage.table_schema) :: text
        AND (tc.table_name) :: text = (constraint_column_usage.table_name) :: text
      )
    )
  )
WHERE
  ((tc.constraint_type) :: text = 'PRIMARY KEY' :: text)
GROUP BY
  tc.table_schema,
  tc.table_name,
  tc.constraint_name;
CREATE FUNCTION hdb_catalog.inject_table_defaults(view_schema text, view_name text, tab_schema text, tab_name text) RETURNS void
LANGUAGE plpgsql AS $$
    DECLARE
        r RECORD;
    BEGIN
      FOR r IN SELECT column_name, column_default FROM information_schema.columns WHERE table_schema = tab_schema AND table_name = tab_name AND column_default IS NOT NULL LOOP
          EXECUTE format('ALTER VIEW %I.%I ALTER COLUMN %I SET DEFAULT %s;', view_schema, view_name, r.column_name, r.column_default);
      END LOOP;
    END;
$$;
CREATE TABLE hdb_catalog.event_triggers
(
  name TEXT PRIMARY KEY,
  type TEXT NOT NULL,
  schema_name TEXT NOT NULL,
  table_name TEXT NOT NULL,
  configuration JSON,
  comment TEXT,
  FOREIGN KEY (schema_name, table_name)
  REFERENCES hdb_catalog.hdb_table(table_schema, table_name) ON UPDATE CASCADE
);
CREATE TABLE hdb_catalog.event_log
(
  id TEXT DEFAULT gen_random_uuid() PRIMARY KEY,
  schema_name TEXT NOT NULL,
  table_name TEXT NOT NULL,
  trigger_name TEXT NOT NULL,
  payload JSONB NOT NULL,
  delivered BOOLEAN NOT NULL DEFAULT FALSE,
  error BOOLEAN NOT NULL DEFAULT FALSE,
  tries INTEGER NOT NULL DEFAULT 0,
  created_at TIMESTAMP DEFAULT NOW(),
  locked BOOLEAN NOT NULL DEFAULT FALSE,
  next_retry_at TIMESTAMP,
  archived BOOLEAN NOT NULL DEFAULT FALSE
);
CREATE INDEX ON hdb_catalog.event_log (trigger_name);
CREATE INDEX ON hdb_catalog.event_log (locked);
CREATE INDEX ON hdb_catalog.event_log (delivered);
CREATE INDEX ON hdb_catalog.event_log (created_at);
CREATE TABLE hdb_catalog.event_invocation_logs
(
  id TEXT DEFAULT gen_random_uuid() PRIMARY KEY,
  event_id TEXT,
  status INTEGER,
  request JSON,
  response JSON,
  created_at TIMESTAMP DEFAULT NOW(),
  FOREIGN KEY (event_id) REFERENCES hdb_catalog.event_log (id)
);
CREATE INDEX ON hdb_catalog.event_invocation_logs (event_id);
CREATE TABLE hdb_catalog.hdb_function
(
    function_schema TEXT,
    function_name TEXT,
    configuration JSONB NOT NULL DEFAULT '{}'::jsonb,
    is_system_defined boolean default false,
    PRIMARY KEY (function_schema, function_name)
);
CREATE VIEW hdb_catalog.hdb_function_agg AS
(
SELECT
  p.proname::text AS function_name,
  pn.nspname::text AS function_schema,
  pd.description,
  CASE
    WHEN (p.provariadic = (0) :: oid) THEN false
    ELSE true
  END AS has_variadic,
  CASE
    WHEN (
      (p.provolatile) :: text = ('i' :: character(1)) :: text
    ) THEN 'IMMUTABLE' :: text
    WHEN (
      (p.provolatile) :: text = ('s' :: character(1)) :: text
    ) THEN 'STABLE' :: text
    WHEN (
      (p.provolatile) :: text = ('v' :: character(1)) :: text
    ) THEN 'VOLATILE' :: text
    ELSE NULL :: text
  END AS function_type,
  pg_get_functiondef(p.oid) AS function_definition,
  rtn.nspname::text as return_type_schema,
  rt.typname::text as return_type_name,
  rt.typtype::text as return_type_type,
  p.proretset AS returns_set,
  ( SELECT
      COALESCE(json_agg(
        json_build_object('schema', q."schema",
                          'name', q."name",
                          'type', q."type"
                         )
      ), '[]')
    FROM
      (
        SELECT
          pt.typname AS "name",
          pns.nspname AS "schema",
          pt.typtype AS "type",
          pat.ordinality
        FROM
          unnest(
            COALESCE(p.proallargtypes, (p.proargtypes) :: oid [])
          ) WITH ORDINALITY pat(oid, ordinality)
          LEFT JOIN pg_type pt ON ((pt.oid = pat.oid))
          LEFT JOIN pg_namespace pns ON (pt.typnamespace = pns.oid)
        ORDER BY pat.ordinality ASC
      ) q
   ) AS input_arg_types,
  to_json(COALESCE(p.proargnames, ARRAY [] :: text [])) AS input_arg_names,
  p.pronargdefaults AS default_args,
  p.oid::integer AS function_oid
FROM
  pg_proc p
  JOIN pg_namespace pn ON (pn.oid = p.pronamespace)
  JOIN pg_type rt ON (rt.oid = p.prorettype)
  JOIN pg_namespace rtn ON (rtn.oid = rt.typnamespace)
  LEFT JOIN pg_description pd ON p.oid = pd.objoid
WHERE
  pn.nspname :: text NOT LIKE 'pg_%'
  AND pn.nspname :: text NOT IN ('information_schema', 'hdb_catalog', 'hdb_views')
  AND (NOT EXISTS (
          SELECT
            1
          FROM
            pg_aggregate
          WHERE
            ((pg_aggregate.aggfnoid) :: oid = p.oid)
        )
    )
);
CREATE TABLE hdb_catalog.remote_schemas (
  id BIGSERIAL PRIMARY KEY,
  name TEXT UNIQUE,
  definition JSON,
  comment TEXT
);
CREATE TABLE hdb_catalog.hdb_schema_update_event (
  instance_id uuid NOT NULL,
  occurred_at timestamptz NOT NULL DEFAULT NOW(),
  invalidations json NOT NULL
);
CREATE UNIQUE INDEX hdb_schema_update_event_one_row
  ON hdb_catalog.hdb_schema_update_event ((occurred_at IS NOT NULL));
CREATE FUNCTION hdb_catalog.hdb_schema_update_event_notifier() RETURNS trigger AS
$function$
  DECLARE
    instance_id uuid;
    occurred_at timestamptz;
    invalidations json;
    curr_rec record;
  BEGIN
    instance_id = NEW.instance_id;
    occurred_at = NEW.occurred_at;
    invalidations = NEW.invalidations;
    PERFORM pg_notify('hasura_schema_update', json_build_object(
      'instance_id', instance_id,
      'occurred_at', occurred_at,
      'invalidations', invalidations
      )::text);
    RETURN curr_rec;
  END;
$function$
LANGUAGE plpgsql;
CREATE TRIGGER hdb_schema_update_event_notifier AFTER INSERT OR UPDATE ON
  hdb_catalog.hdb_schema_update_event FOR EACH ROW EXECUTE PROCEDURE
  hdb_catalog.hdb_schema_update_event_notifier();
CREATE VIEW hdb_catalog.hdb_table_info_agg AS
  SELECT
    schema.nspname AS table_schema,
    "table".relname AS table_name,
    -- This field corresponds to the `CatalogTableInfo` Haskell type
    jsonb_build_object(
      'oid',"table".oid :: integer,
      'columns', coalesce(columns.info, '[]'),
      'primary_key', primary_key.info,
      -- Note: unique_constraints does NOT include primary key constraints!
      'unique_constraints', coalesce(unique_constraints.info, '[]'),
      'foreign_keys', coalesce(foreign_key_constraints.info, '[]'),
      'view_info', CASE "table".relkind WHEN 'v' THEN jsonb_build_object(
        'is_updatable', ((pg_catalog.pg_relation_is_updatable("table".oid, true) & 4) = 4),
        'is_insertable', ((pg_catalog.pg_relation_is_updatable("table".oid, true) & 8) = 8),
        'is_deletable', ((pg_catalog.pg_relation_is_updatable("table".oid, true) & 16) = 16)
      ) END,
      'description', description.description
    ) AS info
  -- table & schema
  FROM pg_catalog.pg_class "table"
  JOIN pg_catalog.pg_namespace schema
    ON schema.oid = "table".relnamespace
  -- description
  LEFT JOIN pg_catalog.pg_description description
    ON  description.classoid = 'pg_catalog.pg_class'::regclass
    AND description.objoid = "table".oid
    AND description.objsubid = 0
  -- columns
  LEFT JOIN LATERAL
    ( SELECT jsonb_agg(jsonb_build_object(
        'name',"column".attname,
        'position',"column".attnum,
        'type', coalesce(base_type.typname,"type".typname),
        'is_nullable', NOT "column".attnotnull,
        'description', pg_catalog.col_description("table".oid,"column".attnum)
      )) AS info
      FROM pg_catalog.pg_attribute "column"
      LEFT JOIN pg_catalog.pg_type "type"
        ON "type".oid = "column".atttypid
      LEFT JOIN pg_catalog.pg_type base_type
        ON "type".typtype = 'd' AND base_type.oid = "type".typbasetype
      WHERE "column".attrelid = "table".oid
        -- columns where attnum <= 0 are special, system-defined columns
        AND "column".attnum > 0
        -- dropped columns still exist in the system catalog as “zombie” columns, so ignore those
        AND NOT "column".attisdropped
    ) columns ON true
  -- primary key
  LEFT JOIN LATERAL
    ( SELECT jsonb_build_object(
        'constraint', jsonb_build_object('name', class.relname, 'oid', class.oid :: integer),
        'columns', coalesce(columns.info, '[]')
      ) AS info
      FROM pg_catalog.pg_index index
      JOIN pg_catalog.pg_class class
        ON class.oid = index.indexrelid
      LEFT JOIN LATERAL
        ( SELECT jsonb_agg("column".attname) AS info
          FROM pg_catalog.pg_attribute "column"
          WHERE "column".attrelid = "table".oid
            AND "column".attnum = ANY (index.indkey)
        ) AS columns ON true
      WHERE index.indrelid = "table".oid
        AND index.indisprimary
    ) primary_key ON true
  -- unique constraints
  LEFT JOIN LATERAL
    ( SELECT jsonb_agg(jsonb_build_object('name', class.relname, 'oid', class.oid :: integer)) AS info
      FROM pg_catalog.pg_index index
      JOIN pg_catalog.pg_class class
        ON class.oid = index.indexrelid
      WHERE index.indrelid = "table".oid
        AND index.indisunique
        AND NOT index.indisprimary
    ) unique_constraints ON true
  -- foreign keys
  LEFT JOIN LATERAL
    ( SELECT jsonb_agg(jsonb_build_object(
        'constraint', jsonb_build_object(
          'name', foreign_key.constraint_name,
          'oid', foreign_key.constraint_oid :: integer
        ),
        'columns', foreign_key.columns,
        'foreign_table', jsonb_build_object(
          'schema', foreign_key.ref_table_table_schema,
          'name', foreign_key.ref_table
        ),
        'foreign_columns', foreign_key.ref_columns
      )) AS info
      FROM hdb_catalog.hdb_foreign_key_constraint foreign_key
      WHERE foreign_key.table_schema = schema.nspname
        AND foreign_key.table_name = "table".relname
    ) foreign_key_constraints ON true
  -- all these identify table-like things
  WHERE "table".relkind IN ('r', 't', 'v', 'm', 'f', 'p');
CREATE VIEW hdb_catalog.hdb_function_info_agg AS (
  SELECT
    function_name,
    function_schema,
    row_to_json (
      (
        SELECT
          e
          FROM
              (
                SELECT
                  description,
                  has_variadic,
                  function_type,
                  return_type_schema,
                  return_type_name,
                  return_type_type,
                  returns_set,
                  input_arg_types,
                  input_arg_names,
                  default_args,
                  exists(
                    SELECT
                      1
                      FROM
                          information_schema.tables
                     WHERE
                table_schema = return_type_schema
            AND table_name = return_type_name
                  ) AS returns_table
              ) AS e
      )
    ) AS "function_info"
    FROM
        hdb_catalog.hdb_function_agg
);
CREATE OR REPLACE FUNCTION
  hdb_catalog.insert_event_log(schema_name text, table_name text, trigger_name text, op text, row_data json)
  RETURNS text AS $$
  DECLARE
    id text;
    payload json;
    session_variables json;
    server_version_num int;
    trace_context json;
  BEGIN
    id := gen_random_uuid();
    server_version_num := current_setting('server_version_num');
    IF server_version_num >= 90600 THEN
      session_variables := current_setting('hasura.user', 't');
      trace_context := current_setting('hasura.tracecontext', 't');
    ELSE
      BEGIN
        session_variables := current_setting('hasura.user');
      EXCEPTION WHEN OTHERS THEN
                  session_variables := NULL;
      END;
      BEGIN
        trace_context := current_setting('hasura.tracecontext');
      EXCEPTION WHEN OTHERS THEN
        trace_context := NULL;
      END;
    END IF;
    payload := json_build_object(
      'op', op,
      'data', row_data,
      'session_variables', session_variables,
      'trace_context', trace_context
    );
    INSERT INTO hdb_catalog.event_log
                (id, schema_name, table_name, trigger_name, payload)
    VALUES
    (id, schema_name, table_name, trigger_name, payload);
    RETURN id;
  END;
$$ LANGUAGE plpgsql;
CREATE TABLE hdb_catalog.hdb_query_collection
(
  collection_name TEXT PRIMARY KEY,
  collection_defn JSONB NOT NULL,
  comment TEXT NULL,
  is_system_defined boolean default false
);
CREATE TABLE hdb_catalog.hdb_allowlist
(
  collection_name TEXT UNIQUE
    REFERENCES hdb_catalog.hdb_query_collection(collection_name)
);
CREATE TABLE hdb_catalog.hdb_computed_field
(
  table_schema TEXT,
  table_name TEXT,
  computed_field_name TEXT,
  definition JSONB NOT NULL,
  comment TEXT NULL,
  PRIMARY KEY (table_schema, table_name, computed_field_name),
  FOREIGN KEY (table_schema, table_name) REFERENCES hdb_catalog.hdb_table(table_schema, table_name) ON UPDATE CASCADE
);
CREATE VIEW hdb_catalog.hdb_computed_field_function AS
(
  SELECT
    table_schema,
    table_name,
    computed_field_name,
    CASE
      WHEN (definition::jsonb -> 'function')::jsonb ->> 'name' IS NULL THEN definition::jsonb ->> 'function'
      ELSE (definition::jsonb -> 'function')::jsonb ->> 'name'
    END AS function_name,
    CASE
      WHEN (definition::jsonb -> 'function')::jsonb ->> 'schema' IS NULL THEN 'public'
      ELSE (definition::jsonb -> 'function')::jsonb ->> 'schema'
    END AS function_schema
  FROM hdb_catalog.hdb_computed_field
);
CREATE OR REPLACE FUNCTION hdb_catalog.check_violation(msg text) RETURNS bool AS
$$
  BEGIN
    RAISE check_violation USING message=msg;
  END;
$$ LANGUAGE plpgsql;
CREATE TABLE hdb_catalog.hdb_action
(
  action_name TEXT PRIMARY KEY,
  action_defn JSONB NOT NULL,
  comment TEXT NULL,
  is_system_defined boolean default false
);
CREATE TABLE hdb_catalog.hdb_action_permission
(
  action_name TEXT NOT NULL,
  role_name TEXT NOT NULL,
  definition JSONB NOT NULL DEFAULT '{}'::jsonb,
  comment    TEXT NULL,
  PRIMARY KEY (action_name, role_name),
  FOREIGN KEY (action_name) REFERENCES hdb_catalog.hdb_action(action_name) ON UPDATE CASCADE
);
CREATE TABLE hdb_catalog.hdb_action_log
(
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  -- we deliberately do not reference the action name
  -- because sometimes we may want to retain history
  -- after dropping the action
  action_name TEXT,
  input_payload JSONB NOT NULL,
  request_headers JSONB NOT NULL,
  session_variables JSONB NOT NULL,
  response_payload JSONB NULL,
  errors JSONB NULL,
  created_at timestamptz NOT NULL default now(),
  response_received_at timestamptz NULL,
  status text NOT NULL,
  CHECK (status IN ('created', 'processing', 'completed', 'error'))
);
CREATE TABLE hdb_catalog.hdb_custom_types
(
  custom_types jsonb NOT NULL
);
CREATE VIEW hdb_catalog.hdb_role AS
(
  SELECT DISTINCT role_name FROM (
    SELECT role_name FROM hdb_catalog.hdb_permission
    UNION ALL
    SELECT role_name FROM hdb_catalog.hdb_action_permission
  ) q
);
CREATE TABLE hdb_catalog.hdb_cron_triggers
(
  name TEXT PRIMARY KEY,
  webhook_conf JSON NOT NULL,
  cron_schedule TEXT NOT NULL,
  payload JSON,
  retry_conf JSON,
  header_conf JSON,
  include_in_metadata BOOLEAN NOT NULL DEFAULT FALSE,
  comment TEXT
);
CREATE TABLE hdb_catalog.hdb_cron_events
(
  id TEXT DEFAULT gen_random_uuid() PRIMARY KEY,
  trigger_name TEXT NOT NULL,
  scheduled_time TIMESTAMPTZ NOT NULL,
  status TEXT NOT NULL DEFAULT 'scheduled',
  tries INTEGER NOT NULL DEFAULT 0,
  created_at TIMESTAMP DEFAULT NOW(),
  next_retry_at TIMESTAMPTZ,
  FOREIGN KEY (trigger_name) REFERENCES hdb_catalog.hdb_cron_triggers(name)
    ON UPDATE CASCADE ON DELETE CASCADE,
  CONSTRAINT valid_status CHECK (status IN ('scheduled','locked','delivered','error','dead'))
);
CREATE INDEX hdb_cron_event_status ON hdb_catalog.hdb_cron_events (status);
CREATE TABLE hdb_catalog.hdb_cron_event_invocation_logs
(
  id TEXT DEFAULT gen_random_uuid() PRIMARY KEY,
  event_id TEXT,
  status INTEGER,
  request JSON,
  response JSON,
  created_at TIMESTAMP DEFAULT NOW(),
  FOREIGN KEY (event_id) REFERENCES hdb_catalog.hdb_cron_events (id)
    ON UPDATE CASCADE ON DELETE CASCADE
);
CREATE VIEW hdb_catalog.hdb_cron_events_stats AS
  SELECT ct.name,
         COALESCE(ce.upcoming_events_count,0) as upcoming_events_count,
         COALESCE(ce.max_scheduled_time, now()) as max_scheduled_time
  FROM hdb_catalog.hdb_cron_triggers ct
  LEFT JOIN
  ( SELECT trigger_name, count(*) as upcoming_events_count, max(scheduled_time) as max_scheduled_time
    FROM hdb_catalog.hdb_cron_events
    WHERE tries = 0 and status = 'scheduled'
    GROUP BY trigger_name
  ) ce
  ON ct.name = ce.trigger_name;
CREATE TABLE hdb_catalog.hdb_scheduled_events
(
  id TEXT DEFAULT gen_random_uuid() PRIMARY KEY,
  webhook_conf JSON NOT NULL,
  scheduled_time TIMESTAMPTZ NOT NULL,
  retry_conf JSON,
  payload JSON,
  header_conf JSON,
  status TEXT NOT NULL DEFAULT 'scheduled',
  tries INTEGER NOT NULL DEFAULT 0,
  created_at TIMESTAMP DEFAULT NOW(),
  next_retry_at TIMESTAMPTZ,
  comment TEXT,
  CONSTRAINT valid_status CHECK (status IN ('scheduled','locked','delivered','error','dead'))
);
CREATE INDEX hdb_scheduled_event_status ON hdb_catalog.hdb_scheduled_events (status);
CREATE TABLE hdb_catalog.hdb_scheduled_event_invocation_logs
(
id TEXT DEFAULT gen_random_uuid() PRIMARY KEY,
event_id TEXT,
status INTEGER,
request JSON,
response JSON,
created_at TIMESTAMP DEFAULT NOW(),
FOREIGN KEY (event_id) REFERENCES hdb_catalog.hdb_scheduled_events (id)
   ON DELETE CASCADE ON UPDATE CASCADE
);

            
              2020-09-03 14:53:06.722 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              10
              SELECT
              2020-09-03 14:53:06 EDT
              4/864
              2093
              LOG
              00000
              execute 1: select
  json_build_object(
    'tables', tables.items :: json,
    'relations', relations.items,
    'permissions', permissions.items,
    'event_triggers', event_triggers.items,
    'remote_schemas', remote_schemas.items,
    'functions', functions.items,
    'allowlist_collections', allowlist.item,
    'computed_fields', computed_field.items,
    'custom_types', custom_types.item,
    'actions', actions.items,
    'remote_relationships', remote_relationships.items,
    'cron_triggers', cron_triggers.items
  )
from
  (
    select
      coalesce(jsonb_agg(
        jsonb_build_object(
          'name', jsonb_build_object(
            'name', ht.table_name,
            'schema', ht.table_schema
          ),
          'is_enum', ht.is_enum,
          'is_system_defined', ht.is_system_defined,
          'configuration', ht.configuration,
          'info', t.info
        )
      ), '[]') as items
    from hdb_catalog.hdb_table ht
    left join hdb_catalog.hdb_table_info_agg t using (table_schema, table_name)
  ) as tables,
  (
    select
      coalesce(
        json_agg(
          json_build_object(
            'table',
            json_build_object(
              'schema', table_schema,
              'name', table_name
            ),
            'rel_name', rel_name,
            'rel_type', rel_type,
            'def', rel_def :: json,
            'comment', comment
          )
        ),
        '[]'
      ) as items
    from
      hdb_catalog.hdb_relationship
  ) as relations,
  (
    select
      coalesce(
        json_agg(
          json_build_object(
            'table',
            json_build_object(
              'schema', table_schema,
              'name', table_name
            ),
            'role', role_name,
            'perm_type', perm_type,
            'def', perm_def :: json,
            'comment', comment
          )
        ),
        '[]'
      ) as items
    from
      hdb_catalog.hdb_permission
  ) as permissions,
  (
    select
      coalesce(
        json_agg(
          json_build_object(
            'table',
            json_build_object(
              'schema', schema_name,
              'name', table_name
            ),
            'name', name,
            'def', configuration :: json
          )
        ),
        '[]'
      ) as items
    from
      hdb_catalog.event_triggers
  ) as event_triggers,
  (
    select
      coalesce(
        json_agg(
          json_build_object(
            'name',
            name,
            'definition', definition :: json,
            'comment', comment
          )
        ),
        '[]'
      ) as items
    from
      hdb_catalog.remote_schemas
  ) as remote_schemas,
  (
    select
      coalesce(json_agg(q.info), '[]') as items
    from
        (
        select
          json_build_object(
            'function',
            json_build_object(
              'schema', hf.function_schema,
              'name', hf.function_name
            ),
            'configuration', hf.configuration,
            'is_system_defined', hf.is_system_defined,
            'info', hf_agg.function_info
          ) as info
        from
          hdb_catalog.hdb_function hf
        left join lateral
            (
              select coalesce(json_agg(function_info), '[]') as function_info
              from hdb_catalog.hdb_function_info_agg
               where function_name = hf.function_name
                     and function_schema = hf.function_schema
            ) hf_agg on 'true'
      ) as q
   ) as functions,
  (
    select
      coalesce(json_agg(hqc.collection_defn), '[]') as item
    from hdb_catalog.hdb_allowlist ha
    left outer join
         hdb_catalog.hdb_query_collection hqc
         on (hqc.collection_name = ha.collection_name)
  ) as allowlist,
  (
    select
      coalesce(json_agg(
        json_build_object('computed_field', cc.computed_field,
                          'function_info', fi.function_info
                         )
      ), '[]') as items
    from
      (
        select json_build_object(
          'table', jsonb_build_object('name', hcc.table_name,'schema', hcc.table_schema),
          'name', hcc.computed_field_name,
          'definition', hcc.definition,
          'comment', hcc.comment
        ) as computed_field,
        hccf.function_name,
        hccf.function_schema
        from hdb_catalog.hdb_computed_field hcc
        left outer join
             hdb_catalog.hdb_computed_field_function hccf
             on ( hcc.table_name = hccf.table_name
                 and hcc.table_schema = hccf.table_schema
                 and hcc.computed_field_name = hccf.computed_field_name
                )
      ) cc
    left join lateral
      (
        select coalesce(json_agg(function_info), '[]') as function_info
        from hdb_catalog.hdb_function_info_agg
        where function_name = cc.function_name and function_schema = cc.function_schema
      ) fi on 'true'
  ) as computed_field,
  (
    select
      json_build_object(
        'custom_types',
         coalesce((select custom_types from hdb_catalog.hdb_custom_types), '{}'),
        'pg_scalars', -- See Note [Postgres scalars in custom types]
         coalesce((select json_agg(typname) from pg_catalog.pg_type where typtype = 'b'), '[]')
      ) as item
  ) as custom_types,
  (
    select
      coalesce(
        json_agg(
          json_build_object(
            'name', ha.action_name,
            'definition', ha.action_defn :: json,
            'comment', ha.comment,
            'permissions', p.items
          )
        ),
        '[]'
      ) as items
    from
      hdb_catalog.hdb_action ha
      left join lateral
      (
        select
          coalesce(
            json_agg(
              json_build_object(
                'action', hap.action_name,
                'role', hap.role_name,
                'comment', hap.comment
              )
            ),
            '[]'
          ) as items
          from
              hdb_catalog.hdb_action_permission hap
          where hap.action_name = ha.action_name
      ) p on 'true'
  ) as actions,
  (
    select coalesce(json_agg(
      json_build_object(
        'name', remote_relationship_name,
        'table', json_build_object('schema', table_schema, 'name', table_name),
        'hasura_fields', definition -> 'hasura_fields',
        'remote_schema', definition -> 'remote_schema',
        'remote_field', definition -> 'remote_field'
      )
    ),'[]') as items
    from hdb_catalog.hdb_remote_relationship
  ) as remote_relationships,
  (
    select
      coalesce(
        json_agg(
          json_build_object(
            'name', name,
            'webhook_conf', webhook_conf :: json,
            'cron_schedule', cron_schedule,
            'payload', payload :: json,
            'retry_conf', retry_conf :: json,
            'header_conf', header_conf :: json,
            'comment', comment
          )
        ),
        '[]'
      ) as items
      from
          hdb_catalog.hdb_cron_triggers
  ) as cron_triggers

            
              2020-09-03 14:53:06.726 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              11
              idle in transaction
              2020-09-03 14:53:06 EDT
              4/864
              2093
              LOG
              00000
              statement: DELETE FROM hdb_catalog.hdb_function WHERE is_system_defined = 'true';
DELETE FROM hdb_catalog.hdb_permission WHERE is_system_defined = 'true';
DELETE FROM hdb_catalog.hdb_relationship WHERE is_system_defined = 'true';
DELETE FROM hdb_catalog.hdb_table WHERE is_system_defined = 'true';
DELETE FROM hdb_catalog.hdb_query_collection WHERE is_system_defined = 'true';

            
              2020-09-03 14:53:06.727 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              12
              INSERT
              2020-09-03 14:53:06 EDT
              4/864
              2093
              LOG
              00000
              execute <unnamed>:
    INSERT INTO "hdb_catalog"."hdb_table"
      (table_schema, table_name, is_system_defined, is_enum, configuration)
    VALUES ($1, $2, $3, $4, $5)
  
              parameters: $1 = 'information_schema', $2 = 'tables', $3 = 't', $4 = 'f', $5 = '{"custom_root_fields":{},"custom_column_names":{}}'

            
              2020-09-03 14:53:06.727 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              13
              INSERT
              2020-09-03 14:53:06 EDT
              4/864
              2093
              LOG
              00000
              execute <unnamed>:
    INSERT INTO "hdb_catalog"."hdb_table"
      (table_schema, table_name, is_system_defined, is_enum, configuration)
    VALUES ($1, $2, $3, $4, $5)
  
              parameters: $1 = 'information_schema', $2 = 'schemata', $3 = 't', $4 = 'f', $5 = '{"custom_root_fields":{},"custom_column_names":{}}'

            
              2020-09-03 14:53:06.728 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              14
              INSERT
              2020-09-03 14:53:06 EDT
              4/864
              2093
              LOG
              00000
              execute <unnamed>:
    INSERT INTO "hdb_catalog"."hdb_table"
      (table_schema, table_name, is_system_defined, is_enum, configuration)
    VALUES ($1, $2, $3, $4, $5)
  
              parameters: $1 = 'information_schema', $2 = 'views', $3 = 't', $4 = 'f', $5 = '{"custom_root_fields":{},"custom_column_names":{}}'

            
              2020-09-03 14:53:06.728 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              15
              INSERT
              2020-09-03 14:53:06 EDT
              4/864
              2093
              LOG
              00000
              execute <unnamed>:
    INSERT INTO "hdb_catalog"."hdb_table"
      (table_schema, table_name, is_system_defined, is_enum, configuration)
    VALUES ($1, $2, $3, $4, $5)
  
              parameters: $1 = 'information_schema', $2 = 'columns', $3 = 't', $4 = 'f', $5 = '{"custom_root_fields":{},"custom_column_names":{}}'

            
              2020-09-03 14:53:06.729 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              16
              INSERT
              2020-09-03 14:53:06 EDT
              4/864
              2093
              LOG
              00000
              execute <unnamed>:
    INSERT INTO "hdb_catalog"."hdb_table"
      (table_schema, table_name, is_system_defined, is_enum, configuration)
    VALUES ($1, $2, $3, $4, $5)
  
              parameters: $1 = 'hdb_catalog', $2 = 'hdb_table', $3 = 't', $4 = 'f', $5 = '{"custom_root_fields":{},"custom_column_names":{}}'

            
              2020-09-03 14:53:06.729 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              17
              INSERT
              2020-09-03 14:53:06 EDT
              4/864
              2093
              LOG
              00000
              execute 2:
      INSERT INTO
        hdb_catalog.hdb_relationship
        (table_schema, table_name, rel_name, rel_type, rel_def, comment, is_system_defined)
      VALUES ($1, $2, $3, $4, $5 :: jsonb, $6, $7) 
              parameters: $1 = 'hdb_catalog', $2 = 'hdb_table', $3 = 'detail', $4 = 'object', $5 = '{"manual_configuration":{"remote_table":{"schema":"information_schema","name":"tables"},"column_mapping":{"table_schema":"table_schema","table_name":"table_name"}}}', $6 = NULL, $7 = 't'

            
              2020-09-03 14:53:06.730 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              18
              INSERT
              2020-09-03 14:53:06 EDT
              4/864
              2093
              LOG
              00000
              execute 2:
      INSERT INTO
        hdb_catalog.hdb_relationship
        (table_schema, table_name, rel_name, rel_type, rel_def, comment, is_system_defined)
      VALUES ($1, $2, $3, $4, $5 :: jsonb, $6, $7) 
              parameters: $1 = 'hdb_catalog', $2 = 'hdb_table', $3 = 'primary_key', $4 = 'object', $5 = '{"manual_configuration":{"remote_table":{"schema":"hdb_catalog","name":"hdb_primary_key"},"column_mapping":{"table_schema":"table_schema","table_name":"table_name"}}}', $6 = NULL, $7 = 't'

            
              2020-09-03 14:53:06.731 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              19
              INSERT
              2020-09-03 14:53:06 EDT
              4/864
              2093
              LOG
              00000
              execute 2:
      INSERT INTO
        hdb_catalog.hdb_relationship
        (table_schema, table_name, rel_name, rel_type, rel_def, comment, is_system_defined)
      VALUES ($1, $2, $3, $4, $5 :: jsonb, $6, $7) 
              parameters: $1 = 'hdb_catalog', $2 = 'hdb_table', $3 = 'columns', $4 = 'array', $5 = '{"manual_configuration":{"remote_table":{"schema":"information_schema","name":"columns"},"column_mapping":{"table_schema":"table_schema","table_name":"table_name"}}}', $6 = NULL, $7 = 't'

            
              2020-09-03 14:53:06.731 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              20
              INSERT
              2020-09-03 14:53:06 EDT
              4/864
              2093
              LOG
              00000
              execute 2:
      INSERT INTO
        hdb_catalog.hdb_relationship
        (table_schema, table_name, rel_name, rel_type, rel_def, comment, is_system_defined)
      VALUES ($1, $2, $3, $4, $5 :: jsonb, $6, $7) 
              parameters: $1 = 'hdb_catalog', $2 = 'hdb_table', $3 = 'foreign_key_constraints', $4 = 'array', $5 = '{"manual_configuration":{"remote_table":{"schema":"hdb_catalog","name":"hdb_foreign_key_constraint"},"column_mapping":{"table_schema":"table_schema","table_name":"table_name"}}}', $6 = NULL, $7 = 't'

            
              2020-09-03 14:53:06.732 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              21
              INSERT
              2020-09-03 14:53:06 EDT
              4/864
              2093
              LOG
              00000
              execute 2:
      INSERT INTO
        hdb_catalog.hdb_relationship
        (table_schema, table_name, rel_name, rel_type, rel_def, comment, is_system_defined)
      VALUES ($1, $2, $3, $4, $5 :: jsonb, $6, $7) 
              parameters: $1 = 'hdb_catalog', $2 = 'hdb_table', $3 = 'relationships', $4 = 'array', $5 = '{"manual_configuration":{"remote_table":{"schema":"hdb_catalog","name":"hdb_relationship"},"column_mapping":{"table_schema":"table_schema","table_name":"table_name"}}}', $6 = NULL, $7 = 't'

            
              2020-09-03 14:53:06.732 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              22
              INSERT
              2020-09-03 14:53:06 EDT
              4/864
              2093
              LOG
              00000
              execute 2:
      INSERT INTO
        hdb_catalog.hdb_relationship
        (table_schema, table_name, rel_name, rel_type, rel_def, comment, is_system_defined)
      VALUES ($1, $2, $3, $4, $5 :: jsonb, $6, $7) 
              parameters: $1 = 'hdb_catalog', $2 = 'hdb_table', $3 = 'permissions', $4 = 'array', $5 = '{"manual_configuration":{"remote_table":{"schema":"hdb_catalog","name":"hdb_permission_agg"},"column_mapping":{"table_schema":"table_schema","table_name":"table_name"}}}', $6 = NULL, $7 = 't'

            
              2020-09-03 14:53:06.733 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              23
              INSERT
              2020-09-03 14:53:06 EDT
              4/864
              2093
              LOG
              00000
              execute 2:
      INSERT INTO
        hdb_catalog.hdb_relationship
        (table_schema, table_name, rel_name, rel_type, rel_def, comment, is_system_defined)
      VALUES ($1, $2, $3, $4, $5 :: jsonb, $6, $7) 
              parameters: $1 = 'hdb_catalog', $2 = 'hdb_table', $3 = 'computed_fields', $4 = 'array', $5 = '{"manual_configuration":{"remote_table":{"schema":"hdb_catalog","name":"hdb_computed_field"},"column_mapping":{"table_schema":"table_schema","table_name":"table_name"}}}', $6 = NULL, $7 = 't'

            
              2020-09-03 14:53:06.733 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              24
              INSERT
              2020-09-03 14:53:06 EDT
              4/864
              2093
              LOG
              00000
              execute 2:
      INSERT INTO
        hdb_catalog.hdb_relationship
        (table_schema, table_name, rel_name, rel_type, rel_def, comment, is_system_defined)
      VALUES ($1, $2, $3, $4, $5 :: jsonb, $6, $7) 
              parameters: $1 = 'hdb_catalog', $2 = 'hdb_table', $3 = 'check_constraints', $4 = 'array', $5 = '{"manual_configuration":{"remote_table":{"schema":"hdb_catalog","name":"hdb_check_constraint"},"column_mapping":{"table_schema":"table_schema","table_name":"table_name"}}}', $6 = NULL, $7 = 't'

            
              2020-09-03 14:53:06.733 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              25
              INSERT
              2020-09-03 14:53:06 EDT
              4/864
              2093
              LOG
              00000
              execute 2:
      INSERT INTO
        hdb_catalog.hdb_relationship
        (table_schema, table_name, rel_name, rel_type, rel_def, comment, is_system_defined)
      VALUES ($1, $2, $3, $4, $5 :: jsonb, $6, $7) 
              parameters: $1 = 'hdb_catalog', $2 = 'hdb_table', $3 = 'unique_constraints', $4 = 'array', $5 = '{"manual_configuration":{"remote_table":{"schema":"hdb_catalog","name":"hdb_unique_constraint"},"column_mapping":{"table_schema":"table_schema","table_name":"table_name"}}}', $6 = NULL, $7 = 't'

            
              2020-09-03 14:53:06.734 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              26
              INSERT
              2020-09-03 14:53:06 EDT
              4/864
              2093
              LOG
              00000
              execute <unnamed>:
    INSERT INTO "hdb_catalog"."hdb_table"
      (table_schema, table_name, is_system_defined, is_enum, configuration)
    VALUES ($1, $2, $3, $4, $5)
  
              parameters: $1 = 'hdb_catalog', $2 = 'hdb_primary_key', $3 = 't', $4 = 'f', $5 = '{"custom_root_fields":{},"custom_column_names":{}}'

            
              2020-09-03 14:53:06.734 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              27
              INSERT
              2020-09-03 14:53:06 EDT
              4/864
              2093
              LOG
              00000
              execute <unnamed>:
    INSERT INTO "hdb_catalog"."hdb_table"
      (table_schema, table_name, is_system_defined, is_enum, configuration)
    VALUES ($1, $2, $3, $4, $5)
  
              parameters: $1 = 'hdb_catalog', $2 = 'hdb_foreign_key_constraint', $3 = 't', $4 = 'f', $5 = '{"custom_root_fields":{},"custom_column_names":{}}'

            
              2020-09-03 14:53:06.735 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              28
              INSERT
              2020-09-03 14:53:06 EDT
              4/864
              2093
              LOG
              00000
              execute <unnamed>:
    INSERT INTO "hdb_catalog"."hdb_table"
      (table_schema, table_name, is_system_defined, is_enum, configuration)
    VALUES ($1, $2, $3, $4, $5)
  
              parameters: $1 = 'hdb_catalog', $2 = 'hdb_relationship', $3 = 't', $4 = 'f', $5 = '{"custom_root_fields":{},"custom_column_names":{}}'

            
              2020-09-03 14:53:06.735 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              29
              INSERT
              2020-09-03 14:53:06 EDT
              4/864
              2093
              LOG
              00000
              execute <unnamed>:
    INSERT INTO "hdb_catalog"."hdb_table"
      (table_schema, table_name, is_system_defined, is_enum, configuration)
    VALUES ($1, $2, $3, $4, $5)
  
              parameters: $1 = 'hdb_catalog', $2 = 'hdb_permission_agg', $3 = 't', $4 = 'f', $5 = '{"custom_root_fields":{},"custom_column_names":{}}'

            
              2020-09-03 14:53:06.736 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              30
              INSERT
              2020-09-03 14:53:06 EDT
              4/864
              2093
              LOG
              00000
              execute <unnamed>:
    INSERT INTO "hdb_catalog"."hdb_table"
      (table_schema, table_name, is_system_defined, is_enum, configuration)
    VALUES ($1, $2, $3, $4, $5)
  
              parameters: $1 = 'hdb_catalog', $2 = 'hdb_computed_field', $3 = 't', $4 = 'f', $5 = '{"custom_root_fields":{},"custom_column_names":{}}'

            
              2020-09-03 14:53:06.736 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              31
              INSERT
              2020-09-03 14:53:06 EDT
              4/864
              2093
              LOG
              00000
              execute <unnamed>:
    INSERT INTO "hdb_catalog"."hdb_table"
      (table_schema, table_name, is_system_defined, is_enum, configuration)
    VALUES ($1, $2, $3, $4, $5)
  
              parameters: $1 = 'hdb_catalog', $2 = 'hdb_check_constraint', $3 = 't', $4 = 'f', $5 = '{"custom_root_fields":{},"custom_column_names":{}}'

            
              2020-09-03 14:53:06.737 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              32
              INSERT
              2020-09-03 14:53:06 EDT
              4/864
              2093
              LOG
              00000
              execute <unnamed>:
    INSERT INTO "hdb_catalog"."hdb_table"
      (table_schema, table_name, is_system_defined, is_enum, configuration)
    VALUES ($1, $2, $3, $4, $5)
  
              parameters: $1 = 'hdb_catalog', $2 = 'hdb_unique_constraint', $3 = 't', $4 = 'f', $5 = '{"custom_root_fields":{},"custom_column_names":{}}'

            
              2020-09-03 14:53:06.737 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              33
              INSERT
              2020-09-03 14:53:06 EDT
              4/864
              2093
              LOG
              00000
              execute <unnamed>:
    INSERT INTO "hdb_catalog"."hdb_table"
      (table_schema, table_name, is_system_defined, is_enum, configuration)
    VALUES ($1, $2, $3, $4, $5)
  
              parameters: $1 = 'hdb_catalog', $2 = 'hdb_remote_relationship', $3 = 't', $4 = 'f', $5 = '{"custom_root_fields":{},"custom_column_names":{}}'

            
              2020-09-03 14:53:06.737 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              34
              INSERT
              2020-09-03 14:53:06 EDT
              4/864
              2093
              LOG
              00000
              execute <unnamed>:
    INSERT INTO "hdb_catalog"."hdb_table"
      (table_schema, table_name, is_system_defined, is_enum, configuration)
    VALUES ($1, $2, $3, $4, $5)
  
              parameters: $1 = 'hdb_catalog', $2 = 'event_triggers', $3 = 't', $4 = 'f', $5 = '{"custom_root_fields":{},"custom_column_names":{}}'

            
              2020-09-03 14:53:06.738 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              35
              INSERT
              2020-09-03 14:53:06 EDT
              4/864
              2093
              LOG
              00000
              execute 2:
      INSERT INTO
        hdb_catalog.hdb_relationship
        (table_schema, table_name, rel_name, rel_type, rel_def, comment, is_system_defined)
      VALUES ($1, $2, $3, $4, $5 :: jsonb, $6, $7) 
              parameters: $1 = 'hdb_catalog', $2 = 'event_triggers', $3 = 'events', $4 = 'array', $5 = '{"manual_configuration":{"remote_table":{"schema":"hdb_catalog","name":"event_log"},"column_mapping":{"name":"trigger_name"}}}', $6 = NULL, $7 = 't'

            
              2020-09-03 14:53:06.738 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              36
              INSERT
              2020-09-03 14:53:06 EDT
              4/864
              2093
              LOG
              00000
              execute <unnamed>:
    INSERT INTO "hdb_catalog"."hdb_table"
      (table_schema, table_name, is_system_defined, is_enum, configuration)
    VALUES ($1, $2, $3, $4, $5)
  
              parameters: $1 = 'hdb_catalog', $2 = 'event_log', $3 = 't', $4 = 'f', $5 = '{"custom_root_fields":{},"custom_column_names":{}}'

            
              2020-09-03 14:53:06.739 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              37
              INSERT
              2020-09-03 14:53:06 EDT
              4/864
              2093
              LOG
              00000
              execute 2:
      INSERT INTO
        hdb_catalog.hdb_relationship
        (table_schema, table_name, rel_name, rel_type, rel_def, comment, is_system_defined)
      VALUES ($1, $2, $3, $4, $5 :: jsonb, $6, $7) 
              parameters: $1 = 'hdb_catalog', $2 = 'event_log', $3 = 'trigger', $4 = 'object', $5 = '{"manual_configuration":{"remote_table":{"schema":"hdb_catalog","name":"event_triggers"},"column_mapping":{"trigger_name":"name"}}}', $6 = NULL, $7 = 't'

            
              2020-09-03 14:53:06.739 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              38
              INSERT
              2020-09-03 14:53:06 EDT
              4/864
              2093
              LOG
              00000
              execute 2:
      INSERT INTO
        hdb_catalog.hdb_relationship
        (table_schema, table_name, rel_name, rel_type, rel_def, comment, is_system_defined)
      VALUES ($1, $2, $3, $4, $5 :: jsonb, $6, $7) 
              parameters: $1 = 'hdb_catalog', $2 = 'event_log', $3 = 'logs', $4 = 'array', $5 = '{"foreign_key_constraint_on":{"column":"event_id","table":{"schema":"hdb_catalog","name":"event_invocation_logs"}}}', $6 = NULL, $7 = 't'

            
              2020-09-03 14:53:06.739 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              39
              INSERT
              2020-09-03 14:53:06 EDT
              4/864
              2093
              LOG
              00000
              execute <unnamed>:
    INSERT INTO "hdb_catalog"."hdb_table"
      (table_schema, table_name, is_system_defined, is_enum, configuration)
    VALUES ($1, $2, $3, $4, $5)
  
              parameters: $1 = 'hdb_catalog', $2 = 'event_invocation_logs', $3 = 't', $4 = 'f', $5 = '{"custom_root_fields":{},"custom_column_names":{}}'

            
              2020-09-03 14:53:06.739 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              40
              INSERT
              2020-09-03 14:53:06 EDT
              4/864
              2093
              LOG
              00000
              execute 2:
      INSERT INTO
        hdb_catalog.hdb_relationship
        (table_schema, table_name, rel_name, rel_type, rel_def, comment, is_system_defined)
      VALUES ($1, $2, $3, $4, $5 :: jsonb, $6, $7) 
              parameters: $1 = 'hdb_catalog', $2 = 'event_invocation_logs', $3 = 'event', $4 = 'object', $5 = '{"foreign_key_constraint_on":"event_id"}', $6 = NULL, $7 = 't'

            
              2020-09-03 14:53:06.740 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              41
              INSERT
              2020-09-03 14:53:06 EDT
              4/864
              2093
              LOG
              00000
              execute <unnamed>:
    INSERT INTO "hdb_catalog"."hdb_table"
      (table_schema, table_name, is_system_defined, is_enum, configuration)
    VALUES ($1, $2, $3, $4, $5)
  
              parameters: $1 = 'hdb_catalog', $2 = 'hdb_function', $3 = 't', $4 = 'f', $5 = '{"custom_root_fields":{},"custom_column_names":{}}'

            
              2020-09-03 14:53:06.740 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              42
              INSERT
              2020-09-03 14:53:06 EDT
              4/864
              2093
              LOG
              00000
              execute <unnamed>:
    INSERT INTO "hdb_catalog"."hdb_table"
      (table_schema, table_name, is_system_defined, is_enum, configuration)
    VALUES ($1, $2, $3, $4, $5)
  
              parameters: $1 = 'hdb_catalog', $2 = 'hdb_function_agg', $3 = 't', $4 = 'f', $5 = '{"custom_root_fields":{},"custom_column_names":{}}'

            
              2020-09-03 14:53:06.740 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              43
              INSERT
              2020-09-03 14:53:06 EDT
              4/864
              2093
              LOG
              00000
              execute 2:
      INSERT INTO
        hdb_catalog.hdb_relationship
        (table_schema, table_name, rel_name, rel_type, rel_def, comment, is_system_defined)
      VALUES ($1, $2, $3, $4, $5 :: jsonb, $6, $7) 
              parameters: $1 = 'hdb_catalog', $2 = 'hdb_function_agg', $3 = 'return_table_info', $4 = 'object', $5 = '{"manual_configuration":{"remote_table":{"schema":"hdb_catalog","name":"hdb_table"},"column_mapping":{"return_type_schema":"table_schema","return_type_name":"table_name"}}}', $6 = NULL, $7 = 't'

            
              2020-09-03 14:53:06.741 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              44
              INSERT
              2020-09-03 14:53:06 EDT
              4/864
              2093
              LOG
              00000
              execute <unnamed>:
    INSERT INTO "hdb_catalog"."hdb_table"
      (table_schema, table_name, is_system_defined, is_enum, configuration)
    VALUES ($1, $2, $3, $4, $5)
  
              parameters: $1 = 'hdb_catalog', $2 = 'remote_schemas', $3 = 't', $4 = 'f', $5 = '{"custom_root_fields":{},"custom_column_names":{}}'

            
              2020-09-03 14:53:06.741 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              45
              INSERT
              2020-09-03 14:53:06 EDT
              4/864
              2093
              LOG
              00000
              execute <unnamed>:
    INSERT INTO "hdb_catalog"."hdb_table"
      (table_schema, table_name, is_system_defined, is_enum, configuration)
    VALUES ($1, $2, $3, $4, $5)
  
              parameters: $1 = 'hdb_catalog', $2 = 'hdb_version', $3 = 't', $4 = 'f', $5 = '{"custom_root_fields":{},"custom_column_names":{}}'

            
              2020-09-03 14:53:06.741 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              46
              INSERT
              2020-09-03 14:53:06 EDT
              4/864
              2093
              LOG
              00000
              execute <unnamed>:
    INSERT INTO "hdb_catalog"."hdb_table"
      (table_schema, table_name, is_system_defined, is_enum, configuration)
    VALUES ($1, $2, $3, $4, $5)
  
              parameters: $1 = 'hdb_catalog', $2 = 'hdb_query_collection', $3 = 't', $4 = 'f', $5 = '{"custom_root_fields":{},"custom_column_names":{}}'

            
              2020-09-03 14:53:06.741 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              47
              INSERT
              2020-09-03 14:53:06 EDT
              4/864
              2093
              LOG
              00000
              execute <unnamed>:
    INSERT INTO "hdb_catalog"."hdb_table"
      (table_schema, table_name, is_system_defined, is_enum, configuration)
    VALUES ($1, $2, $3, $4, $5)
  
              parameters: $1 = 'hdb_catalog', $2 = 'hdb_allowlist', $3 = 't', $4 = 'f', $5 = '{"custom_root_fields":{},"custom_column_names":{}}'

            
              2020-09-03 14:53:06.742 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              48
              INSERT
              2020-09-03 14:53:06 EDT
              4/864
              2093
              LOG
              00000
              execute <unnamed>:
    INSERT INTO "hdb_catalog"."hdb_table"
      (table_schema, table_name, is_system_defined, is_enum, configuration)
    VALUES ($1, $2, $3, $4, $5)
  
              parameters: $1 = 'hdb_catalog', $2 = 'hdb_custom_types', $3 = 't', $4 = 'f', $5 = '{"custom_root_fields":{},"custom_column_names":{}}'

            
              2020-09-03 14:53:06.742 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              49
              INSERT
              2020-09-03 14:53:06 EDT
              4/864
              2093
              LOG
              00000
              execute <unnamed>:
    INSERT INTO "hdb_catalog"."hdb_table"
      (table_schema, table_name, is_system_defined, is_enum, configuration)
    VALUES ($1, $2, $3, $4, $5)
  
              parameters: $1 = 'hdb_catalog', $2 = 'hdb_action_permission', $3 = 't', $4 = 'f', $5 = '{"custom_root_fields":{},"custom_column_names":{}}'

            
              2020-09-03 14:53:06.742 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              50
              INSERT
              2020-09-03 14:53:06 EDT
              4/864
              2093
              LOG
              00000
              execute <unnamed>:
    INSERT INTO "hdb_catalog"."hdb_table"
      (table_schema, table_name, is_system_defined, is_enum, configuration)
    VALUES ($1, $2, $3, $4, $5)
  
              parameters: $1 = 'hdb_catalog', $2 = 'hdb_action', $3 = 't', $4 = 'f', $5 = '{"custom_root_fields":{},"custom_column_names":{}}'

            
              2020-09-03 14:53:06.743 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              51
              INSERT
              2020-09-03 14:53:06 EDT
              4/864
              2093
              LOG
              00000
              execute 2:
      INSERT INTO
        hdb_catalog.hdb_relationship
        (table_schema, table_name, rel_name, rel_type, rel_def, comment, is_system_defined)
      VALUES ($1, $2, $3, $4, $5 :: jsonb, $6, $7) 
              parameters: $1 = 'hdb_catalog', $2 = 'hdb_action', $3 = 'permissions', $4 = 'array', $5 = '{"manual_configuration":{"remote_table":{"schema":"hdb_catalog","name":"hdb_action_permission"},"column_mapping":{"action_name":"action_name"}}}', $6 = NULL, $7 = 't'

            
              2020-09-03 14:53:06.743 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              52
              INSERT
              2020-09-03 14:53:06 EDT
              4/864
              2093
              LOG
              00000
              execute <unnamed>:
    INSERT INTO "hdb_catalog"."hdb_table"
      (table_schema, table_name, is_system_defined, is_enum, configuration)
    VALUES ($1, $2, $3, $4, $5)
  
              parameters: $1 = 'hdb_catalog', $2 = 'hdb_action_log', $3 = 't', $4 = 'f', $5 = '{"custom_root_fields":{},"custom_column_names":{}}'

            
              2020-09-03 14:53:06.743 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              53
              INSERT
              2020-09-03 14:53:06 EDT
              4/864
              2093
              LOG
              00000
              execute <unnamed>:
    INSERT INTO "hdb_catalog"."hdb_table"
      (table_schema, table_name, is_system_defined, is_enum, configuration)
    VALUES ($1, $2, $3, $4, $5)
  
              parameters: $1 = 'hdb_catalog', $2 = 'hdb_role', $3 = 't', $4 = 'f', $5 = '{"custom_root_fields":{},"custom_column_names":{}}'

            
              2020-09-03 14:53:06.744 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              54
              INSERT
              2020-09-03 14:53:06 EDT
              4/864
              2093
              LOG
              00000
              execute 2:
      INSERT INTO
        hdb_catalog.hdb_relationship
        (table_schema, table_name, rel_name, rel_type, rel_def, comment, is_system_defined)
      VALUES ($1, $2, $3, $4, $5 :: jsonb, $6, $7) 
              parameters: $1 = 'hdb_catalog', $2 = 'hdb_role', $3 = 'action_permissions', $4 = 'array', $5 = '{"manual_configuration":{"remote_table":{"schema":"hdb_catalog","name":"hdb_action_permission"},"column_mapping":{"role_name":"role_name"}}}', $6 = NULL, $7 = 't'

            
              2020-09-03 14:53:06.744 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              55
              INSERT
              2020-09-03 14:53:06 EDT
              4/864
              2093
              LOG
              00000
              execute 2:
      INSERT INTO
        hdb_catalog.hdb_relationship
        (table_schema, table_name, rel_name, rel_type, rel_def, comment, is_system_defined)
      VALUES ($1, $2, $3, $4, $5 :: jsonb, $6, $7) 
              parameters: $1 = 'hdb_catalog', $2 = 'hdb_role', $3 = 'permissions', $4 = 'array', $5 = '{"manual_configuration":{"remote_table":{"schema":"hdb_catalog","name":"hdb_permission_agg"},"column_mapping":{"role_name":"role_name"}}}', $6 = NULL, $7 = 't'

            
              2020-09-03 14:53:06.744 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              56
              INSERT
              2020-09-03 14:53:06 EDT
              4/864
              2093
              LOG
              00000
              execute <unnamed>:
    INSERT INTO "hdb_catalog"."hdb_table"
      (table_schema, table_name, is_system_defined, is_enum, configuration)
    VALUES ($1, $2, $3, $4, $5)
  
              parameters: $1 = 'hdb_catalog', $2 = 'hdb_cron_triggers', $3 = 't', $4 = 'f', $5 = '{"custom_root_fields":{},"custom_column_names":{}}'

            
              2020-09-03 14:53:06.744 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              57
              INSERT
              2020-09-03 14:53:06 EDT
              4/864
              2093
              LOG
              00000
              execute 2:
      INSERT INTO
        hdb_catalog.hdb_relationship
        (table_schema, table_name, rel_name, rel_type, rel_def, comment, is_system_defined)
      VALUES ($1, $2, $3, $4, $5 :: jsonb, $6, $7) 
              parameters: $1 = 'hdb_catalog', $2 = 'hdb_cron_triggers', $3 = 'cron_events', $4 = 'array', $5 = '{"foreign_key_constraint_on":{"column":"trigger_name","table":{"schema":"hdb_catalog","name":"hdb_cron_events"}}}', $6 = NULL, $7 = 't'

            
              2020-09-03 14:53:06.745 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              58
              INSERT
              2020-09-03 14:53:06 EDT
              4/864
              2093
              LOG
              00000
              execute <unnamed>:
    INSERT INTO "hdb_catalog"."hdb_table"
      (table_schema, table_name, is_system_defined, is_enum, configuration)
    VALUES ($1, $2, $3, $4, $5)
  
              parameters: $1 = 'hdb_catalog', $2 = 'hdb_cron_events', $3 = 't', $4 = 'f', $5 = '{"custom_root_fields":{},"custom_column_names":{}}'

            
              2020-09-03 14:53:06.745 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              59
              INSERT
              2020-09-03 14:53:06 EDT
              4/864
              2093
              LOG
              00000
              execute 2:
      INSERT INTO
        hdb_catalog.hdb_relationship
        (table_schema, table_name, rel_name, rel_type, rel_def, comment, is_system_defined)
      VALUES ($1, $2, $3, $4, $5 :: jsonb, $6, $7) 
              parameters: $1 = 'hdb_catalog', $2 = 'hdb_cron_events', $3 = 'cron_trigger', $4 = 'object', $5 = '{"foreign_key_constraint_on":"trigger_name"}', $6 = NULL, $7 = 't'

            
              2020-09-03 14:53:06.745 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              60
              INSERT
              2020-09-03 14:53:06 EDT
              4/864
              2093
              LOG
              00000
              execute 2:
      INSERT INTO
        hdb_catalog.hdb_relationship
        (table_schema, table_name, rel_name, rel_type, rel_def, comment, is_system_defined)
      VALUES ($1, $2, $3, $4, $5 :: jsonb, $6, $7) 
              parameters: $1 = 'hdb_catalog', $2 = 'hdb_cron_events', $3 = 'cron_event_logs', $4 = 'array', $5 = '{"foreign_key_constraint_on":{"column":"event_id","table":{"schema":"hdb_catalog","name":"hdb_cron_event_invocation_logs"}}}', $6 = NULL, $7 = 't'

            
              2020-09-03 14:53:06.746 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              61
              INSERT
              2020-09-03 14:53:06 EDT
              4/864
              2093
              LOG
              00000
              execute <unnamed>:
    INSERT INTO "hdb_catalog"."hdb_table"
      (table_schema, table_name, is_system_defined, is_enum, configuration)
    VALUES ($1, $2, $3, $4, $5)
  
              parameters: $1 = 'hdb_catalog', $2 = 'hdb_cron_event_invocation_logs', $3 = 't', $4 = 'f', $5 = '{"custom_root_fields":{},"custom_column_names":{}}'

            
              2020-09-03 14:53:06.746 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              62
              INSERT
              2020-09-03 14:53:06 EDT
              4/864
              2093
              LOG
              00000
              execute 2:
      INSERT INTO
        hdb_catalog.hdb_relationship
        (table_schema, table_name, rel_name, rel_type, rel_def, comment, is_system_defined)
      VALUES ($1, $2, $3, $4, $5 :: jsonb, $6, $7) 
              parameters: $1 = 'hdb_catalog', $2 = 'hdb_cron_event_invocation_logs', $3 = 'cron_event', $4 = 'object', $5 = '{"foreign_key_constraint_on":"event_id"}', $6 = NULL, $7 = 't'

            
              2020-09-03 14:53:06.746 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              63
              INSERT
              2020-09-03 14:53:06 EDT
              4/864
              2093
              LOG
              00000
              execute <unnamed>:
    INSERT INTO "hdb_catalog"."hdb_table"
      (table_schema, table_name, is_system_defined, is_enum, configuration)
    VALUES ($1, $2, $3, $4, $5)
  
              parameters: $1 = 'hdb_catalog', $2 = 'hdb_scheduled_events', $3 = 't', $4 = 'f', $5 = '{"custom_root_fields":{},"custom_column_names":{}}'

            
              2020-09-03 14:53:06.747 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              64
              INSERT
              2020-09-03 14:53:06 EDT
              4/864
              2093
              LOG
              00000
              execute 2:
      INSERT INTO
        hdb_catalog.hdb_relationship
        (table_schema, table_name, rel_name, rel_type, rel_def, comment, is_system_defined)
      VALUES ($1, $2, $3, $4, $5 :: jsonb, $6, $7) 
              parameters: $1 = 'hdb_catalog', $2 = 'hdb_scheduled_events', $3 = 'scheduled_event_logs', $4 = 'array', $5 = '{"foreign_key_constraint_on":{"column":"event_id","table":{"schema":"hdb_catalog","name":"hdb_scheduled_event_invocation_logs"}}}', $6 = NULL, $7 = 't'

            
              2020-09-03 14:53:06.747 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              65
              INSERT
              2020-09-03 14:53:06 EDT
              4/864
              2093
              LOG
              00000
              execute <unnamed>:
    INSERT INTO "hdb_catalog"."hdb_table"
      (table_schema, table_name, is_system_defined, is_enum, configuration)
    VALUES ($1, $2, $3, $4, $5)
  
              parameters: $1 = 'hdb_catalog', $2 = 'hdb_scheduled_event_invocation_logs', $3 = 't', $4 = 'f', $5 = '{"custom_root_fields":{},"custom_column_names":{}}'

            
              2020-09-03 14:53:06.747 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              66
              INSERT
              2020-09-03 14:53:06 EDT
              4/864
              2093
              LOG
              00000
              execute 2:
      INSERT INTO
        hdb_catalog.hdb_relationship
        (table_schema, table_name, rel_name, rel_type, rel_def, comment, is_system_defined)
      VALUES ($1, $2, $3, $4, $5 :: jsonb, $6, $7) 
              parameters: $1 = 'hdb_catalog', $2 = 'hdb_scheduled_event_invocation_logs', $3 = 'scheduled_event', $4 = 'object', $5 = '{"foreign_key_constraint_on":"event_id"}', $6 = NULL, $7 = 't'

            
              2020-09-03 14:53:06.748 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              67
              SELECT
              2020-09-03 14:53:06 EDT
              4/864
              2093
              LOG
              00000
              execute 1: select
  json_build_object(
    'tables', tables.items :: json,
    'relations', relations.items,
    'permissions', permissions.items,
    'event_triggers', event_triggers.items,
    'remote_schemas', remote_schemas.items,
    'functions', functions.items,
    'allowlist_collections', allowlist.item,
    'computed_fields', computed_field.items,
    'custom_types', custom_types.item,
    'actions', actions.items,
    'remote_relationships', remote_relationships.items,
    'cron_triggers', cron_triggers.items
  )
from
  (
    select
      coalesce(jsonb_agg(
        jsonb_build_object(
          'name', jsonb_build_object(
            'name', ht.table_name,
            'schema', ht.table_schema
          ),
          'is_enum', ht.is_enum,
          'is_system_defined', ht.is_system_defined,
          'configuration', ht.configuration,
          'info', t.info
        )
      ), '[]') as items
    from hdb_catalog.hdb_table ht
    left join hdb_catalog.hdb_table_info_agg t using (table_schema, table_name)
  ) as tables,
  (
    select
      coalesce(
        json_agg(
          json_build_object(
            'table',
            json_build_object(
              'schema', table_schema,
              'name', table_name
            ),
            'rel_name', rel_name,
            'rel_type', rel_type,
            'def', rel_def :: json,
            'comment', comment
          )
        ),
        '[]'
      ) as items
    from
      hdb_catalog.hdb_relationship
  ) as relations,
  (
    select
      coalesce(
        json_agg(
          json_build_object(
            'table',
            json_build_object(
              'schema', table_schema,
              'name', table_name
            ),
            'role', role_name,
            'perm_type', perm_type,
            'def', perm_def :: json,
            'comment', comment
          )
        ),
        '[]'
      ) as items
    from
      hdb_catalog.hdb_permission
  ) as permissions,
  (
    select
      coalesce(
        json_agg(
          json_build_object(
            'table',
            json_build_object(
              'schema', schema_name,
              'name', table_name
            ),
            'name', name,
            'def', configuration :: json
          )
        ),
        '[]'
      ) as items
    from
      hdb_catalog.event_triggers
  ) as event_triggers,
  (
    select
      coalesce(
        json_agg(
          json_build_object(
            'name',
            name,
            'definition', definition :: json,
            'comment', comment
          )
        ),
        '[]'
      ) as items
    from
      hdb_catalog.remote_schemas
  ) as remote_schemas,
  (
    select
      coalesce(json_agg(q.info), '[]') as items
    from
        (
        select
          json_build_object(
            'function',
            json_build_object(
              'schema', hf.function_schema,
              'name', hf.function_name
            ),
            'configuration', hf.configuration,
            'is_system_defined', hf.is_system_defined,
            'info', hf_agg.function_info
          ) as info
        from
          hdb_catalog.hdb_function hf
        left join lateral
            (
              select coalesce(json_agg(function_info), '[]') as function_info
              from hdb_catalog.hdb_function_info_agg
               where function_name = hf.function_name
                     and function_schema = hf.function_schema
            ) hf_agg on 'true'
      ) as q
   ) as functions,
  (
    select
      coalesce(json_agg(hqc.collection_defn), '[]') as item
    from hdb_catalog.hdb_allowlist ha
    left outer join
         hdb_catalog.hdb_query_collection hqc
         on (hqc.collection_name = ha.collection_name)
  ) as allowlist,
  (
    select
      coalesce(json_agg(
        json_build_object('computed_field', cc.computed_field,
                          'function_info', fi.function_info
                         )
      ), '[]') as items
    from
      (
        select json_build_object(
          'table', jsonb_build_object('name', hcc.table_name,'schema', hcc.table_schema),
          'name', hcc.computed_field_name,
          'definition', hcc.definition,
          'comment', hcc.comment
        ) as computed_field,
        hccf.function_name,
        hccf.function_schema
        from hdb_catalog.hdb_computed_field hcc
        left outer join
             hdb_catalog.hdb_computed_field_function hccf
             on ( hcc.table_name = hccf.table_name
                 and hcc.table_schema = hccf.table_schema
                 and hcc.computed_field_name = hccf.computed_field_name
                )
      ) cc
    left join lateral
      (
        select coalesce(json_agg(function_info), '[]') as function_info
        from hdb_catalog.hdb_function_info_agg
        where function_name = cc.function_name and function_schema = cc.function_schema
      ) fi on 'true'
  ) as computed_field,
  (
    select
      json_build_object(
        'custom_types',
         coalesce((select custom_types from hdb_catalog.hdb_custom_types), '{}'),
        'pg_scalars', -- See Note [Postgres scalars in custom types]
         coalesce((select json_agg(typname) from pg_catalog.pg_type where typtype = 'b'), '[]')
      ) as item
  ) as custom_types,
  (
    select
      coalesce(
        json_agg(
          json_build_object(
            'name', ha.action_name,
            'definition', ha.action_defn :: json,
            'comment', ha.comment,
            'permissions', p.items
          )
        ),
        '[]'
      ) as items
    from
      hdb_catalog.hdb_action ha
      left join lateral
      (
        select
          coalesce(
            json_agg(
              json_build_object(
                'action', hap.action_name,
                'role', hap.role_name,
                'comment', hap.comment
              )
            ),
            '[]'
          ) as items
          from
              hdb_catalog.hdb_action_permission hap
          where hap.action_name = ha.action_name
      ) p on 'true'
  ) as actions,
  (
    select coalesce(json_agg(
      json_build_object(
        'name', remote_relationship_name,
        'table', json_build_object('schema', table_schema, 'name', table_name),
        'hasura_fields', definition -> 'hasura_fields',
        'remote_schema', definition -> 'remote_schema',
        'remote_field', definition -> 'remote_field'
      )
    ),'[]') as items
    from hdb_catalog.hdb_remote_relationship
  ) as remote_relationships,
  (
    select
      coalesce(
        json_agg(
          json_build_object(
            'name', name,
            'webhook_conf', webhook_conf :: json,
            'cron_schedule', cron_schedule,
            'payload', payload :: json,
            'retry_conf', retry_conf :: json,
            'header_conf', header_conf :: json,
            'comment', comment
          )
        ),
        '[]'
      ) as items
      from
          hdb_catalog.hdb_cron_triggers
  ) as cron_triggers

            
              2020-09-03 14:53:06.805 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              68
              INSERT
              2020-09-03 14:53:06 EDT
              4/864
              2093
              LOG
              00000
              execute <unnamed>:
    INSERT INTO hdb_catalog.hdb_version (version, upgraded_on) VALUES ($1, $2)
    ON CONFLICT ((version IS NOT NULL))
    DO UPDATE SET version = $1, upgraded_on = $2
  
              parameters: $1 = '37', $2 = '2020-09-03 14:53:06.376986-04'

            
              2020-09-03 14:53:06.806 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              69
              SELECT
              2020-09-03 14:53:06 EDT
              4/864
              2093
              LOG
              00000
              execute 3:
  SELECT instance_id::text, occurred_at, invalidations
  FROM hdb_catalog.hdb_schema_update_event
  ORDER BY occurred_at DESC LIMIT 1

            
              2020-09-03 14:53:06.807 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              70
              COMMIT
              2020-09-03 14:53:06 EDT
              4/864
              2093
              LOG
              00000
              execute 4: COMMIT

            
              2020-09-03 14:53:06.810 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              71
              BEGIN
              2020-09-03 14:53:06 EDT
              4/867
              0
              LOG
              00000
              execute 5: BEGIN ISOLATION LEVEL READ COMMITTED

            
              2020-09-03 14:53:06.811 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              72
              UPDATE
              2020-09-03 14:53:06 EDT
              4/867
              0
              LOG
              00000
              execute 6:
          UPDATE hdb_catalog.event_log
          SET locked = 'f'
          WHERE locked = 't'

            
              2020-09-03 14:53:06.811 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              73
              COMMIT
              2020-09-03 14:53:06 EDT
              4/867
              0
              LOG
              00000
              execute 4: COMMIT

            
              2020-09-03 14:53:06.811 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              74
              BEGIN
              2020-09-03 14:53:06 EDT
              4/868
              0
              LOG
              00000
              execute 5: BEGIN ISOLATION LEVEL READ COMMITTED

            
              2020-09-03 14:53:06.812 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              75
              UPDATE
              2020-09-03 14:53:06 EDT
              4/868
              0
              LOG
              00000
              execute 7:
          UPDATE hdb_catalog.hdb_cron_events
          SET status = 'scheduled'
          WHERE status = 'locked'

            
              2020-09-03 14:53:06.813 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              76
              UPDATE
              2020-09-03 14:53:06 EDT
              4/868
              0
              LOG
              00000
              execute 8:
          UPDATE hdb_catalog.hdb_scheduled_events
          SET status = 'scheduled'
          WHERE status = 'locked'

            
              2020-09-03 14:53:06.814 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              77
              COMMIT
              2020-09-03 14:53:06 EDT
              4/868
              0
              LOG
              00000
              execute 4: COMMIT

            
              2020-09-03 14:53:06.814 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              78
              BEGIN
              2020-09-03 14:53:06 EDT
              4/869
              0
              LOG
              00000
              execute 5: BEGIN ISOLATION LEVEL READ COMMITTED

            
              2020-09-03 14:53:06.814 EDT
              jessicalaughlin
              jessicalaughlin
              82260
              127.0.0.1:54863
              5f513b92.14154
              1
              idle
              2020-09-03 14:53:06 EDT
              5/2
              0
              LOG
              00000
              statement: SET client_encoding = 'UTF8';SET client_min_messages TO WARNING;

            
              2020-09-03 14:53:06.815 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              79
              SELECT
              2020-09-03 14:53:06 EDT
              4/869
              0
              LOG
              00000
              execute <unnamed>:
    SELECT (hasura_uuid :: text) FROM hdb_catalog.hdb_version

            
              2020-09-03 14:53:06.815 EDT
              jessicalaughlin
              jessicalaughlin
              82255
              127.0.0.1:54861
              5f513b92.1414f
              80
              COMMIT
              2020-09-03 14:53:06 EDT
              4/869
              0
              LOG
              00000
              execute 4: COMMIT

            
              2020-09-03 14:53:06.815 EDT
              jessicalaughlin
              jessicalaughlin
              82260
              127.0.0.1:54863
              5f513b92.14154
              2
              idle
              2020-09-03 14:53:06 EDT
              5/3
              0
              LOG
              00000
              statement: LISTEN  hasura_schema_update;

            
              2020-09-03 14:53:06.817 EDT
              jessicalaughlin
              jessicalaughlin
              82261
              127.0.0.1:54864
              5f513b92.14155
              1
              idle
              2020-09-03 14:53:06 EDT
              6/2
              0
              LOG
              00000
              statement: SET client_encoding = 'UTF8';SET client_min_messages TO WARNING;

            
              2020-09-03 14:53:06.818 EDT
              jessicalaughlin
              jessicalaughlin
              82261
              127.0.0.1:54864
              5f513b92.14155
              2
              BEGIN
              2020-09-03 14:53:06 EDT
              6/4
              0
              LOG
              00000
              execute 0: BEGIN ISOLATION LEVEL REPEATABLE READ READ WRITE

            
              2020-09-03 14:53:06.818 EDT
              jessicalaughlin
              jessicalaughlin
              82262
              127.0.0.1:54865
              5f513b92.14156
              1
              idle
              2020-09-03 14:53:06 EDT
              7/2
              0
              LOG
              00000
              statement: SET client_encoding = 'UTF8';SET client_min_messages TO WARNING;

            
              2020-09-03 14:53:06.819 EDT
              jessicalaughlin
              jessicalaughlin
              82262
              127.0.0.1:54865
              5f513b92.14156
              2
              BEGIN
              2020-09-03 14:53:06 EDT
              7/4
              0
              LOG
              00000
              execute 0: BEGIN ISOLATION LEVEL READ COMMITTED READ ONLY

            
              2020-09-03 14:53:06.820 EDT
              jessicalaughlin
              jessicalaughlin
              82263
              127.0.0.1:54866
              5f513b92.14157
              1
              idle
              2020-09-03 14:53:06 EDT
              8/2
              0
              LOG
              00000
              statement: SET client_encoding = 'UTF8';SET client_min_messages TO WARNING;

            
              2020-09-03 14:53:06.821 EDT
              jessicalaughlin
              jessicalaughlin
              82261
              127.0.0.1:54864
              5f513b92.14155
              3
              UPDATE
              2020-09-03 14:53:06 EDT
              6/4
              0
              LOG
              00000
              execute 1:
      UPDATE hdb_catalog.event_log
      SET locked = 't'
      WHERE id IN ( SELECT l.id
                    FROM hdb_catalog.event_log l
                    WHERE l.delivered = 'f' and l.error = 'f' and l.locked = 'f'
                          and (l.next_retry_at is NULL or l.next_retry_at <= now())
                          and l.archived = 'f'
                    ORDER BY created_at
                    LIMIT $1
                    FOR UPDATE SKIP LOCKED )
      RETURNING id, schema_name, table_name, trigger_name, payload::json, tries, created_at
      
              parameters: $1 = '100'

            
              2020-09-03 14:53:06.821 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              1
              idle
              2020-09-03 14:53:06 EDT
              9/2
              0
              LOG
              00000
              statement: SET client_encoding = 'UTF8';SET client_min_messages TO WARNING;

            
              2020-09-03 14:53:06.822 EDT
              jessicalaughlin
              jessicalaughlin
              82261
              127.0.0.1:54864
              5f513b92.14155
              4
              COMMIT
              2020-09-03 14:53:06 EDT
              6/4
              0
              LOG
              00000
              execute 2: COMMIT

            
              2020-09-03 14:53:06.822 EDT
              jessicalaughlin
              jessicalaughlin
              82263
              127.0.0.1:54866
              5f513b92.14157
              2
              UPDATE
              2020-09-03 14:53:06 EDT
              8/3
              0
              LOG
              00000
              execute <unnamed>:
        update hdb_catalog.hdb_action_log set status = 'processing'
        where
          id in (
            select id from hdb_catalog.hdb_action_log
            where status = 'created'
            for update skip locked limit 10
          )
        returning
          id, action_name, request_headers::json, session_variables::json, input_payload::json

            
              2020-09-03 14:53:06.822 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              2
              BEGIN
              2020-09-03 14:53:06 EDT
              9/4
              0
              LOG
              00000
              execute 0: BEGIN ISOLATION LEVEL READ COMMITTED READ WRITE

            
              2020-09-03 14:53:06.822 EDT
              jessicalaughlin
              jessicalaughlin
              82262
              127.0.0.1:54865
              5f513b92.14156
              3
              SELECT
              2020-09-03 14:53:06 EDT
              7/4
              0
              LOG
              00000
              execute 1:
           SELECT name, upcoming_events_count, max_scheduled_time
            FROM hdb_catalog.hdb_cron_events_stats
            WHERE upcoming_events_count < 100

            
              2020-09-03 14:53:06.823 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              1
              idle
              2020-09-03 14:53:06 EDT
              10/2
              0
              LOG
              00000
              statement: SET client_encoding = 'UTF8';SET client_min_messages TO WARNING;

            
              2020-09-03 14:53:06.823 EDT
              jessicalaughlin
              jessicalaughlin
              82262
              127.0.0.1:54865
              5f513b92.14156
              4
              COMMIT
              2020-09-03 14:53:06 EDT
              7/4
              0
              LOG
              00000
              execute 2: COMMIT

            
              2020-09-03 14:53:06.823 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              2
              BEGIN
              2020-09-03 14:53:06 EDT
              10/4
              0
              LOG
              00000
              execute 0: BEGIN ISOLATION LEVEL SERIALIZABLE

            
              2020-09-03 14:53:06.823 EDT
              jessicalaughlin
              jessicalaughlin
              82262
              127.0.0.1:54865
              5f513b92.14156
              5
              BEGIN
              2020-09-03 14:53:06 EDT
              7/6
              0
              LOG
              00000
              execute 3: BEGIN ISOLATION LEVEL READ COMMITTED READ WRITE

            
              2020-09-03 14:53:06.824 EDT
              jessicalaughlin
              jessicalaughlin
              82262
              127.0.0.1:54865
              5f513b92.14156
              6
              COMMIT
              2020-09-03 14:53:06 EDT
              7/6
              0
              LOG
              00000
              execute 2: COMMIT

            
              2020-09-03 14:53:06.824 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              3
              UPDATE
              2020-09-03 14:53:06 EDT
              9/4
              0
              LOG
              00000
              execute 1:
      UPDATE hdb_catalog.hdb_cron_events
      SET status = 'locked'
      WHERE id IN ( SELECT t.id
                    FROM hdb_catalog.hdb_cron_events t
                    WHERE ( t.status = 'scheduled'
                            and (
                             (t.next_retry_at is NULL and t.scheduled_time <= now()) or
                             (t.next_retry_at is not NULL and t.next_retry_at <= now())
                            )
                          )
                    FOR UPDATE SKIP LOCKED
                    )
      RETURNING id, trigger_name, scheduled_time, tries

            
              2020-09-03 14:53:06.825 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              3
              SELECT
              2020-09-03 14:53:06 EDT
              10/4
              0
              LOG
              00000
              execute 1:
  SELECT instance_id::text, occurred_at, invalidations
  FROM hdb_catalog.hdb_schema_update_event
  ORDER BY occurred_at DESC LIMIT 1

            
              2020-09-03 14:53:06.825 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              4
              COMMIT
              2020-09-03 14:53:06 EDT
              9/4
              0
              LOG
              00000
              execute 2: COMMIT

            
              2020-09-03 14:53:06.825 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              5
              BEGIN
              2020-09-03 14:53:06 EDT
              9/5
              0
              LOG
              00000
              execute 0: BEGIN ISOLATION LEVEL READ COMMITTED READ WRITE

            
              2020-09-03 14:53:06.825 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              4
              COMMIT
              2020-09-03 14:53:06 EDT
              10/4
              0
              LOG
              00000
              execute 2: COMMIT

            
              2020-09-03 14:53:06.826 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              6
              UPDATE
              2020-09-03 14:53:06 EDT
              9/5
              0
              LOG
              00000
              execute <unnamed>:
      UPDATE hdb_catalog.hdb_scheduled_events
      SET status = 'locked'
      WHERE id IN ( SELECT t.id
                    FROM hdb_catalog.hdb_scheduled_events t
                    WHERE ( t.status = 'scheduled'
                            and (
                             (t.next_retry_at is NULL and t.scheduled_time <= now()) or
                             (t.next_retry_at is not NULL and t.next_retry_at <= now())
                            )
                          )
                    FOR UPDATE SKIP LOCKED
                    )
      RETURNING id, webhook_conf, scheduled_time, retry_conf, payload, header_conf, tries, comment

            
              2020-09-03 14:53:06.826 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              7
              COMMIT
              2020-09-03 14:53:06 EDT
              9/5
              0
              LOG
              00000
              execute 2: COMMIT

            
              2020-09-03 14:53:07.825 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              5
              BEGIN
              2020-09-03 14:53:06 EDT
              10/6
              0
              LOG
              00000
              execute 3: BEGIN ISOLATION LEVEL REPEATABLE READ READ WRITE

            
              2020-09-03 14:53:07.825 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              8
              UPDATE
              2020-09-03 14:53:06 EDT
              9/6
              0
              LOG
              00000
              execute <unnamed>:
        update hdb_catalog.hdb_action_log set status = 'processing'
        where
          id in (
            select id from hdb_catalog.hdb_action_log
            where status = 'created'
            for update skip locked limit 10
          )
        returning
          id, action_name, request_headers::json, session_variables::json, input_payload::json

            
              2020-09-03 14:53:07.828 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              6
              UPDATE
              2020-09-03 14:53:06 EDT
              10/6
              0
              LOG
              00000
              execute 4:
      UPDATE hdb_catalog.event_log
      SET locked = 't'
      WHERE id IN ( SELECT l.id
                    FROM hdb_catalog.event_log l
                    WHERE l.delivered = 'f' and l.error = 'f' and l.locked = 'f'
                          and (l.next_retry_at is NULL or l.next_retry_at <= now())
                          and l.archived = 'f'
                    ORDER BY created_at
                    LIMIT $1
                    FOR UPDATE SKIP LOCKED )
      RETURNING id, schema_name, table_name, trigger_name, payload::json, tries, created_at
      
              parameters: $1 = '100'

            
              2020-09-03 14:53:07.829 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              7
              COMMIT
              2020-09-03 14:53:06 EDT
              10/6
              0
              LOG
              00000
              execute 2: COMMIT

            
              2020-09-03 14:53:08.828 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              8
              UPDATE
              2020-09-03 14:53:06 EDT
              10/7
              0
              LOG
              00000
              execute <unnamed>:
        update hdb_catalog.hdb_action_log set status = 'processing'
        where
          id in (
            select id from hdb_catalog.hdb_action_log
            where status = 'created'
            for update skip locked limit 10
          )
        returning
          id, action_name, request_headers::json, session_variables::json, input_payload::json

            
              2020-09-03 14:53:08.829 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              9
              BEGIN
              2020-09-03 14:53:06 EDT
              10/8
              0
              LOG
              00000
              execute 3: BEGIN ISOLATION LEVEL REPEATABLE READ READ WRITE

            
              2020-09-03 14:53:08.830 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              10
              UPDATE
              2020-09-03 14:53:06 EDT
              10/8
              0
              LOG
              00000
              execute 4:
      UPDATE hdb_catalog.event_log
      SET locked = 't'
      WHERE id IN ( SELECT l.id
                    FROM hdb_catalog.event_log l
                    WHERE l.delivered = 'f' and l.error = 'f' and l.locked = 'f'
                          and (l.next_retry_at is NULL or l.next_retry_at <= now())
                          and l.archived = 'f'
                    ORDER BY created_at
                    LIMIT $1
                    FOR UPDATE SKIP LOCKED )
      RETURNING id, schema_name, table_name, trigger_name, payload::json, tries, created_at
      
              parameters: $1 = '100'

            
              2020-09-03 14:53:08.831 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              11
              COMMIT
              2020-09-03 14:53:06 EDT
              10/8
              0
              LOG
              00000
              execute 2: COMMIT

            
              2020-09-03 14:53:09.834 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              12
              UPDATE
              2020-09-03 14:53:06 EDT
              10/9
              0
              LOG
              00000
              execute <unnamed>:
        update hdb_catalog.hdb_action_log set status = 'processing'
        where
          id in (
            select id from hdb_catalog.hdb_action_log
            where status = 'created'
            for update skip locked limit 10
          )
        returning
          id, action_name, request_headers::json, session_variables::json, input_payload::json

            
              2020-09-03 14:53:09.835 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              9
              BEGIN
              2020-09-03 14:53:06 EDT
              9/8
              0
              LOG
              00000
              execute 3: BEGIN ISOLATION LEVEL REPEATABLE READ READ WRITE

            
              2020-09-03 14:53:09.839 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              10
              UPDATE
              2020-09-03 14:53:06 EDT
              9/8
              0
              LOG
              00000
              execute 4:
      UPDATE hdb_catalog.event_log
      SET locked = 't'
      WHERE id IN ( SELECT l.id
                    FROM hdb_catalog.event_log l
                    WHERE l.delivered = 'f' and l.error = 'f' and l.locked = 'f'
                          and (l.next_retry_at is NULL or l.next_retry_at <= now())
                          and l.archived = 'f'
                    ORDER BY created_at
                    LIMIT $1
                    FOR UPDATE SKIP LOCKED )
      RETURNING id, schema_name, table_name, trigger_name, payload::json, tries, created_at
      
              parameters: $1 = '100'

            
              2020-09-03 14:53:09.840 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              11
              COMMIT
              2020-09-03 14:53:06 EDT
              9/8
              0
              LOG
              00000
              execute 2: COMMIT

            
              2020-09-03 14:53:10.838 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              12
              UPDATE
              2020-09-03 14:53:06 EDT
              9/9
              0
              LOG
              00000
              execute <unnamed>:
        update hdb_catalog.hdb_action_log set status = 'processing'
        where
          id in (
            select id from hdb_catalog.hdb_action_log
            where status = 'created'
            for update skip locked limit 10
          )
        returning
          id, action_name, request_headers::json, session_variables::json, input_payload::json

            
              2020-09-03 14:53:10.840 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              13
              BEGIN
              2020-09-03 14:53:06 EDT
              9/10
              0
              LOG
              00000
              execute 3: BEGIN ISOLATION LEVEL REPEATABLE READ READ WRITE

            
              2020-09-03 14:53:10.842 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              14
              UPDATE
              2020-09-03 14:53:06 EDT
              9/10
              0
              LOG
              00000
              execute 4:
      UPDATE hdb_catalog.event_log
      SET locked = 't'
      WHERE id IN ( SELECT l.id
                    FROM hdb_catalog.event_log l
                    WHERE l.delivered = 'f' and l.error = 'f' and l.locked = 'f'
                          and (l.next_retry_at is NULL or l.next_retry_at <= now())
                          and l.archived = 'f'
                    ORDER BY created_at
                    LIMIT $1
                    FOR UPDATE SKIP LOCKED )
      RETURNING id, schema_name, table_name, trigger_name, payload::json, tries, created_at
      
              parameters: $1 = '100'

            
              2020-09-03 14:53:10.842 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              15
              COMMIT
              2020-09-03 14:53:06 EDT
              9/10
              0
              LOG
              00000
              execute 2: COMMIT

            
              2020-09-03 14:53:11.844 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              13
              BEGIN
              2020-09-03 14:53:06 EDT
              10/10
              0
              LOG
              00000
              execute 3: BEGIN ISOLATION LEVEL REPEATABLE READ READ WRITE

            
              2020-09-03 14:53:11.844 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              16
              UPDATE
              2020-09-03 14:53:06 EDT
              9/11
              0
              LOG
              00000
              execute <unnamed>:
        update hdb_catalog.hdb_action_log set status = 'processing'
        where
          id in (
            select id from hdb_catalog.hdb_action_log
            where status = 'created'
            for update skip locked limit 10
          )
        returning
          id, action_name, request_headers::json, session_variables::json, input_payload::json

            
              2020-09-03 14:53:11.844 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              14
              UPDATE
              2020-09-03 14:53:06 EDT
              10/10
              0
              LOG
              00000
              execute 4:
      UPDATE hdb_catalog.event_log
      SET locked = 't'
      WHERE id IN ( SELECT l.id
                    FROM hdb_catalog.event_log l
                    WHERE l.delivered = 'f' and l.error = 'f' and l.locked = 'f'
                          and (l.next_retry_at is NULL or l.next_retry_at <= now())
                          and l.archived = 'f'
                    ORDER BY created_at
                    LIMIT $1
                    FOR UPDATE SKIP LOCKED )
      RETURNING id, schema_name, table_name, trigger_name, payload::json, tries, created_at
      
              parameters: $1 = '100'

            
              2020-09-03 14:53:11.845 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              15
              COMMIT
              2020-09-03 14:53:06 EDT
              10/10
              0
              LOG
              00000
              execute 2: COMMIT

            
              2020-09-03 14:53:12.850 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              16
              BEGIN
              2020-09-03 14:53:06 EDT
              10/11
              0
              LOG
              00000
              execute 3: BEGIN ISOLATION LEVEL REPEATABLE READ READ WRITE

            
              2020-09-03 14:53:12.851 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              17
              UPDATE
              2020-09-03 14:53:06 EDT
              9/12
              0
              LOG
              00000
              execute <unnamed>:
        update hdb_catalog.hdb_action_log set status = 'processing'
        where
          id in (
            select id from hdb_catalog.hdb_action_log
            where status = 'created'
            for update skip locked limit 10
          )
        returning
          id, action_name, request_headers::json, session_variables::json, input_payload::json

            
              2020-09-03 14:53:12.852 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              17
              UPDATE
              2020-09-03 14:53:06 EDT
              10/11
              0
              LOG
              00000
              execute 4:
      UPDATE hdb_catalog.event_log
      SET locked = 't'
      WHERE id IN ( SELECT l.id
                    FROM hdb_catalog.event_log l
                    WHERE l.delivered = 'f' and l.error = 'f' and l.locked = 'f'
                          and (l.next_retry_at is NULL or l.next_retry_at <= now())
                          and l.archived = 'f'
                    ORDER BY created_at
                    LIMIT $1
                    FOR UPDATE SKIP LOCKED )
      RETURNING id, schema_name, table_name, trigger_name, payload::json, tries, created_at
      
              parameters: $1 = '100'

            
              2020-09-03 14:53:12.853 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              18
              COMMIT
              2020-09-03 14:53:06 EDT
              10/11
              0
              LOG
              00000
              execute 2: COMMIT

            
              2020-09-03 14:53:13.853 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              19
              UPDATE
              2020-09-03 14:53:06 EDT
              10/12
              0
              LOG
              00000
              execute <unnamed>:
        update hdb_catalog.hdb_action_log set status = 'processing'
        where
          id in (
            select id from hdb_catalog.hdb_action_log
            where status = 'created'
            for update skip locked limit 10
          )
        returning
          id, action_name, request_headers::json, session_variables::json, input_payload::json

            
              2020-09-03 14:53:13.854 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              18
              BEGIN
              2020-09-03 14:53:06 EDT
              9/13
              0
              LOG
              00000
              execute 3: BEGIN ISOLATION LEVEL REPEATABLE READ READ WRITE

            
              2020-09-03 14:53:13.855 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              19
              UPDATE
              2020-09-03 14:53:06 EDT
              9/13
              0
              LOG
              00000
              execute 4:
      UPDATE hdb_catalog.event_log
      SET locked = 't'
      WHERE id IN ( SELECT l.id
                    FROM hdb_catalog.event_log l
                    WHERE l.delivered = 'f' and l.error = 'f' and l.locked = 'f'
                          and (l.next_retry_at is NULL or l.next_retry_at <= now())
                          and l.archived = 'f'
                    ORDER BY created_at
                    LIMIT $1
                    FOR UPDATE SKIP LOCKED )
      RETURNING id, schema_name, table_name, trigger_name, payload::json, tries, created_at
      
              parameters: $1 = '100'

            
              2020-09-03 14:53:13.855 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              20
              COMMIT
              2020-09-03 14:53:06 EDT
              9/13
              0
              LOG
              00000
              execute 2: COMMIT

            
              2020-09-03 14:53:14.856 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              21
              BEGIN
              2020-09-03 14:53:06 EDT
              9/14
              0
              LOG
              00000
              execute 3: BEGIN ISOLATION LEVEL REPEATABLE READ READ WRITE

            
              2020-09-03 14:53:14.857 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              20
              UPDATE
              2020-09-03 14:53:06 EDT
              10/13
              0
              LOG
              00000
              execute <unnamed>:
        update hdb_catalog.hdb_action_log set status = 'processing'
        where
          id in (
            select id from hdb_catalog.hdb_action_log
            where status = 'created'
            for update skip locked limit 10
          )
        returning
          id, action_name, request_headers::json, session_variables::json, input_payload::json

            
              2020-09-03 14:53:14.857 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              22
              UPDATE
              2020-09-03 14:53:06 EDT
              9/14
              0
              LOG
              00000
              execute 4:
      UPDATE hdb_catalog.event_log
      SET locked = 't'
      WHERE id IN ( SELECT l.id
                    FROM hdb_catalog.event_log l
                    WHERE l.delivered = 'f' and l.error = 'f' and l.locked = 'f'
                          and (l.next_retry_at is NULL or l.next_retry_at <= now())
                          and l.archived = 'f'
                    ORDER BY created_at
                    LIMIT $1
                    FOR UPDATE SKIP LOCKED )
      RETURNING id, schema_name, table_name, trigger_name, payload::json, tries, created_at
      
              parameters: $1 = '100'

            
              2020-09-03 14:53:14.858 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              23
              COMMIT
              2020-09-03 14:53:06 EDT
              9/14
              0
              LOG
              00000
              execute 2: COMMIT

            
              2020-09-03 14:53:15.858 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              21
              BEGIN
              2020-09-03 14:53:06 EDT
              10/14
              0
              LOG
              00000
              execute 3: BEGIN ISOLATION LEVEL REPEATABLE READ READ WRITE

            
              2020-09-03 14:53:15.859 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              24
              UPDATE
              2020-09-03 14:53:06 EDT
              9/15
              0
              LOG
              00000
              execute <unnamed>:
        update hdb_catalog.hdb_action_log set status = 'processing'
        where
          id in (
            select id from hdb_catalog.hdb_action_log
            where status = 'created'
            for update skip locked limit 10
          )
        returning
          id, action_name, request_headers::json, session_variables::json, input_payload::json

            
              2020-09-03 14:53:15.859 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              22
              UPDATE
              2020-09-03 14:53:06 EDT
              10/14
              0
              LOG
              00000
              execute 4:
      UPDATE hdb_catalog.event_log
      SET locked = 't'
      WHERE id IN ( SELECT l.id
                    FROM hdb_catalog.event_log l
                    WHERE l.delivered = 'f' and l.error = 'f' and l.locked = 'f'
                          and (l.next_retry_at is NULL or l.next_retry_at <= now())
                          and l.archived = 'f'
                    ORDER BY created_at
                    LIMIT $1
                    FOR UPDATE SKIP LOCKED )
      RETURNING id, schema_name, table_name, trigger_name, payload::json, tries, created_at
      
              parameters: $1 = '100'

            
              2020-09-03 14:53:15.860 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              23
              COMMIT
              2020-09-03 14:53:06 EDT
              10/14
              0
              LOG
              00000
              execute 2: COMMIT

            
              2020-09-03 14:53:16.860 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              25
              BEGIN
              2020-09-03 14:53:06 EDT
              9/16
              0
              LOG
              00000
              execute 3: BEGIN ISOLATION LEVEL REPEATABLE READ READ WRITE

            
              2020-09-03 14:53:16.861 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              24
              UPDATE
              2020-09-03 14:53:06 EDT
              10/15
              0
              LOG
              00000
              execute <unnamed>:
        update hdb_catalog.hdb_action_log set status = 'processing'
        where
          id in (
            select id from hdb_catalog.hdb_action_log
            where status = 'created'
            for update skip locked limit 10
          )
        returning
          id, action_name, request_headers::json, session_variables::json, input_payload::json

            
              2020-09-03 14:53:16.862 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              26
              UPDATE
              2020-09-03 14:53:06 EDT
              9/16
              0
              LOG
              00000
              execute 4:
      UPDATE hdb_catalog.event_log
      SET locked = 't'
      WHERE id IN ( SELECT l.id
                    FROM hdb_catalog.event_log l
                    WHERE l.delivered = 'f' and l.error = 'f' and l.locked = 'f'
                          and (l.next_retry_at is NULL or l.next_retry_at <= now())
                          and l.archived = 'f'
                    ORDER BY created_at
                    LIMIT $1
                    FOR UPDATE SKIP LOCKED )
      RETURNING id, schema_name, table_name, trigger_name, payload::json, tries, created_at
      
              parameters: $1 = '100'

            
              2020-09-03 14:53:16.863 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              27
              COMMIT
              2020-09-03 14:53:06 EDT
              9/16
              0
              LOG
              00000
              execute 2: COMMIT

            
              2020-09-03 14:53:17.864 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              25
              BEGIN
              2020-09-03 14:53:06 EDT
              10/16
              0
              LOG
              00000
              execute 3: BEGIN ISOLATION LEVEL REPEATABLE READ READ WRITE

            
              2020-09-03 14:53:17.865 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              28
              UPDATE
              2020-09-03 14:53:06 EDT
              9/17
              0
              LOG
              00000
              execute <unnamed>:
        update hdb_catalog.hdb_action_log set status = 'processing'
        where
          id in (
            select id from hdb_catalog.hdb_action_log
            where status = 'created'
            for update skip locked limit 10
          )
        returning
          id, action_name, request_headers::json, session_variables::json, input_payload::json

            
              2020-09-03 14:53:17.866 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              26
              UPDATE
              2020-09-03 14:53:06 EDT
              10/16
              0
              LOG
              00000
              execute 4:
      UPDATE hdb_catalog.event_log
      SET locked = 't'
      WHERE id IN ( SELECT l.id
                    FROM hdb_catalog.event_log l
                    WHERE l.delivered = 'f' and l.error = 'f' and l.locked = 'f'
                          and (l.next_retry_at is NULL or l.next_retry_at <= now())
                          and l.archived = 'f'
                    ORDER BY created_at
                    LIMIT $1
                    FOR UPDATE SKIP LOCKED )
      RETURNING id, schema_name, table_name, trigger_name, payload::json, tries, created_at
      
              parameters: $1 = '100'

            
              2020-09-03 14:53:17.866 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              27
              COMMIT
              2020-09-03 14:53:06 EDT
              10/16
              0
              LOG
              00000
              execute 2: COMMIT

            
              2020-09-03 14:53:18.868 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              29
              BEGIN
              2020-09-03 14:53:06 EDT
              9/18
              0
              LOG
              00000
              execute 3: BEGIN ISOLATION LEVEL REPEATABLE READ READ WRITE

            
              2020-09-03 14:53:18.868 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              28
              UPDATE
              2020-09-03 14:53:06 EDT
              10/17
              0
              LOG
              00000
              execute <unnamed>:
        update hdb_catalog.hdb_action_log set status = 'processing'
        where
          id in (
            select id from hdb_catalog.hdb_action_log
            where status = 'created'
            for update skip locked limit 10
          )
        returning
          id, action_name, request_headers::json, session_variables::json, input_payload::json

            
              2020-09-03 14:53:18.869 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              30
              UPDATE
              2020-09-03 14:53:06 EDT
              9/18
              0
              LOG
              00000
              execute 4:
      UPDATE hdb_catalog.event_log
      SET locked = 't'
      WHERE id IN ( SELECT l.id
                    FROM hdb_catalog.event_log l
                    WHERE l.delivered = 'f' and l.error = 'f' and l.locked = 'f'
                          and (l.next_retry_at is NULL or l.next_retry_at <= now())
                          and l.archived = 'f'
                    ORDER BY created_at
                    LIMIT $1
                    FOR UPDATE SKIP LOCKED )
      RETURNING id, schema_name, table_name, trigger_name, payload::json, tries, created_at
      
              parameters: $1 = '100'

            
              2020-09-03 14:53:18.870 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              31
              COMMIT
              2020-09-03 14:53:06 EDT
              9/18
              0
              LOG
              00000
              execute 2: COMMIT

            
              2020-09-03 14:53:19.870 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              32
              UPDATE
              2020-09-03 14:53:06 EDT
              9/19
              0
              LOG
              00000
              execute <unnamed>:
        update hdb_catalog.hdb_action_log set status = 'processing'
        where
          id in (
            select id from hdb_catalog.hdb_action_log
            where status = 'created'
            for update skip locked limit 10
          )
        returning
          id, action_name, request_headers::json, session_variables::json, input_payload::json

            
              2020-09-03 14:53:19.871 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              33
              BEGIN
              2020-09-03 14:53:06 EDT
              9/20
              0
              LOG
              00000
              execute 3: BEGIN ISOLATION LEVEL REPEATABLE READ READ WRITE

            
              2020-09-03 14:53:19.872 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              34
              UPDATE
              2020-09-03 14:53:06 EDT
              9/20
              0
              LOG
              00000
              execute 4:
      UPDATE hdb_catalog.event_log
      SET locked = 't'
      WHERE id IN ( SELECT l.id
                    FROM hdb_catalog.event_log l
                    WHERE l.delivered = 'f' and l.error = 'f' and l.locked = 'f'
                          and (l.next_retry_at is NULL or l.next_retry_at <= now())
                          and l.archived = 'f'
                    ORDER BY created_at
                    LIMIT $1
                    FOR UPDATE SKIP LOCKED )
      RETURNING id, schema_name, table_name, trigger_name, payload::json, tries, created_at
      
              parameters: $1 = '100'

            
              2020-09-03 14:53:19.873 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              35
              COMMIT
              2020-09-03 14:53:06 EDT
              9/20
              0
              LOG
              00000
              execute 2: COMMIT

            
              2020-09-03 14:53:20.873 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              36
              UPDATE
              2020-09-03 14:53:06 EDT
              9/21
              0
              LOG
              00000
              execute <unnamed>:
        update hdb_catalog.hdb_action_log set status = 'processing'
        where
          id in (
            select id from hdb_catalog.hdb_action_log
            where status = 'created'
            for update skip locked limit 10
          )
        returning
          id, action_name, request_headers::json, session_variables::json, input_payload::json

            
              2020-09-03 14:53:20.874 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              29
              BEGIN
              2020-09-03 14:53:06 EDT
              10/18
              0
              LOG
              00000
              execute 3: BEGIN ISOLATION LEVEL REPEATABLE READ READ WRITE

            
              2020-09-03 14:53:20.875 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              30
              UPDATE
              2020-09-03 14:53:06 EDT
              10/18
              0
              LOG
              00000
              execute 4:
      UPDATE hdb_catalog.event_log
      SET locked = 't'
      WHERE id IN ( SELECT l.id
                    FROM hdb_catalog.event_log l
                    WHERE l.delivered = 'f' and l.error = 'f' and l.locked = 'f'
                          and (l.next_retry_at is NULL or l.next_retry_at <= now())
                          and l.archived = 'f'
                    ORDER BY created_at
                    LIMIT $1
                    FOR UPDATE SKIP LOCKED )
      RETURNING id, schema_name, table_name, trigger_name, payload::json, tries, created_at
      
              parameters: $1 = '100'

            
              2020-09-03 14:53:20.875 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              31
              COMMIT
              2020-09-03 14:53:06 EDT
              10/18
              0
              LOG
              00000
              execute 2: COMMIT

            
              2020-09-03 14:53:21.875 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              32
              UPDATE
              2020-09-03 14:53:06 EDT
              10/19
              0
              LOG
              00000
              execute <unnamed>:
        update hdb_catalog.hdb_action_log set status = 'processing'
        where
          id in (
            select id from hdb_catalog.hdb_action_log
            where status = 'created'
            for update skip locked limit 10
          )
        returning
          id, action_name, request_headers::json, session_variables::json, input_payload::json

            
              2020-09-03 14:53:21.876 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              37
              BEGIN
              2020-09-03 14:53:06 EDT
              9/22
              0
              LOG
              00000
              execute 3: BEGIN ISOLATION LEVEL REPEATABLE READ READ WRITE

            
              2020-09-03 14:53:21.877 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              38
              UPDATE
              2020-09-03 14:53:06 EDT
              9/22
              0
              LOG
              00000
              execute 4:
      UPDATE hdb_catalog.event_log
      SET locked = 't'
      WHERE id IN ( SELECT l.id
                    FROM hdb_catalog.event_log l
                    WHERE l.delivered = 'f' and l.error = 'f' and l.locked = 'f'
                          and (l.next_retry_at is NULL or l.next_retry_at <= now())
                          and l.archived = 'f'
                    ORDER BY created_at
                    LIMIT $1
                    FOR UPDATE SKIP LOCKED )
      RETURNING id, schema_name, table_name, trigger_name, payload::json, tries, created_at
      
              parameters: $1 = '100'

            
              2020-09-03 14:53:21.878 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              39
              COMMIT
              2020-09-03 14:53:06 EDT
              9/22
              0
              LOG
              00000
              execute 2: COMMIT

            
              2020-09-03 14:53:22.877 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              40
              UPDATE
              2020-09-03 14:53:06 EDT
              9/23
              0
              LOG
              00000
              execute <unnamed>:
        update hdb_catalog.hdb_action_log set status = 'processing'
        where
          id in (
            select id from hdb_catalog.hdb_action_log
            where status = 'created'
            for update skip locked limit 10
          )
        returning
          id, action_name, request_headers::json, session_variables::json, input_payload::json

            
              2020-09-03 14:53:22.879 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              41
              BEGIN
              2020-09-03 14:53:06 EDT
              9/24
              0
              LOG
              00000
              execute 3: BEGIN ISOLATION LEVEL REPEATABLE READ READ WRITE

            
              2020-09-03 14:53:22.880 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              42
              UPDATE
              2020-09-03 14:53:06 EDT
              9/24
              0
              LOG
              00000
              execute 4:
      UPDATE hdb_catalog.event_log
      SET locked = 't'
      WHERE id IN ( SELECT l.id
                    FROM hdb_catalog.event_log l
                    WHERE l.delivered = 'f' and l.error = 'f' and l.locked = 'f'
                          and (l.next_retry_at is NULL or l.next_retry_at <= now())
                          and l.archived = 'f'
                    ORDER BY created_at
                    LIMIT $1
                    FOR UPDATE SKIP LOCKED )
      RETURNING id, schema_name, table_name, trigger_name, payload::json, tries, created_at
      
              parameters: $1 = '100'

            
              2020-09-03 14:53:22.881 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              43
              COMMIT
              2020-09-03 14:53:06 EDT
              9/24
              0
              LOG
              00000
              execute 2: COMMIT

            
              2020-09-03 14:53:23.881 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              33
              BEGIN
              2020-09-03 14:53:06 EDT
              10/20
              0
              LOG
              00000
              execute 3: BEGIN ISOLATION LEVEL REPEATABLE READ READ WRITE

            
              2020-09-03 14:53:23.882 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              44
              UPDATE
              2020-09-03 14:53:06 EDT
              9/25
              0
              LOG
              00000
              execute <unnamed>:
        update hdb_catalog.hdb_action_log set status = 'processing'
        where
          id in (
            select id from hdb_catalog.hdb_action_log
            where status = 'created'
            for update skip locked limit 10
          )
        returning
          id, action_name, request_headers::json, session_variables::json, input_payload::json

            
              2020-09-03 14:53:23.882 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              34
              UPDATE
              2020-09-03 14:53:06 EDT
              10/20
              0
              LOG
              00000
              execute 4:
      UPDATE hdb_catalog.event_log
      SET locked = 't'
      WHERE id IN ( SELECT l.id
                    FROM hdb_catalog.event_log l
                    WHERE l.delivered = 'f' and l.error = 'f' and l.locked = 'f'
                          and (l.next_retry_at is NULL or l.next_retry_at <= now())
                          and l.archived = 'f'
                    ORDER BY created_at
                    LIMIT $1
                    FOR UPDATE SKIP LOCKED )
      RETURNING id, schema_name, table_name, trigger_name, payload::json, tries, created_at
      
              parameters: $1 = '100'

            
              2020-09-03 14:53:23.883 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              35
              COMMIT
              2020-09-03 14:53:06 EDT
              10/20
              0
              LOG
              00000
              execute 2: COMMIT

            
              2020-09-03 14:53:24.888 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              36
              BEGIN
              2020-09-03 14:53:06 EDT
              10/21
              0
              LOG
              00000
              execute 3: BEGIN ISOLATION LEVEL REPEATABLE READ READ WRITE

            
              2020-09-03 14:53:24.888 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              45
              UPDATE
              2020-09-03 14:53:06 EDT
              9/26
              0
              LOG
              00000
              execute <unnamed>:
        update hdb_catalog.hdb_action_log set status = 'processing'
        where
          id in (
            select id from hdb_catalog.hdb_action_log
            where status = 'created'
            for update skip locked limit 10
          )
        returning
          id, action_name, request_headers::json, session_variables::json, input_payload::json

            
              2020-09-03 14:53:24.889 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              37
              UPDATE
              2020-09-03 14:53:06 EDT
              10/21
              0
              LOG
              00000
              execute 4:
      UPDATE hdb_catalog.event_log
      SET locked = 't'
      WHERE id IN ( SELECT l.id
                    FROM hdb_catalog.event_log l
                    WHERE l.delivered = 'f' and l.error = 'f' and l.locked = 'f'
                          and (l.next_retry_at is NULL or l.next_retry_at <= now())
                          and l.archived = 'f'
                    ORDER BY created_at
                    LIMIT $1
                    FOR UPDATE SKIP LOCKED )
      RETURNING id, schema_name, table_name, trigger_name, payload::json, tries, created_at
      
              parameters: $1 = '100'

            
              2020-09-03 14:53:24.890 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              38
              COMMIT
              2020-09-03 14:53:06 EDT
              10/21
              0
              LOG
              00000
              execute 2: COMMIT

            
              2020-09-03 14:53:25.896 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              46
              BEGIN
              2020-09-03 14:53:06 EDT
              9/27
              0
              LOG
              00000
              execute 3: BEGIN ISOLATION LEVEL REPEATABLE READ READ WRITE

            
              2020-09-03 14:53:25.896 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              39
              UPDATE
              2020-09-03 14:53:06 EDT
              10/22
              0
              LOG
              00000
              execute <unnamed>:
        update hdb_catalog.hdb_action_log set status = 'processing'
        where
          id in (
            select id from hdb_catalog.hdb_action_log
            where status = 'created'
            for update skip locked limit 10
          )
        returning
          id, action_name, request_headers::json, session_variables::json, input_payload::json

            
              2020-09-03 14:53:25.896 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              47
              UPDATE
              2020-09-03 14:53:06 EDT
              9/27
              0
              LOG
              00000
              execute 4:
      UPDATE hdb_catalog.event_log
      SET locked = 't'
      WHERE id IN ( SELECT l.id
                    FROM hdb_catalog.event_log l
                    WHERE l.delivered = 'f' and l.error = 'f' and l.locked = 'f'
                          and (l.next_retry_at is NULL or l.next_retry_at <= now())
                          and l.archived = 'f'
                    ORDER BY created_at
                    LIMIT $1
                    FOR UPDATE SKIP LOCKED )
      RETURNING id, schema_name, table_name, trigger_name, payload::json, tries, created_at
      
              parameters: $1 = '100'

            
              2020-09-03 14:53:25.897 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              48
              COMMIT
              2020-09-03 14:53:06 EDT
              9/27
              0
              LOG
              00000
              execute 2: COMMIT

            
              2020-09-03 14:53:26.897 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              40
              BEGIN
              2020-09-03 14:53:06 EDT
              10/23
              0
              LOG
              00000
              execute 3: BEGIN ISOLATION LEVEL REPEATABLE READ READ WRITE

            
              2020-09-03 14:53:26.898 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              49
              UPDATE
              2020-09-03 14:53:06 EDT
              9/28
              0
              LOG
              00000
              execute <unnamed>:
        update hdb_catalog.hdb_action_log set status = 'processing'
        where
          id in (
            select id from hdb_catalog.hdb_action_log
            where status = 'created'
            for update skip locked limit 10
          )
        returning
          id, action_name, request_headers::json, session_variables::json, input_payload::json

            
              2020-09-03 14:53:26.898 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              41
              UPDATE
              2020-09-03 14:53:06 EDT
              10/23
              0
              LOG
              00000
              execute 4:
      UPDATE hdb_catalog.event_log
      SET locked = 't'
      WHERE id IN ( SELECT l.id
                    FROM hdb_catalog.event_log l
                    WHERE l.delivered = 'f' and l.error = 'f' and l.locked = 'f'
                          and (l.next_retry_at is NULL or l.next_retry_at <= now())
                          and l.archived = 'f'
                    ORDER BY created_at
                    LIMIT $1
                    FOR UPDATE SKIP LOCKED )
      RETURNING id, schema_name, table_name, trigger_name, payload::json, tries, created_at
      
              parameters: $1 = '100'

            
              2020-09-03 14:53:26.899 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              42
              COMMIT
              2020-09-03 14:53:06 EDT
              10/23
              0
              LOG
              00000
              execute 2: COMMIT

            
              2020-09-03 14:53:27.902 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              50
              BEGIN
              2020-09-03 14:53:06 EDT
              9/29
              0
              LOG
              00000
              execute 3: BEGIN ISOLATION LEVEL REPEATABLE READ READ WRITE

            
              2020-09-03 14:53:27.902 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              43
              UPDATE
              2020-09-03 14:53:06 EDT
              10/24
              0
              LOG
              00000
              execute <unnamed>:
        update hdb_catalog.hdb_action_log set status = 'processing'
        where
          id in (
            select id from hdb_catalog.hdb_action_log
            where status = 'created'
            for update skip locked limit 10
          )
        returning
          id, action_name, request_headers::json, session_variables::json, input_payload::json

            
              2020-09-03 14:53:27.903 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              51
              UPDATE
              2020-09-03 14:53:06 EDT
              9/29
              0
              LOG
              00000
              execute 4:
      UPDATE hdb_catalog.event_log
      SET locked = 't'
      WHERE id IN ( SELECT l.id
                    FROM hdb_catalog.event_log l
                    WHERE l.delivered = 'f' and l.error = 'f' and l.locked = 'f'
                          and (l.next_retry_at is NULL or l.next_retry_at <= now())
                          and l.archived = 'f'
                    ORDER BY created_at
                    LIMIT $1
                    FOR UPDATE SKIP LOCKED )
      RETURNING id, schema_name, table_name, trigger_name, payload::json, tries, created_at
      
              parameters: $1 = '100'

            
              2020-09-03 14:53:27.903 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              52
              COMMIT
              2020-09-03 14:53:06 EDT
              9/29
              0
              LOG
              00000
              execute 2: COMMIT

            
              2020-09-03 14:53:28.905 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              53
              BEGIN
              2020-09-03 14:53:06 EDT
              9/30
              0
              LOG
              00000
              execute 3: BEGIN ISOLATION LEVEL REPEATABLE READ READ WRITE

            
              2020-09-03 14:53:28.905 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              44
              UPDATE
              2020-09-03 14:53:06 EDT
              10/25
              0
              LOG
              00000
              execute <unnamed>:
        update hdb_catalog.hdb_action_log set status = 'processing'
        where
          id in (
            select id from hdb_catalog.hdb_action_log
            where status = 'created'
            for update skip locked limit 10
          )
        returning
          id, action_name, request_headers::json, session_variables::json, input_payload::json

            
              2020-09-03 14:53:28.906 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              54
              UPDATE
              2020-09-03 14:53:06 EDT
              9/30
              0
              LOG
              00000
              execute 4:
      UPDATE hdb_catalog.event_log
      SET locked = 't'
      WHERE id IN ( SELECT l.id
                    FROM hdb_catalog.event_log l
                    WHERE l.delivered = 'f' and l.error = 'f' and l.locked = 'f'
                          and (l.next_retry_at is NULL or l.next_retry_at <= now())
                          and l.archived = 'f'
                    ORDER BY created_at
                    LIMIT $1
                    FOR UPDATE SKIP LOCKED )
      RETURNING id, schema_name, table_name, trigger_name, payload::json, tries, created_at
      
              parameters: $1 = '100'

            
              2020-09-03 14:53:28.907 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              55
              COMMIT
              2020-09-03 14:53:06 EDT
              9/30
              0
              LOG
              00000
              execute 2: COMMIT

            
              2020-09-03 14:53:29.908 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              45
              BEGIN
              2020-09-03 14:53:06 EDT
              10/26
              0
              LOG
              00000
              execute 3: BEGIN ISOLATION LEVEL REPEATABLE READ READ WRITE

            
              2020-09-03 14:53:29.909 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              56
              UPDATE
              2020-09-03 14:53:06 EDT
              9/31
              0
              LOG
              00000
              execute <unnamed>:
        update hdb_catalog.hdb_action_log set status = 'processing'
        where
          id in (
            select id from hdb_catalog.hdb_action_log
            where status = 'created'
            for update skip locked limit 10
          )
        returning
          id, action_name, request_headers::json, session_variables::json, input_payload::json

            
              2020-09-03 14:53:29.909 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              46
              UPDATE
              2020-09-03 14:53:06 EDT
              10/26
              0
              LOG
              00000
              execute 4:
      UPDATE hdb_catalog.event_log
      SET locked = 't'
      WHERE id IN ( SELECT l.id
                    FROM hdb_catalog.event_log l
                    WHERE l.delivered = 'f' and l.error = 'f' and l.locked = 'f'
                          and (l.next_retry_at is NULL or l.next_retry_at <= now())
                          and l.archived = 'f'
                    ORDER BY created_at
                    LIMIT $1
                    FOR UPDATE SKIP LOCKED )
      RETURNING id, schema_name, table_name, trigger_name, payload::json, tries, created_at
      
              parameters: $1 = '100'

            
              2020-09-03 14:53:29.910 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              47
              COMMIT
              2020-09-03 14:53:06 EDT
              10/26
              0
              LOG
              00000
              execute 2: COMMIT

            
              2020-09-03 14:53:30.914 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              57
              BEGIN
              2020-09-03 14:53:06 EDT
              9/32
              0
              LOG
              00000
              execute 3: BEGIN ISOLATION LEVEL REPEATABLE READ READ WRITE

            
              2020-09-03 14:53:30.914 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              48
              UPDATE
              2020-09-03 14:53:06 EDT
              10/27
              0
              LOG
              00000
              execute <unnamed>:
        update hdb_catalog.hdb_action_log set status = 'processing'
        where
          id in (
            select id from hdb_catalog.hdb_action_log
            where status = 'created'
            for update skip locked limit 10
          )
        returning
          id, action_name, request_headers::json, session_variables::json, input_payload::json

            
              2020-09-03 14:53:30.915 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              58
              UPDATE
              2020-09-03 14:53:06 EDT
              9/32
              0
              LOG
              00000
              execute 4:
      UPDATE hdb_catalog.event_log
      SET locked = 't'
      WHERE id IN ( SELECT l.id
                    FROM hdb_catalog.event_log l
                    WHERE l.delivered = 'f' and l.error = 'f' and l.locked = 'f'
                          and (l.next_retry_at is NULL or l.next_retry_at <= now())
                          and l.archived = 'f'
                    ORDER BY created_at
                    LIMIT $1
                    FOR UPDATE SKIP LOCKED )
      RETURNING id, schema_name, table_name, trigger_name, payload::json, tries, created_at
      
              parameters: $1 = '100'

            
              2020-09-03 14:53:30.915 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              59
              COMMIT
              2020-09-03 14:53:06 EDT
              9/32
              0
              LOG
              00000
              execute 2: COMMIT

            
              2020-09-03 14:53:31.919 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              49
              BEGIN
              2020-09-03 14:53:06 EDT
              10/28
              0
              LOG
              00000
              execute 3: BEGIN ISOLATION LEVEL REPEATABLE READ READ WRITE

            
              2020-09-03 14:53:31.919 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              60
              UPDATE
              2020-09-03 14:53:06 EDT
              9/33
              0
              LOG
              00000
              execute <unnamed>:
        update hdb_catalog.hdb_action_log set status = 'processing'
        where
          id in (
            select id from hdb_catalog.hdb_action_log
            where status = 'created'
            for update skip locked limit 10
          )
        returning
          id, action_name, request_headers::json, session_variables::json, input_payload::json

            
              2020-09-03 14:53:31.920 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              50
              UPDATE
              2020-09-03 14:53:06 EDT
              10/28
              0
              LOG
              00000
              execute 4:
      UPDATE hdb_catalog.event_log
      SET locked = 't'
      WHERE id IN ( SELECT l.id
                    FROM hdb_catalog.event_log l
                    WHERE l.delivered = 'f' and l.error = 'f' and l.locked = 'f'
                          and (l.next_retry_at is NULL or l.next_retry_at <= now())
                          and l.archived = 'f'
                    ORDER BY created_at
                    LIMIT $1
                    FOR UPDATE SKIP LOCKED )
      RETURNING id, schema_name, table_name, trigger_name, payload::json, tries, created_at
      
              parameters: $1 = '100'

            
              2020-09-03 14:53:31.921 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              51
              COMMIT
              2020-09-03 14:53:06 EDT
              10/28
              0
              LOG
              00000
              execute 2: COMMIT

            
              2020-09-03 14:53:32.922 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              52
              UPDATE
              2020-09-03 14:53:06 EDT
              10/29
              0
              LOG
              00000
              execute <unnamed>:
        update hdb_catalog.hdb_action_log set status = 'processing'
        where
          id in (
            select id from hdb_catalog.hdb_action_log
            where status = 'created'
            for update skip locked limit 10
          )
        returning
          id, action_name, request_headers::json, session_variables::json, input_payload::json

            
              2020-09-03 14:53:32.922 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              53
              BEGIN
              2020-09-03 14:53:06 EDT
              10/30
              0
              LOG
              00000
              execute 3: BEGIN ISOLATION LEVEL REPEATABLE READ READ WRITE

            
              2020-09-03 14:53:32.923 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              54
              UPDATE
              2020-09-03 14:53:06 EDT
              10/30
              0
              LOG
              00000
              execute 4:
      UPDATE hdb_catalog.event_log
      SET locked = 't'
      WHERE id IN ( SELECT l.id
                    FROM hdb_catalog.event_log l
                    WHERE l.delivered = 'f' and l.error = 'f' and l.locked = 'f'
                          and (l.next_retry_at is NULL or l.next_retry_at <= now())
                          and l.archived = 'f'
                    ORDER BY created_at
                    LIMIT $1
                    FOR UPDATE SKIP LOCKED )
      RETURNING id, schema_name, table_name, trigger_name, payload::json, tries, created_at
      
              parameters: $1 = '100'

            
              2020-09-03 14:53:32.923 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              55
              COMMIT
              2020-09-03 14:53:06 EDT
              10/30
              0
              LOG
              00000
              execute 2: COMMIT

            
              2020-09-03 14:53:33.924 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              61
              BEGIN
              2020-09-03 14:53:06 EDT
              9/34
              0
              LOG
              00000
              execute 3: BEGIN ISOLATION LEVEL REPEATABLE READ READ WRITE

            
              2020-09-03 14:53:33.924 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              56
              UPDATE
              2020-09-03 14:53:06 EDT
              10/31
              0
              LOG
              00000
              execute <unnamed>:
        update hdb_catalog.hdb_action_log set status = 'processing'
        where
          id in (
            select id from hdb_catalog.hdb_action_log
            where status = 'created'
            for update skip locked limit 10
          )
        returning
          id, action_name, request_headers::json, session_variables::json, input_payload::json

            
              2020-09-03 14:53:33.925 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              62
              UPDATE
              2020-09-03 14:53:06 EDT
              9/34
              0
              LOG
              00000
              execute 4:
      UPDATE hdb_catalog.event_log
      SET locked = 't'
      WHERE id IN ( SELECT l.id
                    FROM hdb_catalog.event_log l
                    WHERE l.delivered = 'f' and l.error = 'f' and l.locked = 'f'
                          and (l.next_retry_at is NULL or l.next_retry_at <= now())
                          and l.archived = 'f'
                    ORDER BY created_at
                    LIMIT $1
                    FOR UPDATE SKIP LOCKED )
      RETURNING id, schema_name, table_name, trigger_name, payload::json, tries, created_at
      
              parameters: $1 = '100'

            
              2020-09-03 14:53:33.926 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              63
              COMMIT
              2020-09-03 14:53:06 EDT
              9/34
              0
              LOG
              00000
              execute 2: COMMIT

            
              2020-09-03 14:53:34.928 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              57
              BEGIN
              2020-09-03 14:53:06 EDT
              10/32
              0
              LOG
              00000
              execute 3: BEGIN ISOLATION LEVEL REPEATABLE READ READ WRITE

            
              2020-09-03 14:53:34.929 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              64
              UPDATE
              2020-09-03 14:53:06 EDT
              9/35
              0
              LOG
              00000
              execute <unnamed>:
        update hdb_catalog.hdb_action_log set status = 'processing'
        where
          id in (
            select id from hdb_catalog.hdb_action_log
            where status = 'created'
            for update skip locked limit 10
          )
        returning
          id, action_name, request_headers::json, session_variables::json, input_payload::json

            
              2020-09-03 14:53:34.929 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              58
              UPDATE
              2020-09-03 14:53:06 EDT
              10/32
              0
              LOG
              00000
              execute 4:
      UPDATE hdb_catalog.event_log
      SET locked = 't'
      WHERE id IN ( SELECT l.id
                    FROM hdb_catalog.event_log l
                    WHERE l.delivered = 'f' and l.error = 'f' and l.locked = 'f'
                          and (l.next_retry_at is NULL or l.next_retry_at <= now())
                          and l.archived = 'f'
                    ORDER BY created_at
                    LIMIT $1
                    FOR UPDATE SKIP LOCKED )
      RETURNING id, schema_name, table_name, trigger_name, payload::json, tries, created_at
      
              parameters: $1 = '100'

            
              2020-09-03 14:53:34.930 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              59
              COMMIT
              2020-09-03 14:53:06 EDT
              10/32
              0
              LOG
              00000
              execute 2: COMMIT

            
              2020-09-03 14:53:35.933 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              65
              BEGIN
              2020-09-03 14:53:06 EDT
              9/36
              0
              LOG
              00000
              execute 3: BEGIN ISOLATION LEVEL REPEATABLE READ READ WRITE

            
              2020-09-03 14:53:35.933 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              60
              UPDATE
              2020-09-03 14:53:06 EDT
              10/33
              0
              LOG
              00000
              execute <unnamed>:
        update hdb_catalog.hdb_action_log set status = 'processing'
        where
          id in (
            select id from hdb_catalog.hdb_action_log
            where status = 'created'
            for update skip locked limit 10
          )
        returning
          id, action_name, request_headers::json, session_variables::json, input_payload::json

            
              2020-09-03 14:53:35.934 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              66
              UPDATE
              2020-09-03 14:53:06 EDT
              9/36
              0
              LOG
              00000
              execute 4:
      UPDATE hdb_catalog.event_log
      SET locked = 't'
      WHERE id IN ( SELECT l.id
                    FROM hdb_catalog.event_log l
                    WHERE l.delivered = 'f' and l.error = 'f' and l.locked = 'f'
                          and (l.next_retry_at is NULL or l.next_retry_at <= now())
                          and l.archived = 'f'
                    ORDER BY created_at
                    LIMIT $1
                    FOR UPDATE SKIP LOCKED )
      RETURNING id, schema_name, table_name, trigger_name, payload::json, tries, created_at
      
              parameters: $1 = '100'

            
              2020-09-03 14:53:35.934 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              67
              COMMIT
              2020-09-03 14:53:06 EDT
              9/36
              0
              LOG
              00000
              execute 2: COMMIT

            
              2020-09-03 14:53:36.935 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              61
              BEGIN
              2020-09-03 14:53:06 EDT
              10/34
              0
              LOG
              00000
              execute 3: BEGIN ISOLATION LEVEL REPEATABLE READ READ WRITE

            
              2020-09-03 14:53:36.936 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              68
              UPDATE
              2020-09-03 14:53:06 EDT
              9/37
              0
              LOG
              00000
              execute <unnamed>:
        update hdb_catalog.hdb_action_log set status = 'processing'
        where
          id in (
            select id from hdb_catalog.hdb_action_log
            where status = 'created'
            for update skip locked limit 10
          )
        returning
          id, action_name, request_headers::json, session_variables::json, input_payload::json

            
              2020-09-03 14:53:36.936 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              62
              UPDATE
              2020-09-03 14:53:06 EDT
              10/34
              0
              LOG
              00000
              execute 4:
      UPDATE hdb_catalog.event_log
      SET locked = 't'
      WHERE id IN ( SELECT l.id
                    FROM hdb_catalog.event_log l
                    WHERE l.delivered = 'f' and l.error = 'f' and l.locked = 'f'
                          and (l.next_retry_at is NULL or l.next_retry_at <= now())
                          and l.archived = 'f'
                    ORDER BY created_at
                    LIMIT $1
                    FOR UPDATE SKIP LOCKED )
      RETURNING id, schema_name, table_name, trigger_name, payload::json, tries, created_at
      
              parameters: $1 = '100'

            
              2020-09-03 14:53:36.937 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              63
              COMMIT
              2020-09-03 14:53:06 EDT
              10/34
              0
              LOG
              00000
              execute 2: COMMIT

            
              2020-09-03 14:53:37.938 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              69
              BEGIN
              2020-09-03 14:53:06 EDT
              9/38
              0
              LOG
              00000
              execute 3: BEGIN ISOLATION LEVEL REPEATABLE READ READ WRITE

            
              2020-09-03 14:53:37.939 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              64
              UPDATE
              2020-09-03 14:53:06 EDT
              10/35
              0
              LOG
              00000
              execute <unnamed>:
        update hdb_catalog.hdb_action_log set status = 'processing'
        where
          id in (
            select id from hdb_catalog.hdb_action_log
            where status = 'created'
            for update skip locked limit 10
          )
        returning
          id, action_name, request_headers::json, session_variables::json, input_payload::json

            
              2020-09-03 14:53:37.940 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              70
              UPDATE
              2020-09-03 14:53:06 EDT
              9/38
              0
              LOG
              00000
              execute 4:
      UPDATE hdb_catalog.event_log
      SET locked = 't'
      WHERE id IN ( SELECT l.id
                    FROM hdb_catalog.event_log l
                    WHERE l.delivered = 'f' and l.error = 'f' and l.locked = 'f'
                          and (l.next_retry_at is NULL or l.next_retry_at <= now())
                          and l.archived = 'f'
                    ORDER BY created_at
                    LIMIT $1
                    FOR UPDATE SKIP LOCKED )
      RETURNING id, schema_name, table_name, trigger_name, payload::json, tries, created_at
      
              parameters: $1 = '100'

            
              2020-09-03 14:53:37.941 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              71
              COMMIT
              2020-09-03 14:53:06 EDT
              9/38
              0
              LOG
              00000
              execute 2: COMMIT

            
              2020-09-03 14:53:38.943 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              65
              BEGIN
              2020-09-03 14:53:06 EDT
              10/36
              0
              LOG
              00000
              execute 3: BEGIN ISOLATION LEVEL REPEATABLE READ READ WRITE

            
              2020-09-03 14:53:38.944 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              72
              UPDATE
              2020-09-03 14:53:06 EDT
              9/39
              0
              LOG
              00000
              execute <unnamed>:
        update hdb_catalog.hdb_action_log set status = 'processing'
        where
          id in (
            select id from hdb_catalog.hdb_action_log
            where status = 'created'
            for update skip locked limit 10
          )
        returning
          id, action_name, request_headers::json, session_variables::json, input_payload::json

            
              2020-09-03 14:53:38.945 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              66
              UPDATE
              2020-09-03 14:53:06 EDT
              10/36
              0
              LOG
              00000
              execute 4:
      UPDATE hdb_catalog.event_log
      SET locked = 't'
      WHERE id IN ( SELECT l.id
                    FROM hdb_catalog.event_log l
                    WHERE l.delivered = 'f' and l.error = 'f' and l.locked = 'f'
                          and (l.next_retry_at is NULL or l.next_retry_at <= now())
                          and l.archived = 'f'
                    ORDER BY created_at
                    LIMIT $1
                    FOR UPDATE SKIP LOCKED )
      RETURNING id, schema_name, table_name, trigger_name, payload::json, tries, created_at
      
              parameters: $1 = '100'

            
              2020-09-03 14:53:38.946 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              67
              COMMIT
              2020-09-03 14:53:06 EDT
              10/36
              0
              LOG
              00000
              execute 2: COMMIT

            
              2020-09-03 14:53:39.948 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              73
              BEGIN
              2020-09-03 14:53:06 EDT
              9/40
              0
              LOG
              00000
              execute 3: BEGIN ISOLATION LEVEL REPEATABLE READ READ WRITE

            
              2020-09-03 14:53:39.948 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              68
              UPDATE
              2020-09-03 14:53:06 EDT
              10/37
              0
              LOG
              00000
              execute <unnamed>:
        update hdb_catalog.hdb_action_log set status = 'processing'
        where
          id in (
            select id from hdb_catalog.hdb_action_log
            where status = 'created'
            for update skip locked limit 10
          )
        returning
          id, action_name, request_headers::json, session_variables::json, input_payload::json

            
              2020-09-03 14:53:39.949 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              74
              UPDATE
              2020-09-03 14:53:06 EDT
              9/40
              0
              LOG
              00000
              execute 4:
      UPDATE hdb_catalog.event_log
      SET locked = 't'
      WHERE id IN ( SELECT l.id
                    FROM hdb_catalog.event_log l
                    WHERE l.delivered = 'f' and l.error = 'f' and l.locked = 'f'
                          and (l.next_retry_at is NULL or l.next_retry_at <= now())
                          and l.archived = 'f'
                    ORDER BY created_at
                    LIMIT $1
                    FOR UPDATE SKIP LOCKED )
      RETURNING id, schema_name, table_name, trigger_name, payload::json, tries, created_at
      
              parameters: $1 = '100'

            
              2020-09-03 14:53:39.950 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              75
              COMMIT
              2020-09-03 14:53:06 EDT
              9/40
              0
              LOG
              00000
              execute 2: COMMIT

            
              2020-09-03 14:53:40.953 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              69
              BEGIN
              2020-09-03 14:53:06 EDT
              10/38
              0
              LOG
              00000
              execute 3: BEGIN ISOLATION LEVEL REPEATABLE READ READ WRITE

            
              2020-09-03 14:53:40.953 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              76
              UPDATE
              2020-09-03 14:53:06 EDT
              9/41
              0
              LOG
              00000
              execute <unnamed>:
        update hdb_catalog.hdb_action_log set status = 'processing'
        where
          id in (
            select id from hdb_catalog.hdb_action_log
            where status = 'created'
            for update skip locked limit 10
          )
        returning
          id, action_name, request_headers::json, session_variables::json, input_payload::json

            
              2020-09-03 14:53:40.953 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              70
              UPDATE
              2020-09-03 14:53:06 EDT
              10/38
              0
              LOG
              00000
              execute 4:
      UPDATE hdb_catalog.event_log
      SET locked = 't'
      WHERE id IN ( SELECT l.id
                    FROM hdb_catalog.event_log l
                    WHERE l.delivered = 'f' and l.error = 'f' and l.locked = 'f'
                          and (l.next_retry_at is NULL or l.next_retry_at <= now())
                          and l.archived = 'f'
                    ORDER BY created_at
                    LIMIT $1
                    FOR UPDATE SKIP LOCKED )
      RETURNING id, schema_name, table_name, trigger_name, payload::json, tries, created_at
      
              parameters: $1 = '100'

            
              2020-09-03 14:53:40.953 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              71
              COMMIT
              2020-09-03 14:53:06 EDT
              10/38
              0
              LOG
              00000
              execute 2: COMMIT

            
              2020-09-03 14:53:41.955 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              77
              BEGIN
              2020-09-03 14:53:06 EDT
              9/42
              0
              LOG
              00000
              execute 3: BEGIN ISOLATION LEVEL REPEATABLE READ READ WRITE

            
              2020-09-03 14:53:41.955 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              72
              UPDATE
              2020-09-03 14:53:06 EDT
              10/39
              0
              LOG
              00000
              execute <unnamed>:
        update hdb_catalog.hdb_action_log set status = 'processing'
        where
          id in (
            select id from hdb_catalog.hdb_action_log
            where status = 'created'
            for update skip locked limit 10
          )
        returning
          id, action_name, request_headers::json, session_variables::json, input_payload::json

            
              2020-09-03 14:53:41.955 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              78
              UPDATE
              2020-09-03 14:53:06 EDT
              9/42
              0
              LOG
              00000
              execute 4:
      UPDATE hdb_catalog.event_log
      SET locked = 't'
      WHERE id IN ( SELECT l.id
                    FROM hdb_catalog.event_log l
                    WHERE l.delivered = 'f' and l.error = 'f' and l.locked = 'f'
                          and (l.next_retry_at is NULL or l.next_retry_at <= now())
                          and l.archived = 'f'
                    ORDER BY created_at
                    LIMIT $1
                    FOR UPDATE SKIP LOCKED )
      RETURNING id, schema_name, table_name, trigger_name, payload::json, tries, created_at
      
              parameters: $1 = '100'

            
              2020-09-03 14:53:41.956 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              79
              COMMIT
              2020-09-03 14:53:06 EDT
              9/42
              0
              LOG
              00000
              execute 2: COMMIT

            
              2020-09-03 14:53:42.957 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              73
              BEGIN
              2020-09-03 14:53:06 EDT
              10/40
              0
              LOG
              00000
              execute 3: BEGIN ISOLATION LEVEL REPEATABLE READ READ WRITE

            
              2020-09-03 14:53:42.957 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              80
              UPDATE
              2020-09-03 14:53:06 EDT
              9/43
              0
              LOG
              00000
              execute <unnamed>:
        update hdb_catalog.hdb_action_log set status = 'processing'
        where
          id in (
            select id from hdb_catalog.hdb_action_log
            where status = 'created'
            for update skip locked limit 10
          )
        returning
          id, action_name, request_headers::json, session_variables::json, input_payload::json

            
              2020-09-03 14:53:42.958 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              74
              UPDATE
              2020-09-03 14:53:06 EDT
              10/40
              0
              LOG
              00000
              execute 4:
      UPDATE hdb_catalog.event_log
      SET locked = 't'
      WHERE id IN ( SELECT l.id
                    FROM hdb_catalog.event_log l
                    WHERE l.delivered = 'f' and l.error = 'f' and l.locked = 'f'
                          and (l.next_retry_at is NULL or l.next_retry_at <= now())
                          and l.archived = 'f'
                    ORDER BY created_at
                    LIMIT $1
                    FOR UPDATE SKIP LOCKED )
      RETURNING id, schema_name, table_name, trigger_name, payload::json, tries, created_at
      
              parameters: $1 = '100'

            
              2020-09-03 14:53:42.959 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              75
              COMMIT
              2020-09-03 14:53:06 EDT
              10/40
              0
              LOG
              00000
              execute 2: COMMIT

            
              2020-09-03 14:53:43.960 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              76
              UPDATE
              2020-09-03 14:53:06 EDT
              10/41
              0
              LOG
              00000
              execute <unnamed>:
        update hdb_catalog.hdb_action_log set status = 'processing'
        where
          id in (
            select id from hdb_catalog.hdb_action_log
            where status = 'created'
            for update skip locked limit 10
          )
        returning
          id, action_name, request_headers::json, session_variables::json, input_payload::json

            
              2020-09-03 14:53:43.961 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              81
              BEGIN
              2020-09-03 14:53:06 EDT
              9/44
              0
              LOG
              00000
              execute 3: BEGIN ISOLATION LEVEL REPEATABLE READ READ WRITE

            
              2020-09-03 14:53:43.962 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              82
              UPDATE
              2020-09-03 14:53:06 EDT
              9/44
              0
              LOG
              00000
              execute 4:
      UPDATE hdb_catalog.event_log
      SET locked = 't'
      WHERE id IN ( SELECT l.id
                    FROM hdb_catalog.event_log l
                    WHERE l.delivered = 'f' and l.error = 'f' and l.locked = 'f'
                          and (l.next_retry_at is NULL or l.next_retry_at <= now())
                          and l.archived = 'f'
                    ORDER BY created_at
                    LIMIT $1
                    FOR UPDATE SKIP LOCKED )
      RETURNING id, schema_name, table_name, trigger_name, payload::json, tries, created_at
      
              parameters: $1 = '100'

            
              2020-09-03 14:53:43.963 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              83
              COMMIT
              2020-09-03 14:53:06 EDT
              9/44
              0
              LOG
              00000
              execute 2: COMMIT

            
              2020-09-03 14:53:44.964 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              77
              BEGIN
              2020-09-03 14:53:06 EDT
              10/42
              0
              LOG
              00000
              execute 3: BEGIN ISOLATION LEVEL REPEATABLE READ READ WRITE

            
              2020-09-03 14:53:44.964 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              84
              UPDATE
              2020-09-03 14:53:06 EDT
              9/45
              0
              LOG
              00000
              execute <unnamed>:
        update hdb_catalog.hdb_action_log set status = 'processing'
        where
          id in (
            select id from hdb_catalog.hdb_action_log
            where status = 'created'
            for update skip locked limit 10
          )
        returning
          id, action_name, request_headers::json, session_variables::json, input_payload::json

            
              2020-09-03 14:53:44.965 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              78
              UPDATE
              2020-09-03 14:53:06 EDT
              10/42
              0
              LOG
              00000
              execute 4:
      UPDATE hdb_catalog.event_log
      SET locked = 't'
      WHERE id IN ( SELECT l.id
                    FROM hdb_catalog.event_log l
                    WHERE l.delivered = 'f' and l.error = 'f' and l.locked = 'f'
                          and (l.next_retry_at is NULL or l.next_retry_at <= now())
                          and l.archived = 'f'
                    ORDER BY created_at
                    LIMIT $1
                    FOR UPDATE SKIP LOCKED )
      RETURNING id, schema_name, table_name, trigger_name, payload::json, tries, created_at
      
              parameters: $1 = '100'

            
              2020-09-03 14:53:44.966 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              79
              COMMIT
              2020-09-03 14:53:06 EDT
              10/42
              0
              LOG
              00000
              execute 2: COMMIT

            
              2020-09-03 14:53:45.969 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              80
              BEGIN
              2020-09-03 14:53:06 EDT
              10/43
              0
              LOG
              00000
              execute 3: BEGIN ISOLATION LEVEL REPEATABLE READ READ WRITE

            
              2020-09-03 14:53:45.969 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              85
              UPDATE
              2020-09-03 14:53:06 EDT
              9/46
              0
              LOG
              00000
              execute <unnamed>:
        update hdb_catalog.hdb_action_log set status = 'processing'
        where
          id in (
            select id from hdb_catalog.hdb_action_log
            where status = 'created'
            for update skip locked limit 10
          )
        returning
          id, action_name, request_headers::json, session_variables::json, input_payload::json

            
              2020-09-03 14:53:45.970 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              81
              UPDATE
              2020-09-03 14:53:06 EDT
              10/43
              0
              LOG
              00000
              execute 4:
      UPDATE hdb_catalog.event_log
      SET locked = 't'
      WHERE id IN ( SELECT l.id
                    FROM hdb_catalog.event_log l
                    WHERE l.delivered = 'f' and l.error = 'f' and l.locked = 'f'
                          and (l.next_retry_at is NULL or l.next_retry_at <= now())
                          and l.archived = 'f'
                    ORDER BY created_at
                    LIMIT $1
                    FOR UPDATE SKIP LOCKED )
      RETURNING id, schema_name, table_name, trigger_name, payload::json, tries, created_at
      
              parameters: $1 = '100'

            
              2020-09-03 14:53:45.971 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              82
              COMMIT
              2020-09-03 14:53:06 EDT
              10/43
              0
              LOG
              00000
              execute 2: COMMIT

            
              2020-09-03 14:53:46.972 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              86
              BEGIN
              2020-09-03 14:53:06 EDT
              9/47
              0
              LOG
              00000
              execute 3: BEGIN ISOLATION LEVEL REPEATABLE READ READ WRITE

            
              2020-09-03 14:53:46.973 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              83
              UPDATE
              2020-09-03 14:53:06 EDT
              10/44
              0
              LOG
              00000
              execute <unnamed>:
        update hdb_catalog.hdb_action_log set status = 'processing'
        where
          id in (
            select id from hdb_catalog.hdb_action_log
            where status = 'created'
            for update skip locked limit 10
          )
        returning
          id, action_name, request_headers::json, session_variables::json, input_payload::json

            
              2020-09-03 14:53:46.973 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              87
              UPDATE
              2020-09-03 14:53:06 EDT
              9/47
              0
              LOG
              00000
              execute 4:
      UPDATE hdb_catalog.event_log
      SET locked = 't'
      WHERE id IN ( SELECT l.id
                    FROM hdb_catalog.event_log l
                    WHERE l.delivered = 'f' and l.error = 'f' and l.locked = 'f'
                          and (l.next_retry_at is NULL or l.next_retry_at <= now())
                          and l.archived = 'f'
                    ORDER BY created_at
                    LIMIT $1
                    FOR UPDATE SKIP LOCKED )
      RETURNING id, schema_name, table_name, trigger_name, payload::json, tries, created_at
      
              parameters: $1 = '100'

            
              2020-09-03 14:53:46.974 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              88
              COMMIT
              2020-09-03 14:53:06 EDT
              9/47
              0
              LOG
              00000
              execute 2: COMMIT

            
              2020-09-03 14:53:47.978 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              84
              BEGIN
              2020-09-03 14:53:06 EDT
              10/45
              0
              LOG
              00000
              execute 3: BEGIN ISOLATION LEVEL REPEATABLE READ READ WRITE

            
              2020-09-03 14:53:47.978 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              89
              UPDATE
              2020-09-03 14:53:06 EDT
              9/48
              0
              LOG
              00000
              execute <unnamed>:
        update hdb_catalog.hdb_action_log set status = 'processing'
        where
          id in (
            select id from hdb_catalog.hdb_action_log
            where status = 'created'
            for update skip locked limit 10
          )
        returning
          id, action_name, request_headers::json, session_variables::json, input_payload::json

            
              2020-09-03 14:53:47.979 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              85
              UPDATE
              2020-09-03 14:53:06 EDT
              10/45
              0
              LOG
              00000
              execute 4:
      UPDATE hdb_catalog.event_log
      SET locked = 't'
      WHERE id IN ( SELECT l.id
                    FROM hdb_catalog.event_log l
                    WHERE l.delivered = 'f' and l.error = 'f' and l.locked = 'f'
                          and (l.next_retry_at is NULL or l.next_retry_at <= now())
                          and l.archived = 'f'
                    ORDER BY created_at
                    LIMIT $1
                    FOR UPDATE SKIP LOCKED )
      RETURNING id, schema_name, table_name, trigger_name, payload::json, tries, created_at
      
              parameters: $1 = '100'

            
              2020-09-03 14:53:47.979 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              86
              COMMIT
              2020-09-03 14:53:06 EDT
              10/45
              0
              LOG
              00000
              execute 2: COMMIT

            
              2020-09-03 14:53:48.980 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              90
              BEGIN
              2020-09-03 14:53:06 EDT
              9/49
              0
              LOG
              00000
              execute 3: BEGIN ISOLATION LEVEL REPEATABLE READ READ WRITE

            
              2020-09-03 14:53:48.980 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              87
              UPDATE
              2020-09-03 14:53:06 EDT
              10/46
              0
              LOG
              00000
              execute <unnamed>:
        update hdb_catalog.hdb_action_log set status = 'processing'
        where
          id in (
            select id from hdb_catalog.hdb_action_log
            where status = 'created'
            for update skip locked limit 10
          )
        returning
          id, action_name, request_headers::json, session_variables::json, input_payload::json

            
              2020-09-03 14:53:48.981 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              91
              UPDATE
              2020-09-03 14:53:06 EDT
              9/49
              0
              LOG
              00000
              execute 4:
      UPDATE hdb_catalog.event_log
      SET locked = 't'
      WHERE id IN ( SELECT l.id
                    FROM hdb_catalog.event_log l
                    WHERE l.delivered = 'f' and l.error = 'f' and l.locked = 'f'
                          and (l.next_retry_at is NULL or l.next_retry_at <= now())
                          and l.archived = 'f'
                    ORDER BY created_at
                    LIMIT $1
                    FOR UPDATE SKIP LOCKED )
      RETURNING id, schema_name, table_name, trigger_name, payload::json, tries, created_at
      
              parameters: $1 = '100'

            
              2020-09-03 14:53:48.982 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              92
              COMMIT
              2020-09-03 14:53:06 EDT
              9/49
              0
              LOG
              00000
              execute 2: COMMIT

            
              2020-09-03 14:53:49.984 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              93
              UPDATE
              2020-09-03 14:53:06 EDT
              9/50
              0
              LOG
              00000
              execute <unnamed>:
        update hdb_catalog.hdb_action_log set status = 'processing'
        where
          id in (
            select id from hdb_catalog.hdb_action_log
            where status = 'created'
            for update skip locked limit 10
          )
        returning
          id, action_name, request_headers::json, session_variables::json, input_payload::json

            
              2020-09-03 14:53:49.984 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              88
              BEGIN
              2020-09-03 14:53:06 EDT
              10/47
              0
              LOG
              00000
              execute 3: BEGIN ISOLATION LEVEL REPEATABLE READ READ WRITE

            
              2020-09-03 14:53:49.985 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              89
              UPDATE
              2020-09-03 14:53:06 EDT
              10/47
              0
              LOG
              00000
              execute 4:
      UPDATE hdb_catalog.event_log
      SET locked = 't'
      WHERE id IN ( SELECT l.id
                    FROM hdb_catalog.event_log l
                    WHERE l.delivered = 'f' and l.error = 'f' and l.locked = 'f'
                          and (l.next_retry_at is NULL or l.next_retry_at <= now())
                          and l.archived = 'f'
                    ORDER BY created_at
                    LIMIT $1
                    FOR UPDATE SKIP LOCKED )
      RETURNING id, schema_name, table_name, trigger_name, payload::json, tries, created_at
      
              parameters: $1 = '100'

            
              2020-09-03 14:53:49.985 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              90
              COMMIT
              2020-09-03 14:53:06 EDT
              10/47
              0
              LOG
              00000
              execute 2: COMMIT

            
              2020-09-03 14:53:50.986 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              91
              UPDATE
              2020-09-03 14:53:06 EDT
              10/48
              0
              LOG
              00000
              execute <unnamed>:
        update hdb_catalog.hdb_action_log set status = 'processing'
        where
          id in (
            select id from hdb_catalog.hdb_action_log
            where status = 'created'
            for update skip locked limit 10
          )
        returning
          id, action_name, request_headers::json, session_variables::json, input_payload::json

            
              2020-09-03 14:53:50.987 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              92
              BEGIN
              2020-09-03 14:53:06 EDT
              10/49
              0
              LOG
              00000
              execute 3: BEGIN ISOLATION LEVEL REPEATABLE READ READ WRITE

            
              2020-09-03 14:53:50.988 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              93
              UPDATE
              2020-09-03 14:53:06 EDT
              10/49
              0
              LOG
              00000
              execute 4:
      UPDATE hdb_catalog.event_log
      SET locked = 't'
      WHERE id IN ( SELECT l.id
                    FROM hdb_catalog.event_log l
                    WHERE l.delivered = 'f' and l.error = 'f' and l.locked = 'f'
                          and (l.next_retry_at is NULL or l.next_retry_at <= now())
                          and l.archived = 'f'
                    ORDER BY created_at
                    LIMIT $1
                    FOR UPDATE SKIP LOCKED )
      RETURNING id, schema_name, table_name, trigger_name, payload::json, tries, created_at
      
              parameters: $1 = '100'

            
              2020-09-03 14:53:50.989 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              94
              COMMIT
              2020-09-03 14:53:06 EDT
              10/49
              0
              LOG
              00000
              execute 2: COMMIT

            
              2020-09-03 14:53:51.989 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              95
              UPDATE
              2020-09-03 14:53:06 EDT
              10/50
              0
              LOG
              00000
              execute <unnamed>:
        update hdb_catalog.hdb_action_log set status = 'processing'
        where
          id in (
            select id from hdb_catalog.hdb_action_log
            where status = 'created'
            for update skip locked limit 10
          )
        returning
          id, action_name, request_headers::json, session_variables::json, input_payload::json

            
              2020-09-03 14:53:51.991 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              96
              BEGIN
              2020-09-03 14:53:06 EDT
              10/51
              0
              LOG
              00000
              execute 3: BEGIN ISOLATION LEVEL REPEATABLE READ READ WRITE

            
              2020-09-03 14:53:51.991 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              97
              UPDATE
              2020-09-03 14:53:06 EDT
              10/51
              0
              LOG
              00000
              execute 4:
      UPDATE hdb_catalog.event_log
      SET locked = 't'
      WHERE id IN ( SELECT l.id
                    FROM hdb_catalog.event_log l
                    WHERE l.delivered = 'f' and l.error = 'f' and l.locked = 'f'
                          and (l.next_retry_at is NULL or l.next_retry_at <= now())
                          and l.archived = 'f'
                    ORDER BY created_at
                    LIMIT $1
                    FOR UPDATE SKIP LOCKED )
      RETURNING id, schema_name, table_name, trigger_name, payload::json, tries, created_at
      
              parameters: $1 = '100'

            
              2020-09-03 14:53:51.992 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              98
              COMMIT
              2020-09-03 14:53:06 EDT
              10/51
              0
              LOG
              00000
              execute 2: COMMIT

            
              2020-09-03 14:53:52.991 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              99
              UPDATE
              2020-09-03 14:53:06 EDT
              10/52
              0
              LOG
              00000
              execute <unnamed>:
        update hdb_catalog.hdb_action_log set status = 'processing'
        where
          id in (
            select id from hdb_catalog.hdb_action_log
            where status = 'created'
            for update skip locked limit 10
          )
        returning
          id, action_name, request_headers::json, session_variables::json, input_payload::json

            
              2020-09-03 14:53:52.993 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              100
              BEGIN
              2020-09-03 14:53:06 EDT
              10/53
              0
              LOG
              00000
              execute 3: BEGIN ISOLATION LEVEL REPEATABLE READ READ WRITE

            
              2020-09-03 14:53:52.993 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              101
              UPDATE
              2020-09-03 14:53:06 EDT
              10/53
              0
              LOG
              00000
              execute 4:
      UPDATE hdb_catalog.event_log
      SET locked = 't'
      WHERE id IN ( SELECT l.id
                    FROM hdb_catalog.event_log l
                    WHERE l.delivered = 'f' and l.error = 'f' and l.locked = 'f'
                          and (l.next_retry_at is NULL or l.next_retry_at <= now())
                          and l.archived = 'f'
                    ORDER BY created_at
                    LIMIT $1
                    FOR UPDATE SKIP LOCKED )
      RETURNING id, schema_name, table_name, trigger_name, payload::json, tries, created_at
      
              parameters: $1 = '100'

            
              2020-09-03 14:53:52.994 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              102
              COMMIT
              2020-09-03 14:53:06 EDT
              10/53
              0
              LOG
              00000
              execute 2: COMMIT

            
              2020-09-03 14:53:53.993 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              103
              UPDATE
              2020-09-03 14:53:06 EDT
              10/54
              0
              LOG
              00000
              execute <unnamed>:
        update hdb_catalog.hdb_action_log set status = 'processing'
        where
          id in (
            select id from hdb_catalog.hdb_action_log
            where status = 'created'
            for update skip locked limit 10
          )
        returning
          id, action_name, request_headers::json, session_variables::json, input_payload::json

            
              2020-09-03 14:53:53.995 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              104
              BEGIN
              2020-09-03 14:53:06 EDT
              10/55
              0
              LOG
              00000
              execute 3: BEGIN ISOLATION LEVEL REPEATABLE READ READ WRITE

            
              2020-09-03 14:53:53.996 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              105
              UPDATE
              2020-09-03 14:53:06 EDT
              10/55
              0
              LOG
              00000
              execute 4:
      UPDATE hdb_catalog.event_log
      SET locked = 't'
      WHERE id IN ( SELECT l.id
                    FROM hdb_catalog.event_log l
                    WHERE l.delivered = 'f' and l.error = 'f' and l.locked = 'f'
                          and (l.next_retry_at is NULL or l.next_retry_at <= now())
                          and l.archived = 'f'
                    ORDER BY created_at
                    LIMIT $1
                    FOR UPDATE SKIP LOCKED )
      RETURNING id, schema_name, table_name, trigger_name, payload::json, tries, created_at
      
              parameters: $1 = '100'

            
              2020-09-03 14:53:53.996 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              106
              COMMIT
              2020-09-03 14:53:06 EDT
              10/55
              0
              LOG
              00000
              execute 2: COMMIT

            
              2020-09-03 14:53:54.997 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              107
              UPDATE
              2020-09-03 14:53:06 EDT
              10/56
              0
              LOG
              00000
              execute <unnamed>:
        update hdb_catalog.hdb_action_log set status = 'processing'
        where
          id in (
            select id from hdb_catalog.hdb_action_log
            where status = 'created'
            for update skip locked limit 10
          )
        returning
          id, action_name, request_headers::json, session_variables::json, input_payload::json

            
              2020-09-03 14:53:54.997 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              94
              BEGIN
              2020-09-03 14:53:06 EDT
              9/51
              0
              LOG
              00000
              execute 3: BEGIN ISOLATION LEVEL REPEATABLE READ READ WRITE

            
              2020-09-03 14:53:54.997 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              95
              UPDATE
              2020-09-03 14:53:06 EDT
              9/51
              0
              LOG
              00000
              execute 4:
      UPDATE hdb_catalog.event_log
      SET locked = 't'
      WHERE id IN ( SELECT l.id
                    FROM hdb_catalog.event_log l
                    WHERE l.delivered = 'f' and l.error = 'f' and l.locked = 'f'
                          and (l.next_retry_at is NULL or l.next_retry_at <= now())
                          and l.archived = 'f'
                    ORDER BY created_at
                    LIMIT $1
                    FOR UPDATE SKIP LOCKED )
      RETURNING id, schema_name, table_name, trigger_name, payload::json, tries, created_at
      
              parameters: $1 = '100'

            
              2020-09-03 14:53:54.998 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              96
              COMMIT
              2020-09-03 14:53:06 EDT
              9/51
              0
              LOG
              00000
              execute 2: COMMIT

            
              2020-09-03 14:53:55.998 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              97
              UPDATE
              2020-09-03 14:53:06 EDT
              9/52
              0
              LOG
              00000
              execute <unnamed>:
        update hdb_catalog.hdb_action_log set status = 'processing'
        where
          id in (
            select id from hdb_catalog.hdb_action_log
            where status = 'created'
            for update skip locked limit 10
          )
        returning
          id, action_name, request_headers::json, session_variables::json, input_payload::json

            
              2020-09-03 14:53:55.999 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              98
              BEGIN
              2020-09-03 14:53:06 EDT
              9/53
              0
              LOG
              00000
              execute 3: BEGIN ISOLATION LEVEL REPEATABLE READ READ WRITE

            
              2020-09-03 14:53:56.000 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              99
              UPDATE
              2020-09-03 14:53:06 EDT
              9/53
              0
              LOG
              00000
              execute 4:
      UPDATE hdb_catalog.event_log
      SET locked = 't'
      WHERE id IN ( SELECT l.id
                    FROM hdb_catalog.event_log l
                    WHERE l.delivered = 'f' and l.error = 'f' and l.locked = 'f'
                          and (l.next_retry_at is NULL or l.next_retry_at <= now())
                          and l.archived = 'f'
                    ORDER BY created_at
                    LIMIT $1
                    FOR UPDATE SKIP LOCKED )
      RETURNING id, schema_name, table_name, trigger_name, payload::json, tries, created_at
      
              parameters: $1 = '100'

            
              2020-09-03 14:53:56.000 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              100
              COMMIT
              2020-09-03 14:53:06 EDT
              9/53
              0
              LOG
              00000
              execute 2: COMMIT

            
              2020-09-03 14:53:57.000 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              101
              BEGIN
              2020-09-03 14:53:06 EDT
              9/54
              0
              LOG
              00000
              execute 3: BEGIN ISOLATION LEVEL REPEATABLE READ READ WRITE

            
              2020-09-03 14:53:57.000 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              108
              UPDATE
              2020-09-03 14:53:06 EDT
              10/57
              0
              LOG
              00000
              execute <unnamed>:
        update hdb_catalog.hdb_action_log set status = 'processing'
        where
          id in (
            select id from hdb_catalog.hdb_action_log
            where status = 'created'
            for update skip locked limit 10
          )
        returning
          id, action_name, request_headers::json, session_variables::json, input_payload::json

            
              2020-09-03 14:53:57.001 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              102
              UPDATE
              2020-09-03 14:53:06 EDT
              9/54
              0
              LOG
              00000
              execute 4:
      UPDATE hdb_catalog.event_log
      SET locked = 't'
      WHERE id IN ( SELECT l.id
                    FROM hdb_catalog.event_log l
                    WHERE l.delivered = 'f' and l.error = 'f' and l.locked = 'f'
                          and (l.next_retry_at is NULL or l.next_retry_at <= now())
                          and l.archived = 'f'
                    ORDER BY created_at
                    LIMIT $1
                    FOR UPDATE SKIP LOCKED )
      RETURNING id, schema_name, table_name, trigger_name, payload::json, tries, created_at
      
              parameters: $1 = '100'

            
              2020-09-03 14:53:57.001 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              103
              COMMIT
              2020-09-03 14:53:06 EDT
              9/54
              0
              LOG
              00000
              execute 2: COMMIT

            
              2020-09-03 14:53:58.003 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              104
              BEGIN
              2020-09-03 14:53:06 EDT
              9/55
              0
              LOG
              00000
              execute 3: BEGIN ISOLATION LEVEL REPEATABLE READ READ WRITE

            
              2020-09-03 14:53:58.003 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              109
              UPDATE
              2020-09-03 14:53:06 EDT
              10/58
              0
              LOG
              00000
              execute <unnamed>:
        update hdb_catalog.hdb_action_log set status = 'processing'
        where
          id in (
            select id from hdb_catalog.hdb_action_log
            where status = 'created'
            for update skip locked limit 10
          )
        returning
          id, action_name, request_headers::json, session_variables::json, input_payload::json

            
              2020-09-03 14:53:58.003 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              105
              UPDATE
              2020-09-03 14:53:06 EDT
              9/55
              0
              LOG
              00000
              execute 4:
      UPDATE hdb_catalog.event_log
      SET locked = 't'
      WHERE id IN ( SELECT l.id
                    FROM hdb_catalog.event_log l
                    WHERE l.delivered = 'f' and l.error = 'f' and l.locked = 'f'
                          and (l.next_retry_at is NULL or l.next_retry_at <= now())
                          and l.archived = 'f'
                    ORDER BY created_at
                    LIMIT $1
                    FOR UPDATE SKIP LOCKED )
      RETURNING id, schema_name, table_name, trigger_name, payload::json, tries, created_at
      
              parameters: $1 = '100'

            
              2020-09-03 14:53:58.004 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              106
              COMMIT
              2020-09-03 14:53:06 EDT
              9/55
              0
              LOG
              00000
              execute 2: COMMIT

            
              2020-09-03 14:53:59.006 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              107
              BEGIN
              2020-09-03 14:53:06 EDT
              9/56
              0
              LOG
              00000
              execute 3: BEGIN ISOLATION LEVEL REPEATABLE READ READ WRITE

            
              2020-09-03 14:53:59.007 EDT
              jessicalaughlin
              jessicalaughlin
              82265
              127.0.0.1:54868
              5f513b92.14159
              110
              UPDATE
              2020-09-03 14:53:06 EDT
              10/59
              0
              LOG
              00000
              execute <unnamed>:
        update hdb_catalog.hdb_action_log set status = 'processing'
        where
          id in (
            select id from hdb_catalog.hdb_action_log
            where status = 'created'
            for update skip locked limit 10
          )
        returning
          id, action_name, request_headers::json, session_variables::json, input_payload::json

            
              2020-09-03 14:53:59.007 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              108
              UPDATE
              2020-09-03 14:53:06 EDT
              9/56
              0
              LOG
              00000
              execute 4:
      UPDATE hdb_catalog.event_log
      SET locked = 't'
      WHERE id IN ( SELECT l.id
                    FROM hdb_catalog.event_log l
                    WHERE l.delivered = 'f' and l.error = 'f' and l.locked = 'f'
                          and (l.next_retry_at is NULL or l.next_retry_at <= now())
                          and l.archived = 'f'
                    ORDER BY created_at
                    LIMIT $1
                    FOR UPDATE SKIP LOCKED )
      RETURNING id, schema_name, table_name, trigger_name, payload::json, tries, created_at
      
              parameters: $1 = '100'

            
              2020-09-03 14:53:59.008 EDT
              jessicalaughlin
              jessicalaughlin
              82264
              127.0.0.1:54867
              5f513b92.14158
              109
              COMMIT
              2020-09-03 14:53:06 EDT
              9/56
              0
              LOG
              00000
              execute 2: COMMIT