postgres-schema.sql

-- automatically generated with `make postgres-schema`

------------------------------------------------------------------------------------------
-- Database: backendA

--
-- PostgreSQL database dump
--

\restrict 79bbfb4630959c48307653a5cd3d83f2582b3c2210f75f10d79e3ebf0015620

-- Dumped from database version 17.11
-- Dumped by pg_dump version 17.11

SET statement_timeout = 0;
SET lock_timeout = 0;
SET idle_in_transaction_session_timeout = 0;
SET transaction_timeout = 0;
SET client_encoding = 'UTF8';
SET standard_conforming_strings = on;
SELECT pg_catalog.set_config('search_path', '', false);
SET check_function_bodies = false;
SET xmloption = content;
SET client_min_messages = warning;
SET row_security = off;

--
-- Name: arbiter; Type: SCHEMA; Schema: -; Owner: wire-server
--

CREATE SCHEMA arbiter;


ALTER SCHEMA arbiter OWNER TO "wire-server";

--
-- Name: public; Type: SCHEMA; Schema: -; Owner: wire-server
--

-- *not* creating schema, since initdb creates it


ALTER SCHEMA public OWNER TO "wire-server";

--
-- Name: SCHEMA public; Type: COMMENT; Schema: -; Owner: wire-server
--

COMMENT ON SCHEMA public IS '';


--
-- Name: meeting_type; Type: TYPE; Schema: public; Owner: wire-server
--

CREATE TYPE public.meeting_type AS ENUM (
    'immediate',
    'scheduled'
);


ALTER TYPE public.meeting_type OWNER TO "wire-server";

--
-- Name: recurrence_frequency; Type: TYPE; Schema: public; Owner: wire-server
--

CREATE TYPE public.recurrence_frequency AS ENUM (
    'daily',
    'weekly',
    'monthly',
    'yearly'
);


ALTER TYPE public.recurrence_frequency OWNER TO "wire-server";

--
-- Name: maintain_conversations_groups_delete(); Type: FUNCTION; Schema: arbiter; Owner: wire-server
--

CREATE FUNCTION arbiter.maintain_conversations_groups_delete() RETURNS trigger
    LANGUAGE plpgsql
    AS $$
BEGIN
  IF NOT EXISTS (SELECT 1 FROM old_table WHERE group_key IS NOT NULL LIMIT 1) THEN
    RETURN NULL;
  END IF;

  PERFORM 1 FROM "arbiter"."conversations_groups" g
  WHERE g.group_key IN (SELECT group_key FROM old_table WHERE group_key IS NOT NULL)
  ORDER BY g.group_key FOR UPDATE;
  WITH t AS (
    SELECT g0.group_key,
      CASE WHEN hp.priority IS NULL THEN 0 ELSE GREATEST(0, g0.job_count + d.count_delta) END AS job_count,
      CASE WHEN hp.priority IS NULL THEN 0 ELSE GREATEST(0, g0.ready_count + d.ready_delta) END AS ready_count,
      COALESCE(hp.priority, 0) AS min_priority,
      COALESCE(hp.id, 0) AS min_id,
      nd.not_visible_until AS next_due,
      fi.not_visible_until AS in_flight_until
    FROM (
      SELECT group_key, (-COUNT(*))::int AS count_delta,
        (-COUNT(*) FILTER (WHERE not_visible_until IS NULL AND NOT suspended))::int AS ready_delta
      FROM old_table WHERE group_key IS NOT NULL GROUP BY group_key
    ) d
    JOIN "arbiter"."conversations_groups" g0 ON g0.group_key = d.group_key
    LEFT JOIN LATERAL (
      SELECT q.priority, q.id FROM "arbiter"."conversations" q
      WHERE q.group_key = d.group_key
      ORDER BY q.priority ASC, q.id ASC LIMIT 1
    ) hp ON TRUE
    LEFT JOIN LATERAL (
      SELECT q.not_visible_until FROM "arbiter"."conversations" q
      WHERE q.group_key = d.group_key AND q.not_visible_until IS NOT NULL AND NOT q.suspended
      ORDER BY q.not_visible_until ASC LIMIT 1
    ) nd ON TRUE
    LEFT JOIN LATERAL (
      SELECT q.not_visible_until FROM "arbiter"."conversations" q
      WHERE q.group_key = d.group_key AND q.not_visible_until > NOW() AND NOT q.suspended AND (q.attempts > 0 OR q.throttled_until > NOW())
      ORDER BY q.not_visible_until DESC NULLS LAST LIMIT 1
    ) fi ON TRUE
  )
  UPDATE "arbiter"."conversations_groups" g
  SET job_count = t.job_count,
    ready_count = t.ready_count,
    min_priority = t.min_priority,
    min_id = t.min_id,
    next_due = t.next_due,
    in_flight_until = t.in_flight_until
  FROM t
  WHERE g.group_key = t.group_key
    AND (g.job_count, g.ready_count, g.min_priority, g.min_id, g.next_due, g.in_flight_until)
        IS DISTINCT FROM (t.job_count, t.ready_count, t.min_priority, t.min_id, t.next_due, t.in_flight_until);
  RETURN NULL;
END;
$$;


ALTER FUNCTION arbiter.maintain_conversations_groups_delete() OWNER TO "wire-server";

--
-- Name: maintain_conversations_groups_insert(); Type: FUNCTION; Schema: arbiter; Owner: wire-server
--

CREATE FUNCTION arbiter.maintain_conversations_groups_insert() RETURNS trigger
    LANGUAGE plpgsql
    AS $$
BEGIN
  IF NOT EXISTS (SELECT 1 FROM new_table WHERE group_key IS NOT NULL LIMIT 1) THEN
    RETURN NULL;
  END IF;

  PERFORM 1 FROM "arbiter"."conversations_groups" g
  WHERE g.group_key IN (SELECT group_key FROM new_table WHERE group_key IS NOT NULL)
  ORDER BY g.group_key FOR UPDATE;

  INSERT INTO "arbiter"."conversations_groups" (group_key, min_priority, min_id, job_count, ready_count, next_due)
  SELECT group_key,
    MIN(priority) AS min_priority,
    (MIN(ARRAY[priority::bigint, id]))[2] AS min_id,
    COUNT(*) AS job_count,
    COUNT(*) FILTER (WHERE not_visible_until IS NULL AND NOT suspended) AS ready_count,
    MIN(not_visible_until) FILTER (WHERE not_visible_until IS NOT NULL AND NOT suspended) AS next_due
  FROM new_table
  WHERE group_key IS NOT NULL
  GROUP BY group_key
  ORDER BY group_key
  ON CONFLICT (group_key) DO UPDATE SET
    min_priority = CASE WHEN "arbiter"."conversations_groups".job_count = 0 OR (EXCLUDED.min_priority, EXCLUDED.min_id) < ("arbiter"."conversations_groups".min_priority, "arbiter"."conversations_groups".min_id) THEN EXCLUDED.min_priority
      ELSE "arbiter"."conversations_groups".min_priority END,
    min_id = CASE WHEN "arbiter"."conversations_groups".job_count = 0 OR (EXCLUDED.min_priority, EXCLUDED.min_id) < ("arbiter"."conversations_groups".min_priority, "arbiter"."conversations_groups".min_id) THEN EXCLUDED.min_id
      ELSE "arbiter"."conversations_groups".min_id END,
    job_count = "arbiter"."conversations_groups".job_count + EXCLUDED.job_count,
    ready_count = "arbiter"."conversations_groups".ready_count + EXCLUDED.ready_count,
    next_due = LEAST("arbiter"."conversations_groups".next_due, EXCLUDED.next_due),
    in_flight_until = CASE WHEN "arbiter"."conversations_groups".in_flight_until <= NOW()
      THEN NULL ELSE "arbiter"."conversations_groups".in_flight_until END;

  RETURN NULL;
END;
$$;


ALTER FUNCTION arbiter.maintain_conversations_groups_insert() OWNER TO "wire-server";

--
-- Name: maintain_conversations_groups_update(); Type: FUNCTION; Schema: arbiter; Owner: wire-server
--

CREATE FUNCTION arbiter.maintain_conversations_groups_update() RETURNS trigger
    LANGUAGE plpgsql
    AS $$
BEGIN
  IF NOT EXISTS (SELECT 1 FROM new_table WHERE group_key IS NOT NULL LIMIT 1)
     AND NOT EXISTS (SELECT 1 FROM old_table WHERE group_key IS NOT NULL LIMIT 1) THEN
    RETURN NULL;
  END IF;

  IF NOT EXISTS (
    SELECT 1 FROM new_table n JOIN old_table o ON o.id = n.id
    WHERE (n.group_key IS NOT NULL OR o.group_key IS NOT NULL)
      AND (n.group_key IS DISTINCT FROM o.group_key OR n.priority IS DISTINCT FROM o.priority OR n.not_visible_until IS DISTINCT FROM o.not_visible_until OR n.suspended IS DISTINCT FROM o.suspended OR n.attempts IS DISTINCT FROM o.attempts OR n.throttled_until IS DISTINCT FROM o.throttled_until)
    LIMIT 1
  ) THEN
    RETURN NULL;
  END IF;

  PERFORM 1 FROM "arbiter"."conversations_groups" g
  WHERE g.group_key IN (SELECT group_key
  FROM new_table
  WHERE group_key IS NOT NULL
  UNION
  SELECT group_key
  FROM old_table
  WHERE group_key IS NOT NULL)
  ORDER BY g.group_key FOR UPDATE;
  IF EXISTS (
    SELECT 1 FROM new_table n JOIN old_table o ON o.id = n.id
    WHERE o.group_key IS DISTINCT FROM n.group_key LIMIT 1
  ) THEN
    WITH t AS (
      SELECT g0.group_key,
        CASE WHEN hp.priority IS NULL THEN 0 ELSE GREATEST(0, g0.job_count + d.count_delta) END AS job_count,
        CASE WHEN hp.priority IS NULL THEN 0 ELSE GREATEST(0, g0.ready_count + d.ready_delta) END AS ready_count,
        COALESCE(hp.priority, 0) AS min_priority,
        COALESCE(hp.id, 0) AS min_id,
        nd.not_visible_until AS next_due,
        fi.not_visible_until AS in_flight_until
      FROM (
        SELECT o.group_key, (-COUNT(*))::int AS count_delta,
          (-COUNT(*) FILTER (WHERE o.not_visible_until IS NULL AND NOT o.suspended))::int AS ready_delta
        FROM old_table o JOIN new_table n ON n.id = o.id
        WHERE o.group_key IS NOT NULL AND o.group_key IS DISTINCT FROM n.group_key
        GROUP BY o.group_key
      ) d
      JOIN "arbiter"."conversations_groups" g0 ON g0.group_key = d.group_key
      LEFT JOIN LATERAL (
        SELECT q.priority, q.id FROM "arbiter"."conversations" q
        WHERE q.group_key = d.group_key
        ORDER BY q.priority ASC, q.id ASC LIMIT 1
      ) hp ON TRUE
      LEFT JOIN LATERAL (
        SELECT q.not_visible_until FROM "arbiter"."conversations" q
        WHERE q.group_key = d.group_key AND q.not_visible_until IS NOT NULL AND NOT q.suspended
        ORDER BY q.not_visible_until ASC LIMIT 1
      ) nd ON TRUE
      LEFT JOIN LATERAL (
        SELECT q.not_visible_until FROM "arbiter"."conversations" q
        WHERE q.group_key = d.group_key AND q.not_visible_until > NOW() AND NOT q.suspended AND (q.attempts > 0 OR q.throttled_until > NOW())
        ORDER BY q.not_visible_until DESC NULLS LAST LIMIT 1
      ) fi ON TRUE
    )
    UPDATE "arbiter"."conversations_groups" g
    SET job_count = t.job_count,
      ready_count = t.ready_count,
      min_priority = t.min_priority,
      min_id = t.min_id,
      next_due = t.next_due,
      in_flight_until = t.in_flight_until
    FROM t
    WHERE g.group_key = t.group_key
      AND (g.job_count, g.ready_count, g.min_priority, g.min_id, g.next_due, g.in_flight_until)
          IS DISTINCT FROM (t.job_count, t.ready_count, t.min_priority, t.min_id, t.next_due, t.in_flight_until);

    INSERT INTO "arbiter"."conversations_groups" (group_key, min_priority, min_id, job_count, ready_count, next_due)
    SELECT n.group_key,
      MIN(n.priority) AS min_priority,
      (MIN(ARRAY[n.priority::bigint, n.id]))[2] AS min_id,
      COUNT(*) AS job_count,
      COUNT(*) FILTER (WHERE n.not_visible_until IS NULL AND NOT n.suspended) AS ready_count,
      MIN(n.not_visible_until) FILTER (WHERE n.not_visible_until IS NOT NULL AND NOT n.suspended) AS next_due
    FROM new_table n JOIN old_table o ON o.id = n.id
    WHERE n.group_key IS NOT NULL AND o.group_key IS DISTINCT FROM n.group_key
    GROUP BY n.group_key ORDER BY n.group_key
    ON CONFLICT (group_key) DO UPDATE SET min_priority = CASE WHEN "arbiter"."conversations_groups".job_count = 0 OR (EXCLUDED.min_priority, EXCLUDED.min_id) < ("arbiter"."conversations_groups".min_priority, "arbiter"."conversations_groups".min_id) THEN EXCLUDED.min_priority
      ELSE "arbiter"."conversations_groups".min_priority END,
    min_id = CASE WHEN "arbiter"."conversations_groups".job_count = 0 OR (EXCLUDED.min_priority, EXCLUDED.min_id) < ("arbiter"."conversations_groups".min_priority, "arbiter"."conversations_groups".min_id) THEN EXCLUDED.min_id
      ELSE "arbiter"."conversations_groups".min_id END,
    job_count = "arbiter"."conversations_groups".job_count + EXCLUDED.job_count,
    ready_count = "arbiter"."conversations_groups".ready_count + EXCLUDED.ready_count,
    next_due = LEAST("arbiter"."conversations_groups".next_due, EXCLUDED.next_due);

    WITH t AS (
      SELECT g0.group_key,
        CASE WHEN hp.priority IS NULL THEN 0 ELSE GREATEST(0, g0.job_count + d.count_delta) END AS job_count,
        CASE WHEN hp.priority IS NULL THEN 0 ELSE GREATEST(0, g0.ready_count + d.ready_delta) END AS ready_count,
        COALESCE(hp.priority, 0) AS min_priority,
        COALESCE(hp.id, 0) AS min_id,
        nd.not_visible_until AS next_due,
        fi.not_visible_until AS in_flight_until
      FROM (
        SELECT n.group_key, 0 AS count_delta, 0 AS ready_delta
        FROM new_table n JOIN old_table o ON o.id = n.id
        WHERE n.group_key IS NOT NULL AND o.group_key IS DISTINCT FROM n.group_key
        GROUP BY n.group_key
      ) d
      JOIN "arbiter"."conversations_groups" g0 ON g0.group_key = d.group_key
      LEFT JOIN LATERAL (
        SELECT q.priority, q.id FROM "arbiter"."conversations" q
        WHERE q.group_key = d.group_key
        ORDER BY q.priority ASC, q.id ASC LIMIT 1
      ) hp ON TRUE
      LEFT JOIN LATERAL (
        SELECT q.not_visible_until FROM "arbiter"."conversations" q
        WHERE q.group_key = d.group_key AND q.not_visible_until IS NOT NULL AND NOT q.suspended
        ORDER BY q.not_visible_until ASC LIMIT 1
      ) nd ON TRUE
      LEFT JOIN LATERAL (
        SELECT q.not_visible_until FROM "arbiter"."conversations" q
        WHERE q.group_key = d.group_key AND q.not_visible_until > NOW() AND NOT q.suspended AND (q.attempts > 0 OR q.throttled_until > NOW())
        ORDER BY q.not_visible_until DESC NULLS LAST LIMIT 1
      ) fi ON TRUE
    )
    UPDATE "arbiter"."conversations_groups" g
    SET job_count = t.job_count,
      ready_count = t.ready_count,
      min_priority = t.min_priority,
      min_id = t.min_id,
      next_due = t.next_due,
      in_flight_until = t.in_flight_until
    FROM t
    WHERE g.group_key = t.group_key
      AND (g.job_count, g.ready_count, g.min_priority, g.min_id, g.next_due, g.in_flight_until)
          IS DISTINCT FROM (t.job_count, t.ready_count, t.min_priority, t.min_id, t.next_due, t.in_flight_until);
  END IF;
  WITH t AS (
    SELECT g0.group_key,
      CASE WHEN hp.priority IS NULL THEN 0 ELSE GREATEST(0, g0.job_count + d.count_delta) END AS job_count,
      CASE WHEN hp.priority IS NULL THEN 0 ELSE GREATEST(0, g0.ready_count + d.ready_delta) END AS ready_count,
      COALESCE(hp.priority, 0) AS min_priority,
      COALESCE(hp.id, 0) AS min_id,
      nd.not_visible_until AS next_due,
      fi.not_visible_until AS in_flight_until
    FROM (
      SELECT n.group_key, 0 AS count_delta,
        SUM((n.not_visible_until IS NULL AND NOT n.suspended)::int - (o.not_visible_until IS NULL AND NOT o.suspended)::int)::int AS ready_delta
      FROM new_table n JOIN old_table o ON o.id = n.id
      WHERE n.group_key IS NOT NULL
        AND n.group_key IS NOT DISTINCT FROM o.group_key
        AND (n.priority IS DISTINCT FROM o.priority OR n.not_visible_until IS DISTINCT FROM o.not_visible_until OR n.suspended IS DISTINCT FROM o.suspended OR n.attempts IS DISTINCT FROM o.attempts OR n.throttled_until IS DISTINCT FROM o.throttled_until)
      GROUP BY n.group_key
    ) d
    JOIN "arbiter"."conversations_groups" g0 ON g0.group_key = d.group_key
    LEFT JOIN LATERAL (
      SELECT q.priority, q.id FROM "arbiter"."conversations" q
      WHERE q.group_key = d.group_key
      ORDER BY q.priority ASC, q.id ASC LIMIT 1
    ) hp ON TRUE
    LEFT JOIN LATERAL (
      SELECT q.not_visible_until FROM "arbiter"."conversations" q
      WHERE q.group_key = d.group_key AND q.not_visible_until IS NOT NULL AND NOT q.suspended
      ORDER BY q.not_visible_until ASC LIMIT 1
    ) nd ON TRUE
    LEFT JOIN LATERAL (
      SELECT q.not_visible_until FROM "arbiter"."conversations" q
      WHERE q.group_key = d.group_key AND q.not_visible_until > NOW() AND NOT q.suspended AND (q.attempts > 0 OR q.throttled_until > NOW())
      ORDER BY q.not_visible_until DESC NULLS LAST LIMIT 1
    ) fi ON TRUE
  )
  UPDATE "arbiter"."conversations_groups" g
  SET job_count = t.job_count,
    ready_count = t.ready_count,
    min_priority = t.min_priority,
    min_id = t.min_id,
    next_due = t.next_due,
    in_flight_until = t.in_flight_until
  FROM t
  WHERE g.group_key = t.group_key
    AND (g.job_count, g.ready_count, g.min_priority, g.min_id, g.next_due, g.in_flight_until)
        IS DISTINCT FROM (t.job_count, t.ready_count, t.min_priority, t.min_id, t.next_due, t.in_flight_until);
  RETURN NULL;
