sequent 8.1.1 → 8.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2c1c844dd60b40d09f71df31af4ed2082af51665e5a652128dd1ba7e53473535
-  data.tar.gz: 1597ad4e428b852a0f720bfcb05c79a5734e72e81a2302feacc870adeb4eb738
+  metadata.gz: eac2900ab837f6b6f12aa09f4cc2bf0f40bfc4ed06292ff501141cba82739e14
+  data.tar.gz: 719335f0d2640357255509a690de4bfe14f423d538aa4c402e0513f14305dfcf
 SHA512:
-  metadata.gz: 44929e619dc88180add807b71794d8520b6f0f33af7a379cad7a3bc2b73ecd2a83ce028df51bf89d6278a615011d0a100f8fe48ac1d44ef23b4d859af24621f1
-  data.tar.gz: 0b983b286c48a2037f31c13cb229769fe2216a4d011fe711a249f5502260f47612eee3b744943abf50a413135b4bd5532f55b1d3c0221d4ebf2df188d16a5f61
+  metadata.gz: 66929197b669aa7aa466eea3cacc6ee3eb0514a6cb2bb80f4b240e68d7877cded40e5e4d2b47ed3f92a83c14426d989a4b74290e154bbdcc621ade9c787192fc
+  data.tar.gz: d0b950e021daded940fd6c519a4824d656787ad32eede7f09cb900fbd4d18c1bf31aaef6bd63df7d581a51bdf093e13b942f33e2c99714167f74e4bafc136c7a