END;
$$;


ALTER FUNCTION arbiter.maintain_conversations_groups_update() OWNER TO "wire-server";

--
-- Name: maintain_meetings_groups_delete(); Type: FUNCTION; Schema: arbiter; Owner: wire-server
--

CREATE FUNCTION arbiter.maintain_meetings_groups_delete() RETURNS trigger
    LANGUAGE plpgsql
    AS $$
BEGIN
  IF NOT EXISTS (SELECT 1 FROM old_table WHERE group_key IS NOT NULL LIMIT 1) THEN
    RETURN NULL;
  END IF;

  PERFORM 1 FROM "arbiter"."meetings_groups" g
  WHERE g.group_key IN (SELECT group_key FROM old_table WHERE group_key IS NOT NULL)
  ORDER BY g.group_key FOR UPDATE;
  WITH t AS (
    SELECT g0.group_key,
      CASE WHEN hp.priority IS NULL THEN 0 ELSE GREATEST(0, g0.job_count + d.count_delta) END AS job_count,
      CASE WHEN hp.priority IS NULL THEN 0 ELSE GREATEST(0, g0.ready_count + d.ready_delta) END AS ready_count,
      COALESCE(hp.priority, 0) AS min_priority,
      COALESCE(hp.id, 0) AS min_id,
      nd.not_visible_until AS next_due,
      fi.not_visible_until AS in_flight_until
    FROM (
      SELECT group_key, (-COUNT(*))::int AS count_delta,
        (-COUNT(*) FILTER (WHERE not_visible_until IS NULL AND NOT suspended))::int AS ready_delta
      FROM old_table WHERE group_key IS NOT NULL GROUP BY group_key
    ) d
    JOIN "arbiter"."meetings_groups" g0 ON g0.group_key = d.group_key
    LEFT JOIN LATERAL (
      SELECT q.priority, q.id FROM "arbiter"."meetings" q
      WHERE q.group_key = d.group_key
      ORDER BY q.priority ASC, q.id ASC LIMIT 1
    ) hp ON TRUE
    LEFT JOIN LATERAL (
      SELECT q.not_visible_until FROM "arbiter"."meetings" q
      WHERE q.group_key = d.group_key AND q.not_visible_until IS NOT NULL AND NOT q.suspended
      ORDER BY q.not_visible_until ASC LIMIT 1
    ) nd ON TRUE
    LEFT JOIN LATERAL (
      SELECT q.not_visible_until FROM "arbiter"."meetings" q
      WHERE q.group_key = d.group_key AND q.not_visible_until > NOW() AND NOT q.suspended AND (q.attempts > 0 OR q.throttled_until > NOW())
      ORDER BY q.not_visible_until DESC NULLS LAST LIMIT 1
    ) fi ON TRUE
  )
  UPDATE "arbiter"."meetings_groups" g
  SET job_count = t.job_count,
    ready_count = t.ready_count,
    min_priority = t.min_priority,
    min_id = t.min_id,
    next_due = t.next_due,
    in_flight_until = t.in_flight_until
  FROM t
  WHERE g.group_key = t.group_key
    AND (g.job_count, g.ready_count, g.min_priority, g.min_id, g.next_due, g.in_flight_until)
        IS DISTINCT FROM (t.job_count, t.ready_count, t.min_priority, t.min_id, t.next_due, t.in_flight_until);
  RETURN NULL;
END;
$$;


ALTER FUNCTION arbiter.maintain_meetings_groups_delete() OWNER TO "wire-server";

--
-- Name: maintain_meetings_groups_insert(); Type: FUNCTION; Schema: arbiter; Owner: wire-server
--

CREATE FUNCTION arbiter.maintain_meetings_groups_insert() RETURNS trigger
    LANGUAGE plpgsql
    AS $$
BEGIN
  IF NOT EXISTS (SELECT 1 FROM new_table WHERE group_key IS NOT NULL LIMIT 1) THEN
    RETURN NULL;
  END IF;

  PERFORM 1 FROM "arbiter"."meetings_groups" g
  WHERE g.group_key IN (SELECT group_key FROM new_table WHERE group_key IS NOT NULL)
  ORDER BY g.group_key FOR UPDATE;

  INSERT INTO "arbiter"."meetings_groups" (group_key, min_priority, min_id, job_count, ready_count, next_due)
  SELECT group_key,
    MIN(priority) AS min_priority,
    (MIN(ARRAY[priority::bigint, id]))[2] AS min_id,
    COUNT(*) AS job_count,
    COUNT(*) FILTER (WHERE not_visible_until IS NULL AND NOT suspended) AS ready_count,
    MIN(not_visible_until) FILTER (WHERE not_visible_until IS NOT NULL AND NOT suspended) AS next_due
  FROM new_table
  WHERE group_key IS NOT NULL
  GROUP BY group_key
  ORDER BY group_key
  ON CONFLICT (group_key) DO UPDATE SET
    min_priority = CASE WHEN "arbiter"."meetings_groups".job_count = 0 OR (EXCLUDED.min_priority, EXCLUDED.min_id) < ("arbiter"."meetings_groups".min_priority, "arbiter"."meetings_groups".min_id) THEN EXCLUDED.min_priority
      ELSE "arbiter"."meetings_groups".min_priority END,
    min_id = CASE WHEN "arbiter"."meetings_groups".job_count = 0 OR (EXCLUDED.min_priority, EXCLUDED.min_id) < ("arbiter"."meetings_groups".min_priority, "arbiter"."meetings_groups".min_id) THEN EXCLUDED.min_id
      ELSE "arbiter"."meetings_groups".min_id END,
    job_count = "arbiter"."meetings_groups".job_count + EXCLUDED.job_count,
    ready_count = "arbiter"."meetings_groups".ready_count + EXCLUDED.ready_count,
    next_due = LEAST("arbiter"."meetings_groups".next_due, EXCLUDED.next_due),
    in_flight_until = CASE WHEN "arbiter"."meetings_groups".in_flight_until <= NOW()
      THEN NULL ELSE "arbiter"."meetings_groups".in_flight_until END;

  RETURN NULL;
END;
$$;


ALTER FUNCTION arbiter.maintain_meetings_groups_insert() OWNER TO "wire-server";

--
-- Name: maintain_meetings_groups_update(); Type: FUNCTION; Schema: arbiter; Owner: wire-server
--

CREATE FUNCTION arbiter.maintain_meetings_groups_update() RETURNS trigger
    LANGUAGE plpgsql
    AS $$