data/db/migrate/20250101000000_sequent_initial_schema.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+class SequentInitialSchema < ActiveRecord::Migration[7.2]
+  def up
+    create_schema Sequent.configuration.event_store_schema_name, if_not_exists: true
+    create_schema Sequent.configuration.view_schema_name, if_not_exists: true
+
+    Sequent::Support::Database.with_search_path(Sequent.configuration.event_store_schema_name) do
+      say 'Creating Sequent tables', true
+      suppress_messages do
+        execute <<~SQL
+          CREATE TABLE command_types (id SMALLINT PRIMARY KEY GENERATED BY DEFAULT AS IDENTITY, type text UNIQUE NOT NULL);
+          CREATE TABLE aggregate_types (id SMALLINT PRIMARY KEY GENERATED BY DEFAULT AS IDENTITY, type text UNIQUE NOT NULL);
+          CREATE TABLE event_types (id SMALLINT PRIMARY KEY GENERATED BY DEFAULT AS IDENTITY, type text UNIQUE NOT NULL);
+
+          CREATE TABLE commands (
+              id bigint PRIMARY KEY GENERATED BY DEFAULT AS IDENTITY,
+              created_at timestamp with time zone NOT NULL,
+              user_id uuid,
+              aggregate_id uuid,
+              command_type_id SMALLINT NOT NULL,
+              command_json jsonb NOT NULL,
+              event_aggregate_id uuid,
+              event_sequence_number integer,
+              FOREIGN KEY (command_type_id) REFERENCES command_types (id) ON UPDATE CASCADE
+          ) PARTITION BY RANGE (id);
+
+          CREATE TABLE aggregates (
+              aggregate_id uuid NOT NULL PRIMARY KEY,
+              events_partition_key text NOT NULL DEFAULT '',
+              aggregate_type_id SMALLINT NOT NULL,
+              created_at timestamp with time zone NOT NULL DEFAULT NOW(),
+              UNIQUE (events_partition_key, aggregate_id),
+              FOREIGN KEY (aggregate_type_id) REFERENCES aggregate_types (id) ON UPDATE CASCADE
+          ) PARTITION BY RANGE (aggregate_id);
+
+          CREATE TABLE aggregate_unique_keys (
+              aggregate_id uuid NOT NULL,
+              scope text NOT NULL,
+              key jsonb NOT NULL,
+              PRIMARY KEY (aggregate_id, scope),
+              UNIQUE (scope, key),
+              FOREIGN KEY (aggregate_id) REFERENCES aggregates (aggregate_id) ON UPDATE CASCADE ON DELETE CASCADE
+          );
+
+          CREATE TABLE events (
+            aggregate_id uuid NOT NULL,
+            partition_key text NOT NULL DEFAULT '',
+            sequence_number integer NOT NULL,
+            created_at timestamp with time zone NOT NULL,
+            command_id bigint NOT NULL,
+            event_type_id SMALLINT NOT NULL,
+            event_json jsonb NOT NULL,
+            xact_id bigint DEFAULT pg_current_xact_id()::text::bigint,
+            PRIMARY KEY (partition_key, aggregate_id, sequence_number),
+            FOREIGN KEY (partition_key, aggregate_id) REFERENCES aggregates (events_partition_key, aggregate_id)
+                 ON UPDATE CASCADE ON DELETE RESTRICT,
+            FOREIGN KEY (command_id) REFERENCES commands (id) ON UPDATE RESTRICT ON DELETE RESTRICT,
+            FOREIGN KEY (event_type_id) REFERENCES event_types (id) ON UPDATE CASCADE
+          ) PARTITION BY RANGE (partition_key);
+
+          CREATE TABLE aggregates_that_need_snapshots (
+            aggregate_id uuid NOT NULL PRIMARY KEY,
+            snapshot_sequence_number_high_water_mark integer,
+            snapshot_outdated_at timestamp with time zone,
+            snapshot_scheduled_at timestamp with time zone,
+            FOREIGN KEY (aggregate_id) REFERENCES aggregates (aggregate_id) ON UPDATE CASCADE ON DELETE CASCADE
+          );
+
+          COMMENT ON TABLE aggregates_that_need_snapshots IS 'Contains a row for every aggregate with more events than its snapshot threshold.';
+          COMMENT ON COLUMN aggregates_that_need_snapshots.snapshot_sequence_number_high_water_mark
+            IS 'The highest sequence number of the stored snapshot. Kept when snapshot are deleted to more easily query aggregates that need snapshotting the most';
+          COMMENT ON COLUMN aggregates_that_need_snapshots.snapshot_outdated_at IS 'Not NULL indicates a snapshot is needed since the stored timestamp';
+          COMMENT ON COLUMN aggregates_that_need_snapshots.snapshot_scheduled_at IS 'Not NULL indicates a snapshot is in the process of being taken';
+
+          CREATE TABLE snapshot_records (
+            aggregate_id uuid NOT NULL,
+            sequence_number integer NOT NULL,
+            created_at timestamptz NOT NULL,
+            snapshot_type text NOT NULL,
+            snapshot_json jsonb NOT NULL,
+            PRIMARY KEY (aggregate_id, sequence_number),
+            FOREIGN KEY (aggregate_id) REFERENCES aggregates_that_need_snapshots (aggregate_id)
+                 ON UPDATE CASCADE ON DELETE CASCADE
+          );
+
+          CREATE TABLE saved_event_records (
+            operation varchar(1) NOT NULL CHECK (operation IN ('U', 'D')),
+            timestamp timestamptz NOT NULL,
+            "user" text NOT NULL,
+            aggregate_id uuid NOT NULL,
+            partition_key text DEFAULT '',
+            sequence_number integer NOT NULL,
+            created_at timestamp with time zone NOT NULL,
+            command_id bigint NOT NULL,
+            event_type text NOT NULL,
+            event_json jsonb NOT NULL,
+            xact_id bigint,
+            PRIMARY KEY (aggregate_id, sequence_number, timestamp)
+          );
+        SQL
+      end
+
+      say 'Creating table partitions', true
+      suppress_messages do
+        execute <<~SQL
+          -- ### Configure partitions as needed
+          CREATE TABLE commands_default PARTITION OF commands DEFAULT;
+          -- CREATE TABLE commands_0 PARTITION OF commands FOR VALUES FROM (1) TO (100e6);
+          -- CREATE TABLE commands_1 PARTITION OF commands FOR VALUES FROM (100e6) TO (200e6);
+          -- CREATE TABLE commands_2 PARTITION OF commands FOR VALUES FROM (200e6) TO (300e6);
+          -- CREATE TABLE commands_3 PARTITION OF commands FOR VALUES FROM (300e6) TO (400e6);
+
+          -- ### Configure partitions as needed
+          CREATE TABLE aggregates_default PARTITION OF aggregates DEFAULT;
+          -- CREATE TABLE aggregates_0 PARTITION OF aggregates FOR VALUES FROM (MINVALUE) TO ('10000000-0000-0000-0000-000000000000');
+          -- CREATE TABLE aggregates_1 PARTITION OF aggregates FOR VALUES FROM ('10000000-0000-0000-0000-000000000000') TO ('20000000-0000-0000-0000-000000000000');
+          -- CREATE TABLE aggregates_2 PARTITION OF aggregates FOR VALUES FROM ('20000000-0000-0000-0000-000000000000') TO ('30000000-0000-0000-0000-000000000000');
+          -- CREATE TABLE aggregates_3 PARTITION OF aggregates FOR VALUES FROM ('30000000-0000-0000-0000-000000000000') TO ('40000000-0000-0000-0000-000000000000');
+          -- CREATE TABLE aggregates_4 PARTITION OF aggregates FOR VALUES FROM ('40000000-0000-0000-0000-000000000000') TO ('50000000-0000-0000-0000-000000000000');
+          -- CREATE TABLE aggregates_5 PARTITION OF aggregates FOR VALUES FROM ('50000000-0000-0000-0000-000000000000') TO ('60000000-0000-0000-0000-000000000000');
+          -- CREATE TABLE aggregates_6 PARTITION OF aggregates FOR VALUES FROM ('60000000-0000-0000-0000-000000000000') TO ('70000000-0000-0000-0000-000000000000');
+          -- CREATE TABLE aggregates_7 PARTITION OF aggregates FOR VALUES FROM ('70000000-0000-0000-0000-000000000000') TO ('80000000-0000-0000-0000-000000000000');
+          -- CREATE TABLE aggregates_8 PARTITION OF aggregates FOR VALUES FROM ('80000000-0000-0000-0000-000000000000') TO ('90000000-0000-0000-0000-000000000000');
+          -- CREATE TABLE aggregates_9 PARTITION OF aggregates FOR VALUES FROM ('90000000-0000-0000-0000-000000000000') TO ('a0000000-0000-0000-0000-000000000000');
+          -- CREATE TABLE aggregates_a PARTITION OF aggregates FOR VALUES FROM ('a0000000-0000-0000-0000-000000000000') TO ('b0000000-0000-0000-0000-000000000000');
+          -- CREATE TABLE aggregates_b PARTITION OF aggregates FOR VALUES FROM ('b0000000-0000-0000-0000-000000000000') TO ('c0000000-0000-0000-0000-000000000000');
+          -- CREATE TABLE aggregates_c PARTITION OF aggregates FOR VALUES FROM ('c0000000-0000-0000-0000-000000000000') TO ('d0000000-0000-0000-0000-000000000000');
+          -- CREATE TABLE aggregates_d PARTITION OF aggregates FOR VALUES FROM ('d0000000-0000-0000-0000-000000000000') TO ('e0000000-0000-0000-0000-000000000000');
+          -- CREATE TABLE aggregates_e PARTITION OF aggregates FOR VALUES FROM ('e0000000-0000-0000-0000-000000000000') TO ('f0000000-0000-0000-0000-000000000000');
+          -- CREATE TABLE aggregates_f PARTITION OF aggregates FOR VALUES FROM ('f0000000-0000-0000-0000-000000000000') TO (MAXVALUE);
+
+          -- ### Configure partitions as needed
+          CREATE TABLE events_default PARTITION OF events DEFAULT;
+          -- CREATE TABLE events_2023_and_earlier PARTITION OF events FOR VALUES FROM ('Y00') TO ('Y24');
+          -- CREATE TABLE events_2024 PARTITION OF events FOR VALUES FROM ('Y24') TO ('Y25');
+          -- CREATE TABLE events_2025 PARTITION OF events FOR VALUES FROM ('Y25') TO ('Y26');
+          -- CREATE TABLE events_2026 PARTITION OF events FOR VALUES FROM ('Y26') TO ('Y27');
+          -- CREATE TABLE events_2027_and_later PARTITION OF events FOR VALUES FROM ('Y27') TO ('Y99');
+          -- CREATE TABLE events_aggregate PARTITION OF events FOR VALUES FROM ('A') TO ('Ag');
+        SQL
+      end
+
+      say 'Creating indexes', true
+      suppress_messages do
+        execute <<~SQL
+          CREATE INDEX aggregates_aggregate_type_id_idx ON aggregates (aggregate_type_id);
+          CREATE INDEX commands_command_type_id_idx ON commands (command_type_id);
+          CREATE INDEX commands_aggregate_id_idx ON commands (aggregate_id);
+          CREATE INDEX commands_event_idx ON commands (event_aggregate_id, event_sequence_number);
+          CREATE INDEX events_command_id_idx ON events (command_id);
+          CREATE INDEX events_event_type_id_idx ON events (event_type_id);
+          CREATE INDEX aggregates_that_need_snapshots_outdated_idx
+                    ON aggregates_that_need_snapshots (snapshot_outdated_at ASC, snapshot_sequence_number_high_water_mark DESC, aggregate_id ASC)
+                 WHERE snapshot_outdated_at IS NOT NULL;
+
+        SQL
+      end
+    end
+  end
+
+  def down
+    execute "DROP SCHEMA #{Sequent.configuration.view_schema_name} CASCADE"
+    execute "DROP SCHEMA #{Sequent.configuration.event_store_schema_name} CASCADE"
+  end
+end