BEGIN
  IF NOT EXISTS (SELECT 1 FROM new_table WHERE group_key IS NOT NULL LIMIT 1)
     AND NOT EXISTS (SELECT 1 FROM old_table WHERE group_key IS NOT NULL LIMIT 1) THEN
    RETURN NULL;
  END IF;

  IF NOT EXISTS (
    SELECT 1 FROM new_table n JOIN old_table o ON o.id = n.id
    WHERE (n.group_key IS NOT NULL OR o.group_key IS NOT NULL)
      AND (n.group_key IS DISTINCT FROM o.group_key OR n.priority IS DISTINCT FROM o.priority OR n.not_visible_until IS DISTINCT FROM o.not_visible_until OR n.suspended IS DISTINCT FROM o.suspended OR n.attempts IS DISTINCT FROM o.attempts OR n.throttled_until IS DISTINCT FROM o.throttled_until)
    LIMIT 1
  ) THEN
    RETURN NULL;
  END IF;

  PERFORM 1 FROM "arbiter"."meetings_groups" g
  WHERE g.group_key IN (SELECT group_key
  FROM new_table
  WHERE group_key IS NOT NULL
  UNION
  SELECT group_key
  FROM old_table
  WHERE group_key IS NOT NULL)
  ORDER BY g.group_key FOR UPDATE;
  IF EXISTS (
    SELECT 1 FROM new_table n JOIN old_table o ON o.id = n.id
    WHERE o.group_key IS DISTINCT FROM n.group_key LIMIT 1
  ) THEN
    WITH t AS (
      SELECT g0.group_key,
        CASE WHEN hp.priority IS NULL THEN 0 ELSE GREATEST(0, g0.job_count + d.count_delta) END AS job_count,
        CASE WHEN hp.priority IS NULL THEN 0 ELSE GREATEST(0, g0.ready_count + d.ready_delta) END AS ready_count,
        COALESCE(hp.priority, 0) AS min_priority,
        COALESCE(hp.id, 0) AS min_id,
        nd.not_visible_until AS next_due,
        fi.not_visible_until AS in_flight_until
      FROM (
        SELECT o.group_key, (-COUNT(*))::int AS count_delta,
          (-COUNT(*) FILTER (WHERE o.not_visible_until IS NULL AND NOT o.suspended))::int AS ready_delta
        FROM old_table o JOIN new_table n ON n.id = o.id
        WHERE o.group_key IS NOT NULL AND o.group_key IS DISTINCT FROM n.group_key
        GROUP BY o.group_key
      ) d
      JOIN "arbiter"."meetings_groups" g0 ON g0.group_key = d.group_key
      LEFT JOIN LATERAL (
        SELECT q.priority, q.id FROM "arbiter"."meetings" q
        WHERE q.group_key = d.group_key
        ORDER BY q.priority ASC, q.id ASC LIMIT 1
      ) hp ON TRUE
      LEFT JOIN LATERAL (
        SELECT q.not_visible_until FROM "arbiter"."meetings" q
        WHERE q.group_key = d.group_key AND q.not_visible_until IS NOT NULL AND NOT q.suspended
        ORDER BY q.not_visible_until ASC LIMIT 1
      ) nd ON TRUE
      LEFT JOIN LATERAL (
        SELECT q.not_visible_until FROM "arbiter"."meetings" q
        WHERE q.group_key = d.group_key AND q.not_visible_until > NOW() AND NOT q.suspended AND (q.attempts > 0 OR q.throttled_until > NOW())
        ORDER BY q.not_visible_until DESC NULLS LAST LIMIT 1
      ) fi ON TRUE
    )
    UPDATE "arbiter"."meetings_groups" g
    SET job_count = t.job_count,
      ready_count = t.ready_count,
      min_priority = t.min_priority,
      min_id = t.min_id,
      next_due = t.next_due,
      in_flight_until = t.in_flight_until
    FROM t
    WHERE g.group_key = t.group_key
      AND (g.job_count, g.ready_count, g.min_priority, g.min_id, g.next_due, g.in_flight_until)
          IS DISTINCT FROM (t.job_count, t.ready_count, t.min_priority, t.min_id, t.next_due, t.in_flight_until);

    INSERT INTO "arbiter"."meetings_groups" (group_key, min_priority, min_id, job_count, ready_count, next_due)
    SELECT n.group_key,
      MIN(n.priority) AS min_priority,
      (MIN(ARRAY[n.priority::bigint, n.id]))[2] AS min_id,
      COUNT(*) AS job_count,
      COUNT(*) FILTER (WHERE n.not_visible_until IS NULL AND NOT n.suspended) AS ready_count,
      MIN(n.not_visible_until) FILTER (WHERE n.not_visible_until IS NOT NULL AND NOT n.suspended) AS next_due
    FROM new_table n JOIN old_table o ON o.id = n.id
    WHERE n.group_key IS NOT NULL AND o.group_key IS DISTINCT FROM n.group_key
    GROUP BY n.group_key ORDER BY n.group_key
    ON CONFLICT (group_key) DO UPDATE SET min_priority = CASE WHEN "arbiter"."meetings_groups".job_count = 0 OR (EXCLUDED.min_priority, EXCLUDED.min_id) < ("arbiter"."meetings_groups".min_priority, "arbiter"."meetings_groups".min_id) THEN EXCLUDED.min_priority
      ELSE "arbiter"."meetings_groups".min_priority END,
    min_id = CASE WHEN "arbiter"."meetings_groups".job_count = 0 OR (EXCLUDED.min_priority, EXCLUDED.min_id) < ("arbiter"."meetings_groups".min_priority, "arbiter"."meetings_groups".min_id) THEN EXCLUDED.min_id
      ELSE "arbiter"."meetings_groups".min_id END,
    job_count = "arbiter"."meetings_groups".job_count + EXCLUDED.job_count,
    ready_count = "arbiter"."meetings_groups".ready_count + EXCLUDED.ready_count,
    next_due = LEAST("arbiter"."meetings_groups".next_due, EXCLUDED.next_due);

    WITH t AS (
      SELECT g0.group_key,
        CASE WHEN hp.priority IS NULL THEN 0 ELSE GREATEST(0, g0.job_count + d.count_delta) END AS job_count,
        CASE WHEN hp.priority IS NULL THEN 0 ELSE GREATEST(0, g0.ready_count + d.ready_delta) END AS ready_count,
        COALESCE(hp.priority, 0) AS min_priority,
        COALESCE(hp.id, 0) AS min_id,
        nd.not_visible_until AS next_due,
        fi.not_visible_until AS in_flight_until
      FROM (
        SELECT n.group_key, 0 AS count_delta, 0 AS ready_delta
        FROM new_table n JOIN old_table o ON o.id = n.id
        WHERE n.group_key IS NOT NULL AND o.group_key IS DISTINCT FROM n.group_key
        GROUP BY n.group_key
      ) d
      JOIN "arbiter"."meetings_groups" g0 ON g0.group_key = d.group_key
      LEFT JOIN LATERAL (
        SELECT q.priority, q.id FROM "arbiter"."meetings" q
        WHERE q.group_key = d.group_key
        ORDER BY q.priority ASC, q.id ASC LIMIT 1
      ) hp ON TRUE
      LEFT JOIN LATERAL (
        SELECT q.not_visible_until FROM "arbiter"."meetings" q
        WHERE q.group_key = d.group_key AND q.not_visible_until IS NOT NULL AND NOT q.suspended
        ORDER BY q.not_visible_until ASC LIMIT 1
      ) nd ON TRUE
      LEFT JOIN LATERAL (
        SELECT q.not_visible_until FROM "arbiter"."meetings" q
        WHERE q.group_key = d.group_key AND q.not_visible_until > NOW() AND NOT q.suspended AND (q.attempts > 0 OR q.throttled_until > NOW())
        ORDER BY q.not_visible_until DESC NULLS LAST LIMIT 1
      ) fi ON TRUE
    )
    UPDATE "arbiter"."meetings_groups" g
    SET job_count = t.job_count,
      ready_count = t.ready_count,
      min_priority = t.min_priority,
      min_id = t.min_id,
      next_due = t.next_due,
      in_flight_until = t.in_flight_until
    FROM t
    WHERE g.group_key = t.group_key
      AND (g.job_count, g.ready_count, g.min_priority, g.min_id, g.next_due, g.in_flight_until)
          IS DISTINCT FROM (t.job_count, t.ready_count, t.min_priority, t.min_id, t.next_due, t.in_flight_until);
  END IF;
  WITH t AS (
    SELECT g0.group_key,
      CASE WHEN hp.priority IS NULL THEN 0 ELSE GREATEST(0, g0.job_count + d.count_delta) END AS job_count,
      CASE WHEN hp.priority IS NULL THEN 0 ELSE GREATEST(0, g0.ready_count + d.ready_delta) END AS ready_count,
      COALESCE(hp.priority, 0) AS min_priority,
      COALESCE(hp.id, 0) AS min_id,
      nd.not_visible_until AS next_due,
      fi.not_visible_until AS in_flight_until
    FROM (
      SELECT n.group_key, 0 AS count_delta,
        SUM((n.not_visible_until IS NULL AND NOT n.suspended)::int - (o.not_visible_until IS NULL AND NOT o.suspended)::int)::int AS ready_delta
      FROM new_table n JOIN old_table o ON o.id = n.id
      WHERE n.group_key IS NOT NULL
        AND n.group_key IS NOT DISTINCT FROM o.group_key
        AND (n.priority IS DISTINCT FROM o.priority OR n.not_visible_until IS DISTINCT FROM o.not_visible_until OR n.suspended IS DISTINCT FROM o.suspended OR n.attempts IS DISTINCT FROM o.attempts OR n.throttled_until IS DISTINCT FROM o.throttled_until)
      GROUP BY n.group_key
    ) d
    JOIN "arbiter"."meetings_groups" g0 ON g0.group_key = d.group_key
    LEFT JOIN LATERAL (
      SELECT q.priority, q.id FROM "arbiter"."meetings" q
      WHERE q.group_key = d.group_key
      ORDER BY q.priority ASC, q.id ASC LIMIT 1
    ) hp ON TRUE
    LEFT JOIN LATERAL (
      SELECT q.not_visible_until FROM "arbiter"."meetings" q
      WHERE q.group_key = d.group_key AND q.not_visible_until IS NOT NULL AND NOT q.suspended
      ORDER BY q.not_visible_until ASC LIMIT 1
    ) nd ON TRUE
    LEFT JOIN LATERAL (
      SELECT q.not_visible_until FROM "arbiter"."meetings" q
      WHERE q.group_key = d.group_key AND q.not_visible_until > NOW() AND NOT q.suspended AND (q.attempts > 0 OR q.throttled_until > NOW())
      ORDER BY q.not_visible_until DESC NULLS LAST LIMIT 1
    ) fi ON TRUE
  )
  UPDATE "arbiter"."meetings_groups" g
  SET job_count = t.job_count,
    ready_count = t.ready_count,
    min_priority = t.min_priority,
    min_id = t.min_id,
    next_due = t.next_due,
    in_flight_until = t.in_flight_until
  FROM t
  WHERE g.group_key = t.group_key
    AND (g.job_count, g.ready_count, g.min_priority, g.min_id, g.next_due, g.in_flight_until)
        IS DISTINCT FROM (t.job_count, t.ready_count, t.min_priority, t.min_id, t.next_due, t.in_flight_until);
  RETURN NULL;
END;
$$;


ALTER FUNCTION arbiter.maintain_meetings_groups_update() OWNER TO "wire-server";

--
-- Name: notify_conversations_created(); Type: FUNCTION; Schema: arbiter; Owner: wire-server
--

CREATE FUNCTION arbiter.notify_conversations_created() RETURNS trigger
    LANGUAGE plpgsql
    AS $$
BEGIN
  IF EXISTS (SELECT 1 FROM new_table) THEN
    PERFORM pg_notify('conversations_created', '');
  END IF;
  RETURN NULL;
END;
$$;


ALTER FUNCTION arbiter.notify_conversations_created() OWNER TO "wire-server";

--
-- Name: FUNCTION notify_conversations_created(); Type: COMMENT; Schema: arbiter; Owner: wire-server
--

COMMENT ON FUNCTION arbiter.notify_conversations_created() IS 'arbiter:notify:v1';


--
-- Name: notify_meetings_created(); Type: FUNCTION; Schema: arbiter; Owner: wire-server
--

CREATE FUNCTION arbiter.notify_meetings_created() RETURNS trigger
    LANGUAGE plpgsql
    AS $$
BEGIN
  IF EXISTS (SELECT 1 FROM new_table) THEN
    PERFORM pg_notify('meetings_created', '');
  END IF;
  RETURN NULL;
END;
$$;


ALTER FUNCTION arbiter.notify_meetings_created() OWNER TO "wire-server";

--
-- Name: FUNCTION notify_meetings_created(); Type: COMMENT; Schema: arbiter; Owner: wire-server
--

COMMENT ON FUNCTION arbiter.notify_meetings_created() IS 'arbiter:notify:v1';


--
-- Name: update_updated_at(); Type: FUNCTION; Schema: public; Owner: wire-server
--

CREATE FUNCTION public.update_updated_at() RETURNS trigger
    LANGUAGE plpgsql
    AS $$
BEGIN
  NEW.updated_at = now();
  RETURN NEW;
END;
$$;


ALTER FUNCTION public.update_updated_at() OWNER TO "wire-server";

SET default_tablespace = '';

SET default_table_access_method = heap;

--
-- Name: arbiter_concurrency; Type: TABLE; Schema: arbiter; Owner: wire-server
--

CREATE UNLOGGED TABLE arbiter.arbiter_concurrency (
    concurrency_key text NOT NULL,
    concurrency_prefix text NOT NULL,
    in_flight integer DEFAULT 0 NOT NULL
)
WITH (fillfactor='80');


ALTER TABLE arbiter.arbiter_concurrency OWNER TO "wire-server";

--
-- Name: arbiter_concurrency_policies; Type: TABLE; Schema: arbiter; Owner: wire-server
--

CREATE TABLE arbiter.arbiter_concurrency_policies (
    prefix_id text NOT NULL,
    default_limit integer NOT NULL,
    override_limit integer,
    CONSTRAINT arbiter_concurrency_policies_default_limit_check CHECK ((default_limit > 0)),
    CONSTRAINT arbiter_concurrency_policies_override_limit_check CHECK ((override_limit >= 0))
);


ALTER TABLE arbiter.arbiter_concurrency_policies OWNER TO "wire-server";

--
-- Name: arbiter_gates; Type: TABLE; Schema: arbiter; Owner: wire-server
--

CREATE TABLE arbiter.arbiter_gates (
    task_name text NOT NULL,
    last_run_at timestamp with time zone DEFAULT '1970-01-01 00:00:00+00'::timestamp with time zone NOT NULL,
    metadata jsonb
);


ALTER TABLE arbiter.arbiter_gates OWNER TO "wire-server";

--
-- Name: arbiter_queues; Type: TABLE; Schema: arbiter; Owner: wire-server
--

CREATE TABLE arbiter.arbiter_queues (
    queue_name text NOT NULL,
    paused boolean DEFAULT false NOT NULL,
    paused_at timestamp with time zone,
    metadata jsonb,
    created_at timestamp with time zone DEFAULT now() NOT NULL,
    updated_at timestamp with time zone DEFAULT now() NOT NULL
);


ALTER TABLE arbiter.arbiter_queues OWNER TO "wire-server";

--
-- Name: arbiter_rate_limit_policies; Type: TABLE; Schema: arbiter; Owner: wire-server
--