data/db/migrate/20250101000001_sequent_stored_procedures.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+class SequentStoredProcedures < ActiveRecord::Migration[7.2]
+  def up
+    Sequent::Support::Database.with_search_path(Sequent.configuration.event_store_schema_name) do
+      execute_sql_file 'aggregate_event_type', version: 1
+      execute_sql_file 'enrich_command_json', version: 1
+      execute_sql_file 'aggregates_that_need_snapshots', version: 1
+      execute_sql_file 'command_records', version: 1
+      execute_sql_file 'delete_all_snapshots', version: 1
+      execute_sql_file 'delete_snapshots_before', version: 1
+      execute_sql_file 'enrich_event_json', version: 1
+      execute_sql_file 'event_records', version: 1
+      execute_sql_file 'load_event', version: 1
+      execute_sql_file 'load_events', version: 1
+      execute_sql_file 'load_latest_snapshots', version: 1
+      execute_sql_file 'permanently_delete_commands_without_events', version: 1
+      execute_sql_file 'permanently_delete_event_streams', version: 1
+      execute_sql_file 'save_events_trigger', version: 1
+      execute_sql_file 'select_aggregates_for_snapshotting', version: 1
+      execute_sql_file 'store_aggregates', version: 1
+      execute_sql_file 'store_command', version: 1
+      execute_sql_file 'store_events', version: 1
+      execute_sql_file 'store_snapshots', version: 1
+      execute_sql_file 'stream_records', version: 1
+      execute_sql_file 'update_types', version: 1
+      execute_sql_file 'update_unique_keys', version: 1
+    end
+  end
+
+  def down
+    fail ActiveRecord::IrreversibleMigration
+  end
+
+  private
+
+  def execute_sql_file(filename, version:)
+    say "Applying '#{filename}' version #{version}", true
+    suppress_messages do
+      execute File.read(
+        File.join(
+          File.dirname(__FILE__),
+          format('sequent/%s_v%02d.sql', filename, version),
+        ),
+      )
+    end
+  end
+end