CREATE TABLE arbiter.arbiter_rate_limit_policies (
    prefix_id text NOT NULL,
    default_max_tokens double precision NOT NULL,
    default_refill_amount double precision NOT NULL,
    default_interval double precision NOT NULL,
    override_max_tokens double precision,
    override_refill_amount double precision,
    override_interval double precision,
    CONSTRAINT arbiter_rate_limit_policies_default_interval_check CHECK ((default_interval > (0)::double precision)),
    CONSTRAINT arbiter_rate_limit_policies_default_max_tokens_check CHECK ((default_max_tokens >= (0)::double precision)),
    CONSTRAINT arbiter_rate_limit_policies_default_refill_amount_check CHECK ((default_refill_amount >= (0)::double precision)),
    CONSTRAINT arbiter_rate_limit_policies_override_interval_check CHECK ((override_interval > (0)::double precision)),
    CONSTRAINT arbiter_rate_limit_policies_override_max_tokens_check CHECK ((override_max_tokens >= (0)::double precision)),
    CONSTRAINT arbiter_rate_limit_policies_override_refill_amount_check CHECK ((override_refill_amount >= (0)::double precision))
);


ALTER TABLE arbiter.arbiter_rate_limit_policies OWNER TO "wire-server";

--
-- Name: arbiter_rate_limits; Type: TABLE; Schema: arbiter; Owner: wire-server
--

CREATE UNLOGGED TABLE arbiter.arbiter_rate_limits (
    rate_limit_key text NOT NULL,
    policy_prefix text NOT NULL,
    tokens double precision NOT NULL,
    last_refill timestamp with time zone NOT NULL
)
WITH (fillfactor='80');


ALTER TABLE arbiter.arbiter_rate_limits OWNER TO "wire-server";

--
-- Name: arbiter_workers; Type: TABLE; Schema: arbiter; Owner: wire-server
--

CREATE TABLE arbiter.arbiter_workers (
    worker_id uuid NOT NULL,
    queue_name text NOT NULL,
    host_name text,
    worker_count integer,
    started_at timestamp with time zone DEFAULT now() NOT NULL,
    last_heartbeat timestamp with time zone DEFAULT now() NOT NULL,
    shutting_down boolean DEFAULT false NOT NULL,
    paused boolean DEFAULT false NOT NULL,
    stale_threshold_secs double precision DEFAULT 300 NOT NULL,
    metadata jsonb
);


ALTER TABLE arbiter.arbiter_workers OWNER TO "wire-server";

--
-- Name: conversations; Type: TABLE; Schema: arbiter; Owner: wire-server
--

CREATE TABLE arbiter.conversations (
    id bigint NOT NULL,
    payload jsonb NOT NULL,
    group_key text,
    inserted_at timestamp with time zone DEFAULT now() NOT NULL,
    updated_at timestamp with time zone,
    last_attempted_at timestamp with time zone,
    not_visible_until timestamp with time zone,
    attempts integer DEFAULT 0 NOT NULL,
    last_error text,
    priority integer DEFAULT 0 NOT NULL,
    dedup_key text,
    dedup_strategy text,
    max_attempts integer DEFAULT 10,
    parent_id bigint,
    parent_state jsonb,
    suspended boolean DEFAULT false NOT NULL,
    claimed_by uuid,
    rate_limit_key text,
    rate_limit_prefix text,
    throttled_until timestamp with time zone,
    concurrency_key text,
    concurrency_prefix text,
    rate_limit_cost double precision DEFAULT 1 NOT NULL,
    cancel_requested_at timestamp with time zone,
    archive_for integer,
    traceparent text,
    tracestate text,
    claim_seq bigint DEFAULT 0 NOT NULL,
    kind text
)
WITH (fillfactor='100');


ALTER TABLE arbiter.conversations OWNER TO "wire-server";

--
-- Name: conversations_archive; Type: TABLE; Schema: arbiter; Owner: wire-server
--

CREATE TABLE arbiter.conversations_archive (
    id bigint NOT NULL,
    completed_at timestamp with time zone DEFAULT now() NOT NULL,
    archive_expires_at timestamp with time zone NOT NULL,
    job_id bigint NOT NULL,
    claimed_by uuid,
    archive_for integer,
    rate_limit_key text,
    rate_limit_prefix text,
    rate_limit_cost double precision,
    concurrency_key text,
    concurrency_prefix text,
    result jsonb,
    payload jsonb NOT NULL,
    group_key text,
    inserted_at timestamp with time zone DEFAULT now() NOT NULL,
    updated_at timestamp with time zone,
    last_attempted_at timestamp with time zone,
    not_visible_until timestamp with time zone,
    attempts integer DEFAULT 0 NOT NULL,
    last_error text,
    priority integer DEFAULT 0 NOT NULL,
    dedup_key text,
    dedup_strategy text,
    max_attempts integer,
    parent_id bigint,
    parent_state jsonb,
    suspended boolean DEFAULT false NOT NULL,
    traceparent text,
    tracestate text,
    claim_seq bigint DEFAULT 0 NOT NULL,
    kind text
);


ALTER TABLE arbiter.conversations_archive OWNER TO "wire-server";

--
-- Name: conversations_archive_id_seq; Type: SEQUENCE; Schema: arbiter; Owner: wire-server
--

CREATE SEQUENCE arbiter.conversations_archive_id_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;


ALTER SEQUENCE arbiter.conversations_archive_id_seq OWNER TO "wire-server";

--
-- Name: conversations_archive_id_seq; Type: SEQUENCE OWNED BY; Schema: arbiter; Owner: wire-server
--

ALTER SEQUENCE arbiter.conversations_archive_id_seq OWNED BY arbiter.conversations_archive.id;


--
-- Name: conversations_dlq; Type: TABLE; Schema: arbiter; Owner: wire-server
--

CREATE TABLE arbiter.conversations_dlq (
    id bigint NOT NULL,
    failed_at timestamp with time zone DEFAULT now() NOT NULL,
    job_id bigint NOT NULL,
    payload jsonb NOT NULL,
    group_key text,
    inserted_at timestamp with time zone DEFAULT now() NOT NULL,
    updated_at timestamp with time zone,
    last_attempted_at timestamp with time zone,
    not_visible_until timestamp with time zone,
    attempts integer DEFAULT 0 NOT NULL,
    last_error text,
    priority integer DEFAULT 0 NOT NULL,
    dedup_key text,
    dedup_strategy text,
    max_attempts integer,
    parent_id bigint,
    parent_state jsonb,
    suspended boolean DEFAULT false NOT NULL,
    claimed_by uuid,
    rate_limit_key text,
    rate_limit_prefix text,
    concurrency_key text,
    concurrency_prefix text,
    rate_limit_cost double precision DEFAULT 1 NOT NULL,
    archive_for integer,
    traceparent text,
    tracestate text,
    claim_seq bigint DEFAULT 0 NOT NULL,
    kind text
);


ALTER TABLE arbiter.conversations_dlq OWNER TO "wire-server";

--
-- Name: conversations_dlq_id_seq; Type: SEQUENCE; Schema: arbiter; Owner: wire-server
--

CREATE SEQUENCE arbiter.conversations_dlq_id_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;


ALTER SEQUENCE arbiter.conversations_dlq_id_seq OWNER TO "wire-server";

--
-- Name: conversations_dlq_id_seq; Type: SEQUENCE OWNED BY; Schema: arbiter; Owner: wire-server
--

ALTER SEQUENCE arbiter.conversations_dlq_id_seq OWNED BY arbiter.conversations_dlq.id;


--
-- Name: conversations_groups; Type: TABLE; Schema: arbiter; Owner: wire-server
--

CREATE TABLE arbiter.conversations_groups (
    group_key text NOT NULL,
    min_priority integer DEFAULT 0 NOT NULL,
    min_id bigint DEFAULT 0 NOT NULL,
    job_count integer DEFAULT 0 NOT NULL,
    in_flight_until timestamp with time zone,
    ready_count integer DEFAULT 0 NOT NULL,
    next_due timestamp with time zone
);


ALTER TABLE arbiter.conversations_groups OWNER TO "wire-server";

--
-- Name: conversations_id_seq; Type: SEQUENCE; Schema: arbiter; Owner: wire-server
--

CREATE SEQUENCE arbiter.conversations_id_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;


ALTER SEQUENCE arbiter.conversations_id_seq OWNER TO "wire-server";

--
-- Name: conversations_id_seq; Type: SEQUENCE OWNED BY; Schema: arbiter; Owner: wire-server
--

ALTER SEQUENCE arbiter.conversations_id_seq OWNED BY arbiter.conversations.id;


--
-- Name: conversations_results; Type: TABLE; Schema: arbiter; Owner: wire-server
--

CREATE TABLE arbiter.conversations_results (
    parent_id bigint NOT NULL,
    child_id bigint NOT NULL,
    result jsonb NOT NULL
);


ALTER TABLE arbiter.conversations_results OWNER TO "wire-server";

--
-- Name: cron_schedules; Type: TABLE; Schema: arbiter; Owner: wire-server
--

CREATE TABLE arbiter.cron_schedules (
    name text NOT NULL,
    default_expression text NOT NULL,
    default_overlap text NOT NULL,
    override_expression text,
    override_overlap text,
    enabled boolean DEFAULT true NOT NULL,
    last_fired_at timestamp with time zone,
    last_checked_at timestamp with time zone,
    created_at timestamp with time zone DEFAULT now() NOT NULL,
    updated_at timestamp with time zone DEFAULT now() NOT NULL,
    default_timezone text,
    override_timezone text,
    queue_name text DEFAULT 'pre-migration'::text NOT NULL,
    run_requested_at timestamp with time zone,
    last_manual_run_at timestamp with time zone,
    CONSTRAINT cron_schedules_default_overlap_check CHECK ((default_overlap = ANY (ARRAY['SkipOverlap'::text, 'AllowOverlap'::text]))),
    CONSTRAINT cron_schedules_override_overlap_check CHECK (((override_overlap IS NULL) OR (override_overlap = ANY (ARRAY['SkipOverlap'::text, 'AllowOverlap'::text]))))
);


ALTER TABLE arbiter.cron_schedules OWNER TO "wire-server";

--
-- Name: meetings; Type: TABLE; Schema: arbiter; Owner: wire-server
--

CREATE TABLE arbiter.meetings (
    id bigint NOT NULL,
    payload jsonb NOT NULL,
    group_key text,
    inserted_at timestamp with time zone DEFAULT now() NOT NULL,
    updated_at timestamp with time zone,
    last_attempted_at timestamp with time zone,
    not_visible_until timestamp with time zone,
    attempts integer DEFAULT 0 NOT NULL,
    last_error text,
    priority integer DEFAULT 0 NOT NULL,
    dedup_key text,
    dedup_strategy text,
    max_attempts integer DEFAULT 10,
    parent_id bigint,
    parent_state jsonb,
    suspended boolean DEFAULT false NOT NULL,
    claimed_by uuid,
    rate_limit_key text,
    rate_limit_prefix text,
    throttled_until timestamp with time zone,
    concurrency_key text,
    concurrency_prefix text,
    rate_limit_cost double precision DEFAULT 1 NOT NULL,
    cancel_requested_at timestamp with time zone,
    archive_for integer,
    traceparent text,
    tracestate text,
    claim_seq bigint DEFAULT 0 NOT NULL,
    kind text
)
WITH (fillfactor='100');


ALTER TABLE arbiter.meetings OWNER TO "wire-server";

--
-- Name: meetings_archive; Type: TABLE; Schema: arbiter; Owner: wire-server
--

CREATE TABLE arbiter.meetings_archive (
    id bigint NOT NULL,
    completed_at timestamp with time zone DEFAULT now() NOT NULL,
    archive_expires_at timestamp with time zone NOT NULL,
    job_id bigint NOT NULL,
    claimed_by uuid,
    archive_for integer,
    rate_limit_key text,
    rate_limit_prefix text,
    rate_limit_cost double precision,
    concurrency_key text,
    concurrency_prefix text,
    result jsonb,
    payload jsonb NOT NULL,
    group_key text,
    inserted_at timestamp with time zone DEFAULT now() NOT NULL,
    updated_at timestamp with time zone,
    last_attempted_at timestamp with time zone,
    not_visible_until timestamp with time zone,
    attempts integer DEFAULT 0 NOT NULL,
    last_error text,
    priority integer DEFAULT 0 NOT NULL,
    dedup_key text,
    dedup_strategy text,
    max_attempts integer,
    parent_id bigint,
    parent_state jsonb,
    suspended boolean DEFAULT false NOT NULL,
    traceparent text,
    tracestate text,
    claim_seq bigint DEFAULT 0 NOT NULL,
    kind text
);


ALTER TABLE arbiter.meetings_archive OWNER TO "wire-server";

--
-- Name: meetings_archive_id_seq; Type: SEQUENCE; Schema: arbiter; Owner: wire-server
--

CREATE SEQUENCE arbiter.meetings_archive_id_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;


ALTER SEQUENCE arbiter.meetings_archive_id_seq OWNER TO "wire-server";

--
-- Name: meetings_archive_id_seq; Type: SEQUENCE OWNED BY; Schema: arbiter; Owner: wire-server
--

ALTER SEQUENCE arbiter.meetings_archive_id_seq OWNED BY arbiter.meetings_archive.id;


--
-- Name: meetings_dlq; Type: TABLE; Schema: arbiter; Owner: wire-server
--

CREATE TABLE arbiter.meetings_dlq (
    id bigint NOT NULL,
    failed_at timestamp with time zone DEFAULT now() NOT NULL,
    job_id bigint NOT NULL,
    payload jsonb NOT NULL,
    group_key text,
    inserted_at timestamp with time zone DEFAULT now() NOT NULL,
    updated_at timestamp with time zone,
    last_attempted_at timestamp with time zone,
    not_visible_until timestamp with time zone,
    attempts integer DEFAULT 0 NOT NULL,
    last_error text,
    priority integer DEFAULT 0 NOT NULL,
    dedup_key text,
    dedup_strategy text,
    max_attempts integer,
    parent_id bigint,
    parent_state jsonb,
    suspended boolean DEFAULT false NOT NULL,
    claimed_by uuid,
    rate_limit_key text,
    rate_limit_prefix text,
    concurrency_key text,
    concurrency_prefix text,
    rate_limit_cost double precision DEFAULT 1 NOT NULL,
    archive_for integer,
    traceparent text,
    tracestate text,
    claim_seq bigint DEFAULT 0 NOT NULL,
    kind text
);