data/db/migrate/20250312105100_sequent_store_events_v02.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+class SequentStoreEventsV02 < ActiveRecord::Migration[7.2]
+  def up
+    Sequent::Support::Database.with_search_path(Sequent.configuration.event_store_schema_name) do
+      execute_sql_file 'store_events', version: 2
+    end
+  end
+
+  def down
+    Sequent::Support::Database.with_search_path(Sequent.configuration.event_store_schema_name) do
+      execute_sql_file 'store_events', version: 1
+    end
+  end
+
+  private
+
+  def execute_sql_file(filename, version:)
+    say "Applying '#{filename}' version #{version}", true
+    suppress_messages do
+      execute File.read(
+        File.join(
+          File.dirname(__FILE__),
+          format('sequent/%s_v%02d.sql', filename, version),
+        ),
+      )
+    end
+  end
+end

data/db/migrate/sequent/aggregate_event_type_v01.sql

@@ -0,0 +1,7 @@
+CREATE TYPE aggregate_event_type AS (
+  aggregate_type text,
+  aggregate_id uuid,
+  events_partition_key text,
+  event_type text,
+  event_json jsonb
+);

data/db/migrate/sequent/aggregates_that_need_snapshots_v01.sql

@@ -0,0 +1,12 @@
+CREATE OR REPLACE FUNCTION aggregates_that_need_snapshots(_last_aggregate_id uuid, _limit integer)
+  RETURNS TABLE (aggregate_id uuid)
+LANGUAGE plpgsql SET search_path FROM CURRENT AS $$
+BEGIN
+  RETURN QUERY SELECT a.aggregate_id
+    FROM aggregates_that_need_snapshots a
+   WHERE a.snapshot_outdated_at IS NOT NULL
+     AND (_last_aggregate_id IS NULL OR a.aggregate_id > _last_aggregate_id)
+   ORDER BY 1
+   LIMIT _limit;
+END;
+$$;

data/db/migrate/sequent/command_records_v01.sql

@@ -0,0 +1,11 @@
+DROP VIEW IF EXISTS command_records;
+CREATE VIEW command_records (id, user_id, aggregate_id, command_type, command_json, created_at, event_aggregate_id, event_sequence_number) AS
+  SELECT id,
+         user_id,
+         aggregate_id,
+         (SELECT type FROM command_types WHERE command_types.id = command.command_type_id),
+         enrich_command_json(command),
+         created_at,
+         event_aggregate_id,
+         event_sequence_number
+    FROM commands command;

data/db/migrate/sequent/delete_all_snapshots_v01.sql