ALTER TABLE arbiter.meetings_dlq OWNER TO "wire-server";

--
-- Name: meetings_dlq_id_seq; Type: SEQUENCE; Schema: arbiter; Owner: wire-server
--

CREATE SEQUENCE arbiter.meetings_dlq_id_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;


ALTER SEQUENCE arbiter.meetings_dlq_id_seq OWNER TO "wire-server";

--
-- Name: meetings_dlq_id_seq; Type: SEQUENCE OWNED BY; Schema: arbiter; Owner: wire-server
--

ALTER SEQUENCE arbiter.meetings_dlq_id_seq OWNED BY arbiter.meetings_dlq.id;


--
-- Name: meetings_groups; Type: TABLE; Schema: arbiter; Owner: wire-server
--

CREATE TABLE arbiter.meetings_groups (
    group_key text NOT NULL,
    min_priority integer DEFAULT 0 NOT NULL,
    min_id bigint DEFAULT 0 NOT NULL,
    job_count integer DEFAULT 0 NOT NULL,
    in_flight_until timestamp with time zone,
    ready_count integer DEFAULT 0 NOT NULL,
    next_due timestamp with time zone
);


ALTER TABLE arbiter.meetings_groups OWNER TO "wire-server";

--
-- Name: meetings_id_seq; Type: SEQUENCE; Schema: arbiter; Owner: wire-server
--

CREATE SEQUENCE arbiter.meetings_id_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;


ALTER SEQUENCE arbiter.meetings_id_seq OWNER TO "wire-server";

--
-- Name: meetings_id_seq; Type: SEQUENCE OWNED BY; Schema: arbiter; Owner: wire-server
--

ALTER SEQUENCE arbiter.meetings_id_seq OWNED BY arbiter.meetings.id;


--
-- Name: meetings_results; Type: TABLE; Schema: arbiter; Owner: wire-server
--

CREATE TABLE arbiter.meetings_results (
    parent_id bigint NOT NULL,
    child_id bigint NOT NULL,
    result jsonb NOT NULL
);


ALTER TABLE arbiter.meetings_results OWNER TO "wire-server";

--
-- Name: schema_migrations; Type: TABLE; Schema: arbiter; Owner: wire-server
--

CREATE TABLE arbiter.schema_migrations (
    filename character varying(512) NOT NULL,
    checksum character varying(32) NOT NULL,
    executed_at timestamp without time zone DEFAULT now() NOT NULL
);


ALTER TABLE arbiter.schema_migrations OWNER TO "wire-server";

--
-- Name: apps; Type: TABLE; Schema: public; Owner: wire-server
--

CREATE TABLE public.apps (
    user_id uuid NOT NULL,
    team_id uuid NOT NULL,
    metadata json,
    category text DEFAULT 'other'::text NOT NULL,
    description text DEFAULT ''::text NOT NULL,
    creator uuid NOT NULL
);


ALTER TABLE public.apps OWNER TO "wire-server";

--
-- Name: asset; Type: TABLE; Schema: public; Owner: wire-server
--

CREATE TABLE public.asset (
    user_id uuid NOT NULL,
    typ integer NOT NULL,
    key text NOT NULL,
    size integer
);


ALTER TABLE public.asset OWNER TO "wire-server";

--
-- Name: bot_conv; Type: TABLE; Schema: public; Owner: wire-server
--

CREATE TABLE public.bot_conv (
    id uuid NOT NULL,
    conv uuid NOT NULL,
    conv_team uuid
);


ALTER TABLE public.bot_conv OWNER TO "wire-server";

--
-- Name: collaborators; Type: TABLE; Schema: public; Owner: wire-server
--

CREATE TABLE public.collaborators (
    user_id uuid NOT NULL,
    team_id uuid NOT NULL,
    permissions smallint[]
);


ALTER TABLE public.collaborators OWNER TO "wire-server";

--
-- Name: conversation; Type: TABLE; Schema: public; Owner: wire-server
--

CREATE TABLE public.conversation (
    id uuid NOT NULL,
    access integer[],
    access_roles_v2 integer[],
    cells_state integer,
    channel_add_permission integer,
    cipher_suite integer,
    creator uuid,
    epoch bigint,
    epoch_timestamp timestamp with time zone,
    group_conv_type integer,
    group_id bytea,
    message_timer bigint,
    name text,
    protocol integer,
    public_group_state bytea,
    receipt_mode integer,
    team uuid,
    type integer NOT NULL,
    parent_conv uuid,
    history_depth bigint
);


ALTER TABLE public.conversation OWNER TO "wire-server";

--
-- Name: conversation_codes; Type: TABLE; Schema: public; Owner: wire-server
--

CREATE TABLE public.conversation_codes (
    key text NOT NULL,
    conversation uuid NOT NULL,
    password bytea,
    value text NOT NULL,
    expires_at timestamp with time zone NOT NULL,
    target text DEFAULT 'conv'::text NOT NULL
);


ALTER TABLE public.conversation_codes OWNER TO "wire-server";

--
-- Name: conversation_member; Type: TABLE; Schema: public; Owner: wire-server
--

CREATE TABLE public.conversation_member (
    conv uuid NOT NULL,
    "user" uuid NOT NULL,
    conversation_role text,
    hidden boolean,
    hidden_ref text,
    otr_archived boolean,
    otr_archived_ref text,
    otr_muted boolean,
    otr_muted_ref text,
    otr_muted_status integer,
    provider uuid,
    service uuid
);


ALTER TABLE public.conversation_member OWNER TO "wire-server";

--
-- Name: conversation_migration_pending_deletes; Type: TABLE; Schema: public; Owner: wire-server
--

CREATE TABLE public.conversation_migration_pending_deletes (
    typ text NOT NULL,
    id uuid NOT NULL
);


ALTER TABLE public.conversation_migration_pending_deletes OWNER TO "wire-server";

--
-- Name: conversation_out_of_sync; Type: TABLE; Schema: public; Owner: wire-server
--

CREATE TABLE public.conversation_out_of_sync (
    conv_id uuid NOT NULL,
    out_of_sync boolean NOT NULL
);


ALTER TABLE public.conversation_out_of_sync OWNER TO "wire-server";

--
-- Name: deleted_user; Type: TABLE; Schema: public; Owner: wire-server
--

CREATE TABLE public.deleted_user (
    id uuid NOT NULL,
    team uuid,
    created_at timestamp with time zone NOT NULL,
    deleted_at timestamp with time zone DEFAULT CURRENT_TIMESTAMP NOT NULL
);


ALTER TABLE public.deleted_user OWNER TO "wire-server";

--
-- Name: domain_registration; Type: TABLE; Schema: public; Owner: wire-server
--

CREATE TABLE public.domain_registration (
    domain text NOT NULL,
    authorized_team uuid,
    domain_redirect integer,
    team_invite integer,
    idp_id uuid,
    backend_url bytea,
    team uuid,
    dns_verification_token text,
    ownership_token_hash bytea,
    webapp_url bytea
);


ALTER TABLE public.domain_registration OWNER TO "wire-server";

--
-- Name: domain_registration_challenge; Type: TABLE; Schema: public; Owner: wire-server
--

CREATE TABLE public.domain_registration_challenge (
    id uuid NOT NULL,
    domain text NOT NULL,
    challenge_token_hash bytea NOT NULL,
    dns_verification_token text NOT NULL,
    expires_at timestamp with time zone NOT NULL
);


ALTER TABLE public.domain_registration_challenge OWNER TO "wire-server";

--
-- Name: email_blocklist; Type: TABLE; Schema: public; Owner: wire-server
--

CREATE TABLE public.email_blocklist (
    email text NOT NULL
);


ALTER TABLE public.email_blocklist OWNER TO "wire-server";

--
-- Name: local_conversation_remote_member; Type: TABLE; Schema: public; Owner: wire-server
--

CREATE TABLE public.local_conversation_remote_member (
    conv uuid NOT NULL,
    user_remote_domain text NOT NULL,
    user_remote_id uuid NOT NULL,
    conversation_role text
);


ALTER TABLE public.local_conversation_remote_member OWNER TO "wire-server";

--
-- Name: meetings; Type: TABLE; Schema: public; Owner: wire-server
--

CREATE TABLE public.meetings (
    id uuid DEFAULT gen_random_uuid() NOT NULL,
    title text NOT NULL,
    creator uuid NOT NULL,
    start_time timestamp with time zone NOT NULL,
    end_time timestamp with time zone NOT NULL,
    recurrence_frequency public.recurrence_frequency,
    recurrence_interval integer,
    recurrence_until timestamp with time zone,
    conversation_id uuid NOT NULL,
    invited_emails text[] DEFAULT '{}'::text[] NOT NULL,
    trial boolean DEFAULT false NOT NULL,
    created_at timestamp with time zone DEFAULT now() NOT NULL,
    updated_at timestamp with time zone DEFAULT now() NOT NULL,
    tzid text NOT NULL,
    mtype public.meeting_type DEFAULT 'scheduled'::public.meeting_type NOT NULL,
    CONSTRAINT meetings_recurrence_consistency CHECK ((((recurrence_frequency IS NULL) AND (recurrence_interval IS NULL) AND (recurrence_until IS NULL)) OR ((recurrence_frequency IS NOT NULL) AND (recurrence_interval IS NOT NULL)))),
    CONSTRAINT meetings_title_length CHECK ((length(title) <= 256)),
    CONSTRAINT meetings_title_not_empty CHECK ((length(TRIM(BOTH FROM title)) > 0)),
    CONSTRAINT meetings_valid_time_range CHECK ((end_time > start_time))
);


ALTER TABLE public.meetings OWNER TO "wire-server";

--
-- Name: mls_group_member_client; Type: TABLE; Schema: public; Owner: wire-server
--

CREATE TABLE public.mls_group_member_client (
    group_id bytea NOT NULL,
    user_domain text NOT NULL,
    "user" uuid NOT NULL,
    client text NOT NULL,
    leaf_node_index integer NOT NULL,
    removal_pending boolean NOT NULL
);


ALTER TABLE public.mls_group_member_client OWNER TO "wire-server";

--
-- Name: mls_history_client; Type: TABLE; Schema: public; Owner: wire-server
--

CREATE TABLE public.mls_history_client (
    group_id bytea NOT NULL,
    id uuid NOT NULL,
    leaf_node_index integer NOT NULL,
    removal_pending boolean NOT NULL
);


ALTER TABLE public.mls_history_client OWNER TO "wire-server";

--
-- Name: password_reset; Type: TABLE; Schema: public; Owner: wire-server
--

CREATE TABLE public.password_reset (
    key text NOT NULL,
    code text NOT NULL,
    user_id uuid NOT NULL,
    retries integer,
    timeout timestamp with time zone,
    expires_at timestamp with time zone NOT NULL
);


ALTER TABLE public.password_reset OWNER TO "wire-server";

--
-- Name: remote_conversation_local_member; Type: TABLE; Schema: public; Owner: wire-server
--

CREATE TABLE public.remote_conversation_local_member (
    "user" uuid NOT NULL,
    conv_remote_domain text NOT NULL,
    conv_remote_id uuid NOT NULL,
    hidden boolean,
    hidden_ref text,
    otr_archived boolean,
    otr_archived_ref text,
    otr_muted_ref text,
    otr_muted_status integer
);


ALTER TABLE public.remote_conversation_local_member OWNER TO "wire-server";

--
-- Name: schema_migrations; Type: TABLE; Schema: public; Owner: wire-server
--

CREATE TABLE public.schema_migrations (
    filename character varying(512) NOT NULL,
    checksum character varying(32) NOT NULL,
    executed_at timestamp without time zone DEFAULT now() NOT NULL
);


ALTER TABLE public.schema_migrations OWNER TO "wire-server";

--
-- Name: subconversation; Type: TABLE; Schema: public; Owner: wire-server
--

CREATE TABLE public.subconversation (
    conv_id uuid NOT NULL,
    subconv_id text NOT NULL,
    cipher_suite integer,
    epoch bigint NOT NULL,
    epoch_timestamp timestamp with time zone NOT NULL,
    group_id bytea NOT NULL,
    public_group_state bytea
);


ALTER TABLE public.subconversation OWNER TO "wire-server";

--
-- Name: team_features; Type: TABLE; Schema: public; Owner: wire-server
--

CREATE TABLE public.team_features (
    team uuid NOT NULL,
    feature text NOT NULL,
    config jsonb,
    lock_status integer,
    status integer
);


ALTER TABLE public.team_features OWNER TO "wire-server";

--
-- Name: user_group; Type: TABLE; Schema: public; Owner: wire-server
--

CREATE TABLE public.user_group (
    team_id uuid NOT NULL,
    id uuid DEFAULT gen_random_uuid() NOT NULL,
    name text NOT NULL,
    managed_by integer NOT NULL,
    created_at timestamp with time zone DEFAULT now()
);


ALTER TABLE public.user_group OWNER TO "wire-server";

--
-- Name: user_group_channel; Type: TABLE; Schema: public; Owner: wire-server
--

CREATE TABLE public.user_group_channel (
    user_group_id uuid NOT NULL,
    conv_id uuid NOT NULL
);


ALTER TABLE public.user_group_channel OWNER TO "wire-server";

--
-- Name: user_group_member; Type: TABLE; Schema: public; Owner: wire-server
--

CREATE TABLE public.user_group_member (
    user_group_id uuid NOT NULL,
    user_id uuid NOT NULL
);


ALTER TABLE public.user_group_member OWNER TO "wire-server";

--
-- Name: user_migration_pending_deletes; Type: TABLE; Schema: public; Owner: wire-server
--

CREATE TABLE public.user_migration_pending_deletes (
    id uuid NOT NULL
);


ALTER TABLE public.user_migration_pending_deletes OWNER TO "wire-server";

--
-- Name: wire_user; Type: TABLE; Schema: public; Owner: wire-server
--

CREATE TABLE public.wire_user (
    id uuid NOT NULL,
    user_type integer NOT NULL,
    accent_id integer NOT NULL,
    activated boolean NOT NULL,
    country text,
    email text,
    email_unvalidated text,
    expires timestamp with time zone,
    feature_conference_calling integer,
    handle text,
    language text,
    managed_by integer,
    name text NOT NULL,
    password text,
    picture jsonb,
    provider uuid,
    service uuid,
    searchable boolean,
    sso_id jsonb,
    account_status integer,
    supported_protocols integer,
    team uuid,
    text_status text,
    rich_info jsonb,
    created_at timestamp with time zone DEFAULT CURRENT_TIMESTAMP NOT NULL,
    updated_at timestamp with time zone DEFAULT CURRENT_TIMESTAMP NOT NULL
);


ALTER TABLE public.wire_user OWNER TO "wire-server";

--
-- Name: conversations id; Type: DEFAULT; Schema: arbiter; Owner: wire-server
--

ALTER TABLE ONLY arbiter.conversations ALTER COLUMN id SET DEFAULT nextval('arbiter.conversations_id_seq'::regclass);


--
-- Name: conversations_archive id; Type: DEFAULT; Schema: arbiter; Owner: wire-server
--

ALTER TABLE ONLY arbiter.conversations_archive ALTER COLUMN id SET DEFAULT nextval('arbiter.conversations_archive_id_seq'::regclass);


--
-- Name: conversations_dlq id; Type: DEFAULT; Schema: arbiter; Owner: wire-server
--

ALTER TABLE ONLY arbiter.conversations_dlq ALTER COLUMN id SET DEFAULT nextval('arbiter.conversations_dlq_id_seq'::regclass);


--
-- Name: meetings id; Type: DEFAULT; Schema: arbiter; Owner: wire-server
--

ALTER TABLE ONLY arbiter.meetings ALTER COLUMN id SET DEFAULT nextval('arbiter.meetings_id_seq'::regclass);


--
-- Name: meetings_archive id; Type: DEFAULT; Schema: arbiter; Owner: wire-server
--

ALTER TABLE ONLY arbiter.meetings_archive ALTER COLUMN id SET DEFAULT nextval('arbiter.meetings_archive_id_seq'::regclass);


--
-- Name: meetings_dlq id; Type: DEFAULT; Schema: arbiter; Owner: wire-server
--

ALTER TABLE ONLY arbiter.meetings_dlq ALTER COLUMN id SET DEFAULT nextval('arbiter.meetings_dlq_id_seq'::regclass);


--
-- Name: arbiter_concurrency arbiter_concurrency_pkey; Type: CONSTRAINT; Schema: arbiter; Owner: wire-server
--

ALTER TABLE ONLY arbiter.arbiter_concurrency
    ADD CONSTRAINT arbiter_concurrency_pkey PRIMARY KEY (concurrency_key);


--
-- Name: arbiter_concurrency_policies arbiter_concurrency_policies_pkey; Type: CONSTRAINT; Schema: arbiter; Owner: wire-server
--

ALTER TABLE ONLY arbiter.arbiter_concurrency_policies
    ADD CONSTRAINT arbiter_concurrency_policies_pkey PRIMARY KEY (prefix_id);


--
-- Name: arbiter_gates arbiter_gates_pkey; Type: CONSTRAINT; Schema: arbiter; Owner: wire-server
--

ALTER TABLE ONLY arbiter.arbiter_gates
    ADD CONSTRAINT arbiter_gates_pkey PRIMARY KEY (task_name);


--
-- Name: arbiter_queues arbiter_queues_pkey; Type: CONSTRAINT; Schema: arbiter; Owner: wire-server
--

ALTER TABLE ONLY arbiter.arbiter_queues
    ADD CONSTRAINT arbiter_queues_pkey PRIMARY KEY (queue_name);


--
-- Name: arbiter_rate_limit_policies arbiter_rate_limit_policies_pkey; Type: CONSTRAINT; Schema: arbiter; Owner: wire-server
--

ALTER TABLE ONLY arbiter.arbiter_rate_limit_policies
    ADD CONSTRAINT arbiter_rate_limit_policies_pkey PRIMARY KEY (prefix_id);


--
-- Name: arbiter_rate_limits arbiter_rate_limits_pkey; Type: CONSTRAINT; Schema: arbiter; Owner: wire-server
--

ALTER TABLE ONLY arbiter.arbiter_rate_limits
    ADD CONSTRAINT arbiter_rate_limits_pkey PRIMARY KEY (rate_limit_key);


--
-- Name: arbiter_workers arbiter_workers_pkey; Type: CONSTRAINT; Schema: arbiter; Owner: wire-server
--

ALTER TABLE ONLY arbiter.arbiter_workers
    ADD CONSTRAINT arbiter_workers_pkey PRIMARY KEY (worker_id);


--
-- Name: conversations_archive conversations_archive_pkey; Type: CONSTRAINT; Schema: arbiter; Owner: wire-server
--

ALTER TABLE ONLY arbiter.conversations_archive
    ADD CONSTRAINT conversations_archive_pkey PRIMARY KEY (id);


--
-- Name: conversations_dlq conversations_dlq_pkey; Type: CONSTRAINT; Schema: arbiter; Owner: wire-server
--

ALTER TABLE ONLY arbiter.conversations_dlq
    ADD CONSTRAINT conversations_dlq_pkey PRIMARY KEY (id);


--
-- Name: conversations_groups conversations_groups_pkey; Type: CONSTRAINT; Schema: arbiter; Owner: wire-server
--

ALTER TABLE ONLY arbiter.conversations_groups
    ADD CONSTRAINT conversations_groups_pkey PRIMARY KEY (group_key);


--
-- Name: conversations conversations_pkey; Type: CONSTRAINT; Schema: arbiter; Owner: wire-server
--

ALTER TABLE ONLY arbiter.conversations
    ADD CONSTRAINT conversations_pkey PRIMARY KEY (id);


--
-- Name: conversations_results conversations_results_pkey; Type: CONSTRAINT; Schema: arbiter; Owner: wire-server
--

ALTER TABLE ONLY arbiter.conversations_results
    ADD CONSTRAINT conversations_results_pkey PRIMARY KEY (parent_id, child_id);


--
-- Name: cron_schedules cron_schedules_pkey; Type: CONSTRAINT; Schema: arbiter; Owner: wire-server
--

ALTER TABLE ONLY arbiter.cron_schedules
    ADD CONSTRAINT cron_schedules_pkey PRIMARY KEY (name);


--
-- Name: meetings_archive meetings_archive_pkey; Type: CONSTRAINT; Schema: arbiter; Owner: wire-server
--

ALTER TABLE ONLY arbiter.meetings_archive
    ADD CONSTRAINT meetings_archive_pkey PRIMARY KEY (id);


--
-- Name: meetings_dlq meetings_dlq_pkey; Type: CONSTRAINT; Schema: arbiter; Owner: wire-server
--

ALTER TABLE ONLY arbiter.meetings_dlq
    ADD CONSTRAINT meetings_dlq_pkey PRIMARY KEY (id);


--
-- Name: meetings_groups meetings_groups_pkey; Type: CONSTRAINT; Schema: arbiter; Owner: wire-server
--

ALTER TABLE ONLY arbiter.meetings_groups
    ADD CONSTRAINT meetings_groups_pkey PRIMARY KEY (group_key);


--
-- Name: meetings meetings_pkey; Type: CONSTRAINT; Schema: arbiter; Owner: wire-server
--

ALTER TABLE ONLY arbiter.meetings
    ADD CONSTRAINT meetings_pkey PRIMARY KEY (id);


--
-- Name: meetings_results meetings_results_pkey; Type: CONSTRAINT; Schema: arbiter; Owner: wire-server
--

ALTER TABLE ONLY arbiter.meetings_results
    ADD CONSTRAINT meetings_results_pkey PRIMARY KEY (parent_id, child_id);


--
-- Name: apps apps_pkey; Type: CONSTRAINT; Schema: public; Owner: wire-server
--

ALTER TABLE ONLY public.apps
    ADD CONSTRAINT apps_pkey PRIMARY KEY (user_id);


--
-- Name: bot_conv bot_conv_pkey; Type: CONSTRAINT; Schema: public; Owner: wire-server
--

ALTER TABLE ONLY public.bot_conv
    ADD CONSTRAINT bot_conv_pkey PRIMARY KEY (id);


--
-- Name: collaborators collaborators_pkey; Type: CONSTRAINT; Schema: public; Owner: wire-server
--

ALTER TABLE ONLY public.collaborators
    ADD CONSTRAINT collaborators_pkey PRIMARY KEY (user_id, team_id);


--
-- Name: conversation_codes conversation_codes_pkey; Type: CONSTRAINT; Schema: public; Owner: wire-server
--

ALTER TABLE ONLY public.conversation_codes
    ADD CONSTRAINT conversation_codes_pkey PRIMARY KEY (key);


--
-- Name: conversation_member conversation_member_pkey; Type: CONSTRAINT; Schema: public; Owner: wire-server
--

ALTER TABLE ONLY public.conversation_member
    ADD CONSTRAINT conversation_member_pkey PRIMARY KEY (conv, "user");


--
-- Name: conversation_migration_pending_deletes conversation_migration_pending_deletes_pkey; Type: CONSTRAINT; Schema: public; Owner: wire-server
--

ALTER TABLE ONLY public.conversation_migration_pending_deletes
    ADD CONSTRAINT conversation_migration_pending_deletes_pkey PRIMARY KEY (typ, id);


--
-- Name: conversation_out_of_sync conversation_out_of_sync_pkey; Type: CONSTRAINT; Schema: public; Owner: wire-server
--

ALTER TABLE ONLY public.conversation_out_of_sync
    ADD CONSTRAINT conversation_out_of_sync_pkey PRIMARY KEY (conv_id);


--
-- Name: conversation conversation_pkey; Type: CONSTRAINT; Schema: public; Owner: wire-server
--

ALTER TABLE ONLY public.conversation
    ADD CONSTRAINT conversation_pkey PRIMARY KEY (id);


--
-- Name: deleted_user deleted_user_pkey; Type: CONSTRAINT; Schema: public; Owner: wire-server
--

ALTER TABLE ONLY public.deleted_user
    ADD CONSTRAINT deleted_user_pkey PRIMARY KEY (id);


--
-- Name: domain_registration_challenge domain_registration_challenge_pkey; Type: CONSTRAINT; Schema: public; Owner: wire-server
--

ALTER TABLE ONLY public.domain_registration_challenge
    ADD CONSTRAINT domain_registration_challenge_pkey PRIMARY KEY (id);


--
-- Name: domain_registration domain_registration_pkey; Type: CONSTRAINT; Schema: public; Owner: wire-server
--

ALTER TABLE ONLY public.domain_registration
    ADD CONSTRAINT domain_registration_pkey PRIMARY KEY (domain);


--
-- Name: email_blocklist email_blocklist_pkey; Type: CONSTRAINT; Schema: public; Owner: wire-server
--

ALTER TABLE ONLY public.email_blocklist
    ADD CONSTRAINT email_blocklist_pkey PRIMARY KEY (email);


--
-- Name: local_conversation_remote_member local_conversation_remote_member_pkey; Type: CONSTRAINT; Schema: public; Owner: wire-server
--

ALTER TABLE ONLY public.local_conversation_remote_member
    ADD CONSTRAINT local_conversation_remote_member_pkey PRIMARY KEY (conv, user_remote_domain, user_remote_id);


--
-- Name: meetings meetings_pkey; Type: CONSTRAINT; Schema: public; Owner: wire-server
--

ALTER TABLE ONLY public.meetings
    ADD CONSTRAINT meetings_pkey PRIMARY KEY (id);


--
-- Name: mls_group_member_client mls_group_member_client_pkey; Type: CONSTRAINT; Schema: public; Owner: wire-server
--

ALTER TABLE ONLY public.mls_group_member_client
    ADD CONSTRAINT mls_group_member_client_pkey PRIMARY KEY (group_id, user_domain, "user", client);


--
-- Name: mls_history_client mls_history_client_pkey; Type: CONSTRAINT; Schema: public; Owner: wire-server
--

ALTER TABLE ONLY public.mls_history_client
    ADD CONSTRAINT mls_history_client_pkey PRIMARY KEY (group_id, id);


--
-- Name: password_reset password_reset_pkey; Type: CONSTRAINT; Schema: public; Owner: wire-server
--

ALTER TABLE ONLY public.password_reset
    ADD CONSTRAINT password_reset_pkey PRIMARY KEY (key);


--
-- Name: remote_conversation_local_member remote_conversation_local_member_pkey; Type: CONSTRAINT; Schema: public; Owner: wire-server
--

ALTER TABLE ONLY public.remote_conversation_local_member
    ADD CONSTRAINT remote_conversation_local_member_pkey PRIMARY KEY ("user", conv_remote_domain, conv_remote_id);


--
-- Name: subconversation subconversation_pkey; Type: CONSTRAINT; Schema: public; Owner: wire-server
--

ALTER TABLE ONLY public.subconversation
    ADD CONSTRAINT subconversation_pkey PRIMARY KEY (conv_id, subconv_id);


--
-- Name: team_features team_features_pkey; Type: CONSTRAINT; Schema: public; Owner: wire-server
--

ALTER TABLE ONLY public.team_features
    ADD CONSTRAINT team_features_pkey PRIMARY KEY (team, feature);


--
-- Name: user_group_channel user_group_channel_pkey; Type: CONSTRAINT; Schema: public; Owner: wire-server
--