@@ -0,0 +1,9 @@
+CREATE OR REPLACE PROCEDURE delete_all_snapshots(_now timestamp with time zone DEFAULT NOW())
+LANGUAGE plpgsql SET search_path FROM CURRENT AS $$
+BEGIN
+  UPDATE aggregates_that_need_snapshots
+     SET snapshot_outdated_at = _now
+   WHERE snapshot_outdated_at IS NULL;
+  DELETE FROM snapshot_records;
+END;
+$$;

data/db/migrate/sequent/delete_snapshots_before_v01.sql

@@ -0,0 +1,14 @@
+CREATE OR REPLACE PROCEDURE delete_snapshots_before(_aggregate_id uuid, _sequence_number integer, _now timestamp with time zone DEFAULT NOW())
+LANGUAGE plpgsql SET search_path FROM CURRENT AS $$
+BEGIN
+  DELETE FROM snapshot_records
+   WHERE aggregate_id = _aggregate_id
+     AND sequence_number < _sequence_number;
+
+  UPDATE aggregates_that_need_snapshots
+     SET snapshot_outdated_at = _now
+   WHERE aggregate_id = _aggregate_id
+     AND snapshot_outdated_at IS NULL
+     AND NOT EXISTS (SELECT 1 FROM snapshot_records WHERE aggregate_id = _aggregate_id);
+END;
+$$;

data/db/migrate/sequent/enrich_command_json_v01.sql

@@ -0,0 +1,14 @@
+CREATE OR REPLACE FUNCTION enrich_command_json(command commands) RETURNS jsonb RETURNS NULL ON NULL INPUT
+LANGUAGE plpgsql SET search_path FROM CURRENT AS $$
+BEGIN
+  RETURN jsonb_build_object(
+      'command_type', (SELECT type FROM command_types WHERE command_types.id = command.command_type_id),
+      'created_at', command.created_at,
+      'user_id', command.user_id,
+      'aggregate_id', command.aggregate_id,
+      'event_aggregate_id', command.event_aggregate_id,
+      'event_sequence_number', command.event_sequence_number
+    )
+    || command.command_json;
+END
+$$;

data/db/migrate/sequent/enrich_event_json_v01.sql

@@ -0,0 +1,11 @@
+CREATE OR REPLACE FUNCTION enrich_event_json(event events) RETURNS jsonb RETURNS NULL ON NULL INPUT
+LANGUAGE plpgsql SET search_path FROM CURRENT AS $$
+BEGIN
+  RETURN jsonb_build_object(
+      'aggregate_id', event.aggregate_id,
+      'sequence_number', event.sequence_number,
+      'created_at', event.created_at
+    )
+    || event.event_json;
+END
+$$;

data/db/migrate/sequent/event_records_v01.sql

@@ -0,0 +1,13 @@
+DROP VIEW IF EXISTS event_records;
+CREATE VIEW event_records (aggregate_id, partition_key, sequence_number, created_at, event_type, event_json, command_record_id, xact_id) AS
+     SELECT aggregate.aggregate_id,
+            event.partition_key,
+            event.sequence_number,
+            event.created_at,
+            type.type,
+            enrich_event_json(event) AS event_json,
+            command_id,
+            event.xact_id
+       FROM events event
+       JOIN aggregates aggregate ON aggregate.aggregate_id = event.aggregate_id AND aggregate.events_partition_key = event.partition_key
+       JOIN event_types type ON event.event_type_id = type.id;

data/db/migrate/sequent/load_event_v01.sql

@@ -0,0 +1,19 @@
+CREATE OR REPLACE FUNCTION load_event(
+  _aggregate_id uuid,
+  _sequence_number integer
+) RETURNS SETOF aggregate_event_type RETURNS NULL ON NULL INPUT
+LANGUAGE plpgsql SET search_path FROM CURRENT AS $$
+BEGIN
+  RETURN QUERY SELECT aggregate_types.type,
+         a.aggregate_id,
+         a.events_partition_key,
+         event_types.type,
+         enrich_event_json(e)
+    FROM aggregates a
+        INNER JOIN events e ON (a.events_partition_key, a.aggregate_id) = (e.partition_key, e.aggregate_id)
+        INNER JOIN aggregate_types ON a.aggregate_type_id = aggregate_types.id
+        INNER JOIN event_types ON e.event_type_id = event_types.id
+   WHERE a.aggregate_id = _aggregate_id
+     AND e.sequence_number = _sequence_number;
+END;
+$$;

data/db/migrate/sequent/load_events_v01.sql

@@ -0,0 +1,40 @@
+CREATE OR REPLACE FUNCTION load_events(
+  _aggregate_ids jsonb,
+  _use_snapshots boolean DEFAULT TRUE,
+  _until timestamptz DEFAULT NULL
+) RETURNS SETOF aggregate_event_type
+LANGUAGE plpgsql SET search_path FROM CURRENT AS $$
+DECLARE
+  _aggregate_id aggregates.aggregate_id%TYPE;
+BEGIN
+  FOR _aggregate_id IN SELECT * FROM jsonb_array_elements_text(_aggregate_ids) LOOP
+    -- Use a single query to avoid race condition with UPDATEs to the events partition key
+    -- in case transaction isolation level is lower than repeatable read (the default of
+    -- PostgreSQL is read committed).
+    RETURN QUERY WITH
+      aggregate AS (
+        SELECT aggregate_types.type, aggregate_id, events_partition_key
+          FROM aggregates
+          JOIN aggregate_types ON aggregate_type_id = aggregate_types.id
+         WHERE aggregate_id = _aggregate_id
+      ),
+      snapshot AS (
+        SELECT *
+          FROM snapshot_records
+         WHERE _use_snapshots
+           AND aggregate_id = _aggregate_id
+           AND (_until IS NULL OR created_at < _until)
+         ORDER BY sequence_number DESC LIMIT 1
+      )
+    (SELECT a.*, s.snapshot_type, s.snapshot_json FROM aggregate a, snapshot s)
+    UNION ALL
+    (SELECT a.*, event_types.type, enrich_event_json(e)
+       FROM aggregate a
+       JOIN events e ON (a.events_partition_key, a.aggregate_id) = (e.partition_key, e.aggregate_id)
+       JOIN event_types ON e.event_type_id = event_types.id
+      WHERE e.sequence_number >= COALESCE((SELECT sequence_number FROM snapshot), 0)
+        AND (_until IS NULL OR e.created_at < _until)
+      ORDER BY e.sequence_number ASC);
+  END LOOP;
+END;
+$$;

data/db/migrate/sequent/load_latest_snapshots_v01.sql

@@ -0,0 +1,12 @@
+CREATE OR REPLACE FUNCTION load_latest_snapshot(_aggregate_id uuid) RETURNS aggregate_event_type
+LANGUAGE SQL SET search_path FROM CURRENT AS $$
+  SELECT (SELECT type FROM aggregate_types WHERE id = a.aggregate_type_id),
+         a.aggregate_id,
+         a.events_partition_key,
+         s.snapshot_type,
+         s.snapshot_json
+    FROM aggregates a JOIN snapshot_records s ON a.aggregate_id = s.aggregate_id
+   WHERE a.aggregate_id = _aggregate_id
+   ORDER BY s.sequence_number DESC
+   LIMIT 1;
+$$;

data/db/migrate/sequent/permanently_delete_commands_without_events_v01.sql

@@ -0,0 +1,13 @@
+DROP PROCEDURE IF EXISTS permanently_delete_commands_without_events(uuid, uuid);
+CREATE OR REPLACE PROCEDURE permanently_delete_commands_without_events(_aggregate_id uuid)
+LANGUAGE plpgsql SET search_path FROM CURRENT AS $$
+BEGIN
+  IF _aggregate_id IS NULL THEN
+    RAISE EXCEPTION 'aggregate_id must be specified to delete commands';
+  END IF;
+
+  DELETE FROM commands
+   WHERE aggregate_id = _aggregate_id
+     AND NOT EXISTS (SELECT 1 FROM events WHERE command_id = commands.id);
+END;
+$$;

data/db/migrate/sequent/permanently_delete_event_streams_v01.sql

@@ -0,0 +1,13 @@
+CREATE OR REPLACE PROCEDURE permanently_delete_event_streams(_aggregate_ids jsonb)
+LANGUAGE plpgsql SET search_path FROM CURRENT AS $$
+BEGIN
+  DELETE FROM events
+   USING jsonb_array_elements_text(_aggregate_ids) AS ids (id)
+    JOIN aggregates ON ids.id::uuid = aggregates.aggregate_id
+   WHERE events.partition_key = aggregates.events_partition_key
+     AND events.aggregate_id = aggregates.aggregate_id;
+  DELETE FROM aggregates
+   USING jsonb_array_elements_text(_aggregate_ids) AS ids (id)
+   WHERE aggregates.aggregate_id = ids.id::uuid;
+END;
+$$;

data/db/migrate/sequent/save_events_trigger_v01.sql