ALTER TABLE ONLY public.user_group_channel
    ADD CONSTRAINT user_group_channel_pkey PRIMARY KEY (user_group_id, conv_id);


--
-- Name: user_group user_group_id_key; Type: CONSTRAINT; Schema: public; Owner: wire-server
--

ALTER TABLE ONLY public.user_group
    ADD CONSTRAINT user_group_id_key UNIQUE (id);


--
-- Name: user_group_member user_group_member_pkey; Type: CONSTRAINT; Schema: public; Owner: wire-server
--

ALTER TABLE ONLY public.user_group_member
    ADD CONSTRAINT user_group_member_pkey PRIMARY KEY (user_group_id, user_id);


--
-- Name: user_group user_group_pkey; Type: CONSTRAINT; Schema: public; Owner: wire-server
--

ALTER TABLE ONLY public.user_group
    ADD CONSTRAINT user_group_pkey PRIMARY KEY (team_id, id);


--
-- Name: user_migration_pending_deletes user_migration_pending_deletes_pkey; Type: CONSTRAINT; Schema: public; Owner: wire-server
--

ALTER TABLE ONLY public.user_migration_pending_deletes
    ADD CONSTRAINT user_migration_pending_deletes_pkey PRIMARY KEY (id);


--
-- Name: wire_user wire_user_handle_key; Type: CONSTRAINT; Schema: public; Owner: wire-server
--

ALTER TABLE ONLY public.wire_user
    ADD CONSTRAINT wire_user_handle_key UNIQUE (handle);


--
-- Name: wire_user wire_user_pkey; Type: CONSTRAINT; Schema: public; Owner: wire-server
--

ALTER TABLE ONLY public.wire_user
    ADD CONSTRAINT wire_user_pkey PRIMARY KEY (id);


--
-- Name: conversations_adminless_team_id_idx; Type: INDEX; Schema: arbiter; Owner: wire-server
--