@@ -0,0 +1,53 @@
+CREATE OR REPLACE FUNCTION save_events_on_delete_trigger() RETURNS TRIGGER
+LANGUAGE plpgsql SET search_path FROM CURRENT AS $$
+BEGIN
+  INSERT INTO saved_event_records (operation, timestamp, "user", aggregate_id, partition_key, sequence_number, created_at, event_type, event_json, command_id, xact_id)
+  SELECT 'D',
+         statement_timestamp(),
+         user,
+         o.aggregate_id,
+         o.partition_key,
+         o.sequence_number,
+         o.created_at,
+         (SELECT type FROM event_types WHERE event_types.id = o.event_type_id),
+         o.event_json,
+         o.command_id,
+         o.xact_id
+    FROM old_table o;
+  RETURN NULL;
+END;
+$$;
+
+CREATE OR REPLACE FUNCTION save_events_on_update_trigger() RETURNS TRIGGER
+LANGUAGE plpgsql SET search_path FROM CURRENT AS $$
+BEGIN
+  INSERT INTO saved_event_records (operation, timestamp, "user", aggregate_id, partition_key, sequence_number, created_at, event_type, event_json, command_id, xact_id)
+  SELECT 'U',
+         statement_timestamp(),
+         user,
+         o.aggregate_id,
+         o.partition_key,
+         o.sequence_number,
+         o.created_at,
+         (SELECT type FROM event_types WHERE event_types.id = o.event_type_id),
+         o.event_json,
+         o.command_id,
+         o.xact_id
+    FROM old_table o LEFT JOIN new_table n ON o.aggregate_id = n.aggregate_id AND o.sequence_number = n.sequence_number
+   WHERE n IS NULL
+      -- Only save when event related information changes
+      OR o.created_at <> n.created_at
+      OR o.event_type_id <> n.event_type_id
+      OR o.event_json <> n.event_json;
+  RETURN NULL;
+END;
+$$;
+
+CREATE OR REPLACE TRIGGER save_events_on_delete_trigger
+    AFTER DELETE ON events
+    REFERENCING OLD TABLE AS old_table
+    FOR EACH STATEMENT EXECUTE FUNCTION save_events_on_delete_trigger();
+CREATE OR REPLACE TRIGGER save_events_on_update_trigger
+    AFTER UPDATE ON events
+    REFERENCING OLD TABLE AS old_table NEW TABLE AS new_table
+    FOR EACH STATEMENT EXECUTE FUNCTION save_events_on_update_trigger();

data/db/migrate/sequent/select_aggregates_for_snapshotting_v01.sql

@@ -0,0 +1,19 @@
+CREATE OR REPLACE FUNCTION select_aggregates_for_snapshotting(_limit integer, _reschedule_snapshot_scheduled_before timestamp with time zone, _now timestamp with time zone DEFAULT NOW())
+  RETURNS TABLE (aggregate_id uuid)
+LANGUAGE plpgsql SET search_path FROM CURRENT AS $$
+BEGIN
+  RETURN QUERY WITH scheduled AS MATERIALIZED (
+    SELECT a.aggregate_id
+      FROM aggregates_that_need_snapshots AS a
+     WHERE snapshot_outdated_at IS NOT NULL
+     ORDER BY snapshot_outdated_at ASC, snapshot_sequence_number_high_water_mark DESC, aggregate_id ASC
+     LIMIT _limit
+       FOR UPDATE
+   ) UPDATE aggregates_that_need_snapshots AS row
+        SET snapshot_scheduled_at = _now
+       FROM scheduled
+      WHERE row.aggregate_id = scheduled.aggregate_id
+        AND (row.snapshot_scheduled_at IS NULL OR row.snapshot_scheduled_at < _reschedule_snapshot_scheduled_before)
+    RETURNING row.aggregate_id;
+END;
+$$;

data/db/migrate/sequent/store_aggregates_v01.sql

@@ -0,0 +1,39 @@
+CREATE OR REPLACE PROCEDURE store_aggregates(_aggregates_with_events jsonb)
+LANGUAGE plpgsql SET search_path FROM CURRENT AS $$
+DECLARE
+  _aggregate jsonb;
+  _events jsonb;
+  _aggregate_id aggregates.aggregate_id%TYPE;
+  _events_partition_key aggregates.events_partition_key%TYPE;
+  _snapshot_outdated_at aggregates_that_need_snapshots.snapshot_outdated_at%TYPE;
+BEGIN
+  FOR _aggregate, _events IN SELECT row->0, row->1 FROM jsonb_array_elements(_aggregates_with_events) AS row LOOP
+    _aggregate_id = _aggregate->>'aggregate_id';
+
+    _events_partition_key = COALESCE(
+      _aggregate->>'events_partition_key',
+      (SELECT events_partition_key FROM aggregates WHERE aggregate_id = _aggregate_id),
+      ''
+    );
+
+    INSERT INTO aggregates (aggregate_id, created_at, aggregate_type_id, events_partition_key)
+    VALUES (
+      _aggregate_id,
+      (_events->0->>'created_at')::timestamptz,
+      (SELECT id FROM aggregate_types WHERE type = _aggregate->>'aggregate_type'),
+      _events_partition_key
+    ) ON CONFLICT (aggregate_id)
+      DO UPDATE SET events_partition_key = EXCLUDED.events_partition_key
+              WHERE aggregates.events_partition_key IS DISTINCT FROM EXCLUDED.events_partition_key;
+
+    _snapshot_outdated_at = _aggregate->>'snapshot_outdated_at';
+    IF _snapshot_outdated_at IS NOT NULL THEN
+      INSERT INTO aggregates_that_need_snapshots AS row (aggregate_id, snapshot_outdated_at)
+      VALUES (_aggregate_id, _snapshot_outdated_at)
+          ON CONFLICT (aggregate_id) DO UPDATE
+         SET snapshot_outdated_at = LEAST(row.snapshot_outdated_at, EXCLUDED.snapshot_outdated_at)
+       WHERE row.snapshot_outdated_at IS DISTINCT FROM EXCLUDED.snapshot_outdated_at;
+    END IF;
+  END LOOP;
+END;
+$$;

data/db/migrate/sequent/store_command_v01.sql

@@ -0,0 +1,21 @@
+CREATE OR REPLACE FUNCTION store_command(_command jsonb) RETURNS bigint RETURNS NULL ON NULL INPUT
+LANGUAGE plpgsql SET search_path FROM CURRENT AS $$
+DECLARE
+  _id commands.id%TYPE;
+  _command_json jsonb = _command->'command_json';
+BEGIN
+  INSERT INTO commands (
+    created_at, user_id, aggregate_id, command_type_id, command_json,
+    event_aggregate_id, event_sequence_number
+  ) VALUES (
+    (_command->>'created_at')::timestamptz,
+    (_command_json->>'user_id')::uuid,
+    (_command_json->>'aggregate_id')::uuid,
+    (SELECT id FROM command_types WHERE type = _command->>'command_type'),
+    (_command->'command_json') - '{command_type,created_at,user_id,aggregate_id,event_aggregate_id,event_sequence_number}'::text[],
+    (_command_json->>'event_aggregate_id')::uuid,
+    NULLIF(_command_json->'event_sequence_number', 'null'::jsonb)::integer
+  ) RETURNING id INTO STRICT _id;
+  RETURN _id;
+END;
+$$;

data/db/migrate/sequent/store_events_v01.sql

@@ -0,0 +1,37 @@
+CREATE OR REPLACE PROCEDURE store_events(_command jsonb, _aggregates_with_events jsonb)
+LANGUAGE plpgsql SET search_path FROM CURRENT AS $$
+DECLARE
+  _command_id commands.id%TYPE;
+  _aggregates jsonb;
+  _aggregate jsonb;
+  _events jsonb;
+  _aggregate_id aggregates.aggregate_id%TYPE;
+  _events_partition_key aggregates.events_partition_key%TYPE;
+BEGIN
+  CALL update_types(_command, _aggregates_with_events);
+
+  _command_id = store_command(_command);
+
+  CALL store_aggregates(_aggregates_with_events);
+
+  _aggregates = (SELECT jsonb_agg(row->0) FROM jsonb_array_elements(_aggregates_with_events) AS row);
+  CALL update_unique_keys(_aggregates);
+
+  FOR _aggregate, _events IN SELECT row->0, row->1 FROM jsonb_array_elements(_aggregates_with_events) AS row
+                             ORDER BY row->0->'aggregate_id', row->1->0->'event_json'->'sequence_number'
+  LOOP
+    _aggregate_id = _aggregate->>'aggregate_id';
+    SELECT events_partition_key INTO STRICT _events_partition_key FROM aggregates WHERE aggregate_id = _aggregate_id;
+
+    INSERT INTO events (partition_key, aggregate_id, sequence_number, created_at, command_id, event_type_id, event_json)
+    SELECT _events_partition_key,
+           _aggregate_id,
+           (event->'event_json'->'sequence_number')::integer,
+           (event->>'created_at')::timestamptz,
+           _command_id,
+           (SELECT id FROM event_types WHERE type = event->>'event_type'),
+           (event->'event_json') - '{aggregate_id,created_at,event_type,sequence_number}'::text[]
+      FROM jsonb_array_elements(_events) AS event;
+  END LOOP;
+END;
+$$;