CREATE INDEX conversations_adminless_team_id_idx ON arbiter.conversations USING btree (((payload #>> '{data,team_id}'::text[]))) WHERE ((claimed_by IS NULL) AND ((payload ->> 'type'::text) = ANY (ARRAY['adminless_setup'::text, 'adminless_deletion'::text, 'adminless_reminder'::text])));


--
-- Name: idx_conversations_archive_completed_at; Type: INDEX; Schema: arbiter; Owner: wire-server
--

CREATE INDEX idx_conversations_archive_completed_at ON arbiter.conversations_archive USING btree (completed_at DESC);


--
-- Name: idx_conversations_archive_expires_at; Type: INDEX; Schema: arbiter; Owner: wire-server
--

CREATE INDEX idx_conversations_archive_expires_at ON arbiter.conversations_archive USING btree (archive_expires_at);


--
-- Name: idx_conversations_archive_group_key; Type: INDEX; Schema: arbiter; Owner: wire-server
--

CREATE INDEX idx_conversations_archive_group_key ON arbiter.conversations_archive USING btree (group_key);


--
-- Name: idx_conversations_archive_job_id; Type: INDEX; Schema: arbiter; Owner: wire-server
--

CREATE INDEX idx_conversations_archive_job_id ON arbiter.conversations_archive USING btree (job_id);


--
-- Name: idx_conversations_archive_parent_id; Type: INDEX; Schema: arbiter; Owner: wire-server
--

CREATE INDEX idx_conversations_archive_parent_id ON arbiter.conversations_archive USING btree (parent_id) WHERE (parent_id IS NOT NULL);


--
-- Name: idx_conversations_cancel_requested; Type: INDEX; Schema: arbiter; Owner: wire-server
--

CREATE INDEX idx_conversations_cancel_requested ON arbiter.conversations USING btree (id) WHERE (cancel_requested_at IS NOT NULL);


--
-- Name: idx_conversations_concurrency; Type: INDEX; Schema: arbiter; Owner: wire-server
--

CREATE INDEX idx_conversations_concurrency ON arbiter.conversations USING btree (concurrency_key) WHERE (concurrency_key IS NOT NULL);


--
-- Name: idx_conversations_dedup_key; Type: INDEX; Schema: arbiter; Owner: wire-server
--

CREATE UNIQUE INDEX idx_conversations_dedup_key ON arbiter.conversations USING btree (dedup_key) WHERE (dedup_key IS NOT NULL);


--
-- Name: idx_conversations_dlq_failed_at; Type: INDEX; Schema: arbiter; Owner: wire-server
--

CREATE INDEX idx_conversations_dlq_failed_at ON arbiter.conversations_dlq USING btree (failed_at DESC);


--
-- Name: idx_conversations_dlq_group_key; Type: INDEX; Schema: arbiter; Owner: wire-server
--

CREATE INDEX idx_conversations_dlq_group_key ON arbiter.conversations_dlq USING btree (group_key);


--
-- Name: idx_conversations_dlq_parent_id; Type: INDEX; Schema: arbiter; Owner: wire-server
--

CREATE INDEX idx_conversations_dlq_parent_id ON arbiter.conversations_dlq USING btree (parent_id) WHERE (parent_id IS NOT NULL);


--
-- Name: idx_conversations_group_in_flight; Type: INDEX; Schema: arbiter; Owner: wire-server
--

CREATE INDEX idx_conversations_group_in_flight ON arbiter.conversations USING btree (group_key, not_visible_until DESC NULLS LAST) WHERE ((group_key IS NOT NULL) AND (not_visible_until IS NOT NULL) AND (NOT suspended) AND ((attempts > 0) OR (throttled_until IS NOT NULL)));


--
-- Name: idx_conversations_group_key; Type: INDEX; Schema: arbiter; Owner: wire-server
--

CREATE INDEX idx_conversations_group_key ON arbiter.conversations USING btree (group_key, priority, id) WHERE (group_key IS NOT NULL);


--
-- Name: idx_conversations_group_retried; Type: INDEX; Schema: arbiter; Owner: wire-server
--

CREATE INDEX idx_conversations_group_retried ON arbiter.conversations USING btree (group_key, attempts DESC, priority, id) WHERE ((group_key IS NOT NULL) AND (attempts > 0));


--
-- Name: idx_conversations_grouped_due; Type: INDEX; Schema: arbiter; Owner: wire-server
--

CREATE INDEX idx_conversations_grouped_due ON arbiter.conversations USING btree (group_key, not_visible_until) WHERE ((group_key IS NOT NULL) AND (not_visible_until IS NOT NULL) AND (NOT suspended));


--
-- Name: idx_conversations_groups_emptied; Type: INDEX; Schema: arbiter; Owner: wire-server
--

CREATE INDEX idx_conversations_groups_emptied ON arbiter.conversations_groups USING btree (group_key) WHERE (job_count = 0);


--
-- Name: idx_conversations_groups_next_due; Type: INDEX; Schema: arbiter; Owner: wire-server
--

CREATE INDEX idx_conversations_groups_next_due ON arbiter.conversations_groups USING btree (next_due) WHERE (next_due IS NOT NULL);


--
-- Name: idx_conversations_groups_ranking; Type: INDEX; Schema: arbiter; Owner: wire-server
--

CREATE INDEX idx_conversations_groups_ranking ON arbiter.conversations_groups USING btree (min_priority, min_id) WHERE ((ready_count > 0) AND (in_flight_until IS NULL));


--
-- Name: idx_conversations_parent_id; Type: INDEX; Schema: arbiter; Owner: wire-server
--

CREATE INDEX idx_conversations_parent_id ON arbiter.conversations USING btree (parent_id) WHERE (parent_id IS NOT NULL);


--
-- Name: idx_conversations_throttled; Type: INDEX; Schema: arbiter; Owner: wire-server
--

CREATE INDEX idx_conversations_throttled ON arbiter.conversations USING btree (rate_limit_prefix, rate_limit_key) WHERE (throttled_until IS NOT NULL);


--
-- Name: idx_conversations_ungrouped_due; Type: INDEX; Schema: arbiter; Owner: wire-server
--

CREATE INDEX idx_conversations_ungrouped_due ON arbiter.conversations USING btree (not_visible_until) WHERE ((group_key IS NULL) AND (not_visible_until IS NOT NULL) AND (NOT suspended));


--
-- Name: idx_conversations_ungrouped_ready_ranking; Type: INDEX; Schema: arbiter; Owner: wire-server
--

CREATE INDEX idx_conversations_ungrouped_ready_ranking ON arbiter.conversations USING btree (priority, id) WHERE ((group_key IS NULL) AND (not_visible_until IS NULL) AND (NOT suspended));


--
-- Name: idx_meetings_archive_completed_at; Type: INDEX; Schema: arbiter; Owner: wire-server
--

CREATE INDEX idx_meetings_archive_completed_at ON arbiter.meetings_archive USING btree (completed_at DESC);


--
-- Name: idx_meetings_archive_expires_at; Type: INDEX; Schema: arbiter; Owner: wire-server
--

CREATE INDEX idx_meetings_archive_expires_at ON arbiter.meetings_archive USING btree (archive_expires_at);


--
-- Name: idx_meetings_archive_group_key; Type: INDEX; Schema: arbiter; Owner: wire-server
--

CREATE INDEX idx_meetings_archive_group_key ON arbiter.meetings_archive USING btree (group_key);


--
-- Name: idx_meetings_archive_job_id; Type: INDEX; Schema: arbiter; Owner: wire-server
--

CREATE INDEX idx_meetings_archive_job_id ON arbiter.meetings_archive USING btree (job_id);


--
-- Name: idx_meetings_archive_parent_id; Type: INDEX; Schema: arbiter; Owner: wire-server
--

CREATE INDEX idx_meetings_archive_parent_id ON arbiter.meetings_archive USING btree (parent_id) WHERE (parent_id IS NOT NULL);


--
-- Name: idx_meetings_cancel_requested; Type: INDEX; Schema: arbiter; Owner: wire-server
--

CREATE INDEX idx_meetings_cancel_requested ON arbiter.meetings USING btree (id) WHERE (cancel_requested_at IS NOT NULL);


--
-- Name: idx_meetings_concurrency; Type: INDEX; Schema: arbiter; Owner: wire-server
--

CREATE INDEX idx_meetings_concurrency ON arbiter.meetings USING btree (concurrency_key) WHERE (concurrency_key IS NOT NULL);


--
-- Name: idx_meetings_dedup_key; Type: INDEX; Schema: arbiter; Owner: wire-server
--

CREATE UNIQUE INDEX idx_meetings_dedup_key ON arbiter.meetings USING btree (dedup_key) WHERE (dedup_key IS NOT NULL);


--
-- Name: idx_meetings_dlq_failed_at; Type: INDEX; Schema: arbiter; Owner: wire-server
--

CREATE INDEX idx_meetings_dlq_failed_at ON arbiter.meetings_dlq USING btree (failed_at DESC);


--
-- Name: idx_meetings_dlq_group_key; Type: INDEX; Schema: arbiter; Owner: wire-server
--

CREATE INDEX idx_meetings_dlq_group_key ON arbiter.meetings_dlq USING btree (group_key);


--
-- Name: idx_meetings_dlq_parent_id; Type: INDEX; Schema: arbiter; Owner: wire-server
--

CREATE INDEX idx_meetings_dlq_parent_id ON arbiter.meetings_dlq USING btree (parent_id) WHERE (parent_id IS NOT NULL);


--
-- Name: idx_meetings_group_in_flight; Type: INDEX; Schema: arbiter; Owner: wire-server
--

CREATE INDEX idx_meetings_group_in_flight ON arbiter.meetings USING btree (group_key, not_visible_until DESC NULLS LAST) WHERE ((group_key IS NOT NULL) AND (not_visible_until IS NOT NULL) AND (NOT suspended) AND ((attempts > 0) OR (throttled_until IS NOT NULL)));


--
-- Name: idx_meetings_group_key; Type: INDEX; Schema: arbiter; Owner: wire-server
--

CREATE INDEX idx_meetings_group_key ON arbiter.meetings USING btree (group_key, priority, id) WHERE (group_key IS NOT NULL);


--
-- Name: idx_meetings_group_retried; Type: INDEX; Schema: arbiter; Owner: wire-server
--

CREATE INDEX idx_meetings_group_retried ON arbiter.meetings USING btree (group_key, attempts DESC, priority, id) WHERE ((group_key IS NOT NULL) AND (attempts > 0));


--
-- Name: idx_meetings_grouped_due; Type: INDEX; Schema: arbiter; Owner: wire-server
--

CREATE INDEX idx_meetings_grouped_due ON arbiter.meetings USING btree (group_key, not_visible_until) WHERE ((group_key IS NOT NULL) AND (not_visible_until IS NOT NULL) AND (NOT suspended));


--
-- Name: idx_meetings_groups_emptied; Type: INDEX; Schema: arbiter; Owner: wire-server
--

CREATE INDEX idx_meetings_groups_emptied ON arbiter.meetings_groups USING btree (group_key) WHERE (job_count = 0);


--
-- Name: idx_meetings_groups_next_due; Type: INDEX; Schema: arbiter; Owner: wire-server
--

CREATE INDEX idx_meetings_groups_next_due ON arbiter.meetings_groups USING btree (next_due) WHERE (next_due IS NOT NULL);


--
-- Name: idx_meetings_groups_ranking; Type: INDEX; Schema: arbiter; Owner: wire-server
--

CREATE INDEX idx_meetings_groups_ranking ON arbiter.meetings_groups USING btree (min_priority, min_id) WHERE ((ready_count > 0) AND (in_flight_until IS NULL));


--
-- Name: idx_meetings_parent_id; Type: INDEX; Schema: arbiter; Owner: wire-server
--

CREATE INDEX idx_meetings_parent_id ON arbiter.meetings USING btree (parent_id) WHERE (parent_id IS NOT NULL);


--
-- Name: idx_meetings_throttled; Type: INDEX; Schema: arbiter; Owner: wire-server
--

CREATE INDEX idx_meetings_throttled ON arbiter.meetings USING btree (rate_limit_prefix, rate_limit_key) WHERE (throttled_until IS NOT NULL);


--
-- Name: idx_meetings_ungrouped_due; Type: INDEX; Schema: arbiter; Owner: wire-server
--

CREATE INDEX idx_meetings_ungrouped_due ON arbiter.meetings USING btree (not_visible_until) WHERE ((group_key IS NULL) AND (not_visible_until IS NOT NULL) AND (NOT suspended));


--
-- Name: idx_meetings_ungrouped_ready_ranking; Type: INDEX; Schema: arbiter; Owner: wire-server
--

CREATE INDEX idx_meetings_ungrouped_ready_ranking ON arbiter.meetings USING btree (priority, id) WHERE ((group_key IS NULL) AND (not_visible_until IS NULL) AND (NOT suspended));


--
-- Name: asset_user_id_idx; Type: INDEX; Schema: public; Owner: wire-server
--

CREATE INDEX asset_user_id_idx ON public.asset USING btree (user_id);


--
-- Name: bot_conv_conv_idx; Type: INDEX; Schema: public; Owner: wire-server
--

CREATE INDEX bot_conv_conv_idx ON public.bot_conv USING btree (conv);


--
-- Name: bot_conv_team_idx; Type: INDEX; Schema: public; Owner: wire-server
--

CREATE INDEX bot_conv_team_idx ON public.bot_conv USING btree (conv_team);


--
-- Name: collaborators_team_id_idx; Type: INDEX; Schema: public; Owner: wire-server
--

CREATE INDEX collaborators_team_id_idx ON public.collaborators USING btree (team_id);


--
-- Name: collaborators_user_id_idx; Type: INDEX; Schema: public; Owner: wire-server
--

CREATE INDEX collaborators_user_id_idx ON public.collaborators USING btree (user_id);


--
-- Name: conversation_codes_expires_at_idx; Type: INDEX; Schema: public; Owner: wire-server
--

CREATE INDEX conversation_codes_expires_at_idx ON public.conversation_codes USING btree (expires_at);


--
-- Name: conversation_codes_key_expires_at_idx; Type: INDEX; Schema: public; Owner: wire-server
--

CREATE INDEX conversation_codes_key_expires_at_idx ON public.conversation_codes USING btree (key, expires_at);


--
-- Name: conversation_member_user_idx; Type: INDEX; Schema: public; Owner: wire-server
--

CREATE INDEX conversation_member_user_idx ON public.conversation_member USING btree ("user");


--
-- Name: conversation_parent_conv_idx; Type: INDEX; Schema: public; Owner: wire-server
--

CREATE INDEX conversation_parent_conv_idx ON public.conversation USING btree (parent_conv);


--
-- Name: conversation_team_group_type_lower_name_id_idx; Type: INDEX; Schema: public; Owner: wire-server
--

CREATE INDEX conversation_team_group_type_lower_name_id_idx ON public.conversation USING btree (team, group_conv_type, lower(name), id);


--
-- Name: conversation_team_idx; Type: INDEX; Schema: public; Owner: wire-server
--

CREATE INDEX conversation_team_idx ON public.conversation USING btree (team);


--
-- Name: domain_registration_authorized_team_idx; Type: INDEX; Schema: public; Owner: wire-server
--

CREATE INDEX domain_registration_authorized_team_idx ON public.domain_registration USING btree (authorized_team);


--
-- Name: domain_registration_challenge_expires_at_idx; Type: INDEX; Schema: public; Owner: wire-server
--

CREATE INDEX domain_registration_challenge_expires_at_idx ON public.domain_registration_challenge USING btree (expires_at);


--
-- Name: idx_meetings_conversation; Type: INDEX; Schema: public; Owner: wire-server
--

CREATE INDEX idx_meetings_conversation ON public.meetings USING btree (conversation_id);


--
-- Name: idx_meetings_creator; Type: INDEX; Schema: public; Owner: wire-server
--

CREATE INDEX idx_meetings_creator ON public.meetings USING btree (creator);


--
-- Name: idx_meetings_end_time; Type: INDEX; Schema: public; Owner: wire-server
--

CREATE INDEX idx_meetings_end_time ON public.meetings USING btree (end_time);


--
-- Name: idx_meetings_end_time_nonrecurring; Type: INDEX; Schema: public; Owner: wire-server
--

CREATE INDEX idx_meetings_end_time_nonrecurring ON public.meetings USING btree (end_time) WHERE (recurrence_frequency IS NULL);


--
-- Name: idx_meetings_recurrence_eff_end; Type: INDEX; Schema: public; Owner: wire-server
--

CREATE INDEX idx_meetings_recurrence_eff_end ON public.meetings USING btree (GREATEST(end_time, recurrence_until)) WHERE ((recurrence_frequency IS NOT NULL) AND (recurrence_interval IS NOT NULL) AND (recurrence_until IS NOT NULL));


--
-- Name: idx_meetings_start_time; Type: INDEX; Schema: public; Owner: wire-server
--

CREATE INDEX idx_meetings_start_time ON public.meetings USING btree (start_time);


--
-- Name: user_group_member_user_id_idx; Type: INDEX; Schema: public; Owner: wire-server
--

CREATE INDEX user_group_member_user_id_idx ON public.user_group_member USING btree (user_id);


--
-- Name: wire_user_pending_scim_users_idx; Type: INDEX; Schema: public; Owner: wire-server
--

CREATE INDEX wire_user_pending_scim_users_idx ON public.wire_user USING btree (team) INCLUDE (id, email) WHERE ((managed_by = 1) AND (account_status = 4) AND (activated = true) AND (email IS NOT NULL));


--
-- Name: wire_user_scim_users_idx; Type: INDEX; Schema: public; Owner: wire-server
--

CREATE INDEX wire_user_scim_users_idx ON public.wire_user USING btree (team, id) WHERE (managed_by = 1);


--
-- Name: wire_user_service_idx; Type: INDEX; Schema: public; Owner: wire-server
--

CREATE INDEX wire_user_service_idx ON public.wire_user USING btree (provider, service);


--
-- Name: conversations conversations_notify_trigger; Type: TRIGGER; Schema: arbiter; Owner: wire-server
--

CREATE TRIGGER conversations_notify_trigger AFTER INSERT ON arbiter.conversations REFERENCING NEW TABLE AS new_table FOR EACH STATEMENT EXECUTE FUNCTION arbiter.notify_conversations_created();


--
-- Name: TRIGGER conversations_notify_trigger ON conversations; Type: COMMENT; Schema: arbiter; Owner: wire-server
--

COMMENT ON TRIGGER conversations_notify_trigger ON arbiter.conversations IS 'arbiter:notify:v1';


--
-- Name: conversations maintain_conversations_groups_delete; Type: TRIGGER; Schema: arbiter; Owner: wire-server
--

CREATE TRIGGER maintain_conversations_groups_delete AFTER DELETE ON arbiter.conversations REFERENCING OLD TABLE AS old_table FOR EACH STATEMENT EXECUTE FUNCTION arbiter.maintain_conversations_groups_delete();


--
-- Name: conversations maintain_conversations_groups_insert; Type: TRIGGER; Schema: arbiter; Owner: wire-server
--

CREATE TRIGGER maintain_conversations_groups_insert AFTER INSERT ON arbiter.conversations REFERENCING NEW TABLE AS new_table FOR EACH STATEMENT EXECUTE FUNCTION arbiter.maintain_conversations_groups_insert();


--
-- Name: conversations maintain_conversations_groups_update; Type: TRIGGER; Schema: arbiter; Owner: wire-server
--

CREATE TRIGGER maintain_conversations_groups_update AFTER UPDATE ON arbiter.conversations REFERENCING OLD TABLE AS old_table NEW TABLE AS new_table FOR EACH STATEMENT EXECUTE FUNCTION arbiter.maintain_conversations_groups_update();


--
-- Name: meetings maintain_meetings_groups_delete; Type: TRIGGER; Schema: arbiter; Owner: wire-server
--

CREATE TRIGGER maintain_meetings_groups_delete AFTER DELETE ON arbiter.meetings REFERENCING OLD TABLE AS old_table FOR EACH STATEMENT EXECUTE FUNCTION arbiter.maintain_meetings_groups_delete();


--
-- Name: meetings maintain_meetings_groups_insert; Type: TRIGGER; Schema: arbiter; Owner: wire-server
--

CREATE TRIGGER maintain_meetings_groups_insert AFTER INSERT ON arbiter.meetings REFERENCING NEW TABLE AS new_table FOR EACH STATEMENT EXECUTE FUNCTION arbiter.maintain_meetings_groups_insert();


--
-- Name: meetings maintain_meetings_groups_update; Type: TRIGGER; Schema: arbiter; Owner: wire-server
--

CREATE TRIGGER maintain_meetings_groups_update AFTER UPDATE ON arbiter.meetings REFERENCING OLD TABLE AS old_table NEW TABLE AS new_table FOR EACH STATEMENT EXECUTE FUNCTION arbiter.maintain_meetings_groups_update();


--
-- Name: meetings meetings_notify_trigger; Type: TRIGGER; Schema: arbiter; Owner: wire-server
--

CREATE TRIGGER meetings_notify_trigger AFTER INSERT ON arbiter.meetings REFERENCING NEW TABLE AS new_table FOR EACH STATEMENT EXECUTE FUNCTION arbiter.notify_meetings_created();


--
-- Name: TRIGGER meetings_notify_trigger ON meetings; Type: COMMENT; Schema: arbiter; Owner: wire-server
--

COMMENT ON TRIGGER meetings_notify_trigger ON arbiter.meetings IS 'arbiter:notify:v1';


--
-- Name: wire_user update_user_updated_at; Type: TRIGGER; Schema: public; Owner: wire-server
--

CREATE TRIGGER update_user_updated_at BEFORE UPDATE ON public.wire_user FOR EACH ROW EXECUTE FUNCTION public.update_updated_at();


--
-- Name: conversations_results conversations_results_parent_id_fkey; Type: FK CONSTRAINT; Schema: arbiter; Owner: wire-server
--

ALTER TABLE ONLY arbiter.conversations_results
    ADD CONSTRAINT conversations_results_parent_id_fkey FOREIGN KEY (parent_id) REFERENCES arbiter.conversations(id) ON DELETE CASCADE;


--
-- Name: meetings_results meetings_results_parent_id_fkey; Type: FK CONSTRAINT; Schema: arbiter; Owner: wire-server
--

ALTER TABLE ONLY arbiter.meetings_results
    ADD CONSTRAINT meetings_results_parent_id_fkey FOREIGN KEY (parent_id) REFERENCES arbiter.meetings(id) ON DELETE CASCADE;


--
-- Name: bot_conv bot_conv_id_fkey; Type: FK CONSTRAINT; Schema: public; Owner: wire-server
--

ALTER TABLE ONLY public.bot_conv
    ADD CONSTRAINT bot_conv_id_fkey FOREIGN KEY (id) REFERENCES public.wire_user(id) ON DELETE CASCADE;


--
-- Name: conversation_member conversation_member_conv_fkey; Type: FK CONSTRAINT; Schema: public; Owner: wire-server
--

ALTER TABLE ONLY public.conversation_member
    ADD CONSTRAINT conversation_member_conv_fkey FOREIGN KEY (conv) REFERENCES public.conversation(id) ON DELETE CASCADE;


--
-- Name: conversation_out_of_sync conversation_out_of_sync_conv_id_fkey; Type: FK CONSTRAINT; Schema: public; Owner: wire-server
--

ALTER TABLE ONLY public.conversation_out_of_sync
    ADD CONSTRAINT conversation_out_of_sync_conv_id_fkey FOREIGN KEY (conv_id) REFERENCES public.conversation(id) ON DELETE CASCADE;


--
-- Name: conversation conversation_parent_conv_fkey; Type: FK CONSTRAINT; Schema: public; Owner: wire-server
--

ALTER TABLE ONLY public.conversation
    ADD CONSTRAINT conversation_parent_conv_fkey FOREIGN KEY (parent_conv) REFERENCES public.conversation(id) ON DELETE CASCADE;


--
-- Name: user_group_member fk_user_group; Type: FK CONSTRAINT; Schema: public; Owner: wire-server
--

ALTER TABLE ONLY public.user_group_member
    ADD CONSTRAINT fk_user_group FOREIGN KEY (user_group_id) REFERENCES public.user_group(id) ON DELETE CASCADE;


--
-- Name: user_group_channel fk_user_group_channel; Type: FK CONSTRAINT; Schema: public; Owner: wire-server
--

ALTER TABLE ONLY public.user_group_channel
    ADD CONSTRAINT fk_user_group_channel FOREIGN KEY (user_group_id) REFERENCES public.user_group(id) ON DELETE CASCADE;


--
-- Name: local_conversation_remote_member local_conversation_remote_member_conv_fkey; Type: FK CONSTRAINT; Schema: public; Owner: wire-server
--

ALTER TABLE ONLY public.local_conversation_remote_member
    ADD CONSTRAINT local_conversation_remote_member_conv_fkey FOREIGN KEY (conv) REFERENCES public.conversation(id) ON DELETE CASCADE;


--
-- Name: subconversation subconversation_conv_id_fkey; Type: FK CONSTRAINT; Schema: public; Owner: wire-server
--

ALTER TABLE ONLY public.subconversation
    ADD CONSTRAINT subconversation_conv_id_fkey FOREIGN KEY (conv_id) REFERENCES public.conversation(id) ON DELETE CASCADE;


--
-- Name: SCHEMA public; Type: ACL; Schema: -; Owner: wire-server
--

REVOKE USAGE ON SCHEMA public FROM PUBLIC;


--
-- PostgreSQL database dump complete
--

\unrestrict 79bbfb4630959c48307653a5cd3d83f2582b3c2210f75f10d79e3ebf0015620