@haathie/pgmb 0.2.13 → 0.2.15

package/lib/client.js

@@ -62,14 +62,14 @@ export class PgmbClient extends PGMBEventBatcher {
         const isPgCronEnabled = pgCronRslt?.value === 'true';
         if (!isPgCronEnabled) {
             // maintain event table
-            await maintainEventsTable.run(undefined, this.client);
+            await maintainEventsTable.run({}, this.client);
             this.logger.debug('maintained events table');
             if (this.pollEventsIntervalMs) {
                 this.#pollTask = this.#startLoop(pollForEvents.run.bind(pollForEvents, undefined, this.client), this.pollEventsIntervalMs);
             }
             if (this.tableMaintenanceMs) {
                 this.#tableMaintainTask = this.#startLoop(maintainEventsTable.run
-                    .bind(maintainEventsTable, undefined, this.client), this.tableMaintenanceMs);
+                    .bind(maintainEventsTable, {}, this.client), this.tableMaintenanceMs);
             }
         }
         await assertGroup.run({ id: this.groupId }, this.client);

package/lib/queries.d.ts

@@ -103,7 +103,7 @@ export interface IMarkSubscriptionsActiveQuery {
  * UPDATE pgmb.subscriptions
  * SET
  * 	last_active_at = NOW()
- * WHERE id IN (SELECT * FROM unnest(:ids!::pgmb.subscription_id[]))
+ * WHERE id IN (SELECT * FROM unnest(:ids!::text[]))
  * ```
  */
 export declare const markSubscriptionsActive: PreparedQuery<IMarkSubscriptionsActiveParams, void>;
@@ -427,7 +427,7 @@ export interface IRemoveExpiredSubscriptionsQuery {
  * 	WHERE group_id = :groupId!
  * 		AND expiry_interval IS NOT NULL
  * 		AND pgmb.add_interval_imm(last_active_at, expiry_interval) < NOW()
- * 		AND id NOT IN (select * from unnest(:activeIds!::pgmb.subscription_id[]))
+ * 		AND id NOT IN (select * from unnest(:activeIds!::text[]))
  * 	RETURNING id
  * )
  * SELECT COUNT(*) AS "deleted!" FROM deleted
@@ -479,11 +479,11 @@ export interface IUpdateConfigValueQuery {
  */
 export declare const updateConfigValue: PreparedQuery<IUpdateConfigValueParams, IUpdateConfigValueResult>;
 /** 'MaintainEventsTable' parameters type */
-export type IMaintainEventsTableParams = void;
-/** 'MaintainEventsTable' return type */
-export interface IMaintainEventsTableResult {
-    maintainEventsTable: undefined | null;
+export interface IMaintainEventsTableParams {
+    ts?: DateOrString | null | void;
 }
+/** 'MaintainEventsTable' return type */
+export type IMaintainEventsTableResult = void;
 /** 'MaintainEventsTable' query type */
 export interface IMaintainEventsTableQuery {
     params: IMaintainEventsTableParams;
@@ -492,7 +492,7 @@ export interface IMaintainEventsTableQuery {
 /**
  * Query generated from SQL:
  * ```
- * SELECT pgmb.maintain_events_table()
+ * CALL pgmb.maintain_events_table(COALESCE(:ts, NOW()))
  * ```
  */
-export declare const maintainEventsTable: PreparedQuery<void, IMaintainEventsTableResult>;
+export declare const maintainEventsTable: PreparedQuery<IMaintainEventsTableParams, void>;

package/lib/queries.js

@@ -46,14 +46,14 @@ const deleteSubscriptionsIR = { "usedParamSet": { "ids": true }, "params": [{ "n
  * ```
  */
 export const deleteSubscriptions = new PreparedQuery(deleteSubscriptionsIR);
-const markSubscriptionsActiveIR = { "usedParamSet": { "ids": true }, "params": [{ "name": "ids", "required": true, "transform": { "type": "scalar" }, "locs": [{ "a": 88, "b": 92 }] }], "statement": "UPDATE pgmb.subscriptions\nSET\n\tlast_active_at = NOW()\nWHERE id IN (SELECT * FROM unnest(:ids!::pgmb.subscription_id[]))" };
+const markSubscriptionsActiveIR = { "usedParamSet": { "ids": true }, "params": [{ "name": "ids", "required": true, "transform": { "type": "scalar" }, "locs": [{ "a": 88, "b": 92 }] }], "statement": "UPDATE pgmb.subscriptions\nSET\n\tlast_active_at = NOW()\nWHERE id IN (SELECT * FROM unnest(:ids!::text[]))" };
 /**
  * Query generated from SQL:
  * ```
  * UPDATE pgmb.subscriptions
  * SET
  * 	last_active_at = NOW()
- * WHERE id IN (SELECT * FROM unnest(:ids!::pgmb.subscription_id[]))
+ * WHERE id IN (SELECT * FROM unnest(:ids!::text[]))
  * ```
  */
 export const markSubscriptionsActive = new PreparedQuery(markSubscriptionsActiveIR);
@@ -206,7 +206,7 @@ const findEventsIR = { "usedParamSet": { "ids": true }, "params": [{ "name": "id
  * ```
  */
 export const findEvents = new PreparedQuery(findEventsIR);
-const removeExpiredSubscriptionsIR = { "usedParamSet": { "groupId": true, "activeIds": true }, "params": [{ "name": "groupId", "required": true, "transform": { "type": "scalar" }, "locs": [{ "a": 68, "b": 76 }] }, { "name": "activeIds", "required": true, "transform": { "type": "scalar" }, "locs": [{ "a": 219, "b": 229 }] }], "statement": "WITH deleted AS (\n\tDELETE FROM pgmb.subscriptions\n\tWHERE group_id = :groupId!\n\t\tAND expiry_interval IS NOT NULL\n\t\tAND pgmb.add_interval_imm(last_active_at, expiry_interval) < NOW()\n\t\tAND id NOT IN (select * from unnest(:activeIds!::pgmb.subscription_id[]))\n\tRETURNING id\n)\nSELECT COUNT(*) AS \"deleted!\" FROM deleted" };
+const removeExpiredSubscriptionsIR = { "usedParamSet": { "groupId": true, "activeIds": true }, "params": [{ "name": "groupId", "required": true, "transform": { "type": "scalar" }, "locs": [{ "a": 68, "b": 76 }] }, { "name": "activeIds", "required": true, "transform": { "type": "scalar" }, "locs": [{ "a": 219, "b": 229 }] }], "statement": "WITH deleted AS (\n\tDELETE FROM pgmb.subscriptions\n\tWHERE group_id = :groupId!\n\t\tAND expiry_interval IS NOT NULL\n\t\tAND pgmb.add_interval_imm(last_active_at, expiry_interval) < NOW()\n\t\tAND id NOT IN (select * from unnest(:activeIds!::text[]))\n\tRETURNING id\n)\nSELECT COUNT(*) AS \"deleted!\" FROM deleted" };
 /**
  * Query generated from SQL:
  * ```
@@ -215,7 +215,7 @@ const removeExpiredSubscriptionsIR = { "usedParamSet": { "groupId": true, "activ
  * 	WHERE group_id = :groupId!
  * 		AND expiry_interval IS NOT NULL
  * 		AND pgmb.add_interval_imm(last_active_at, expiry_interval) < NOW()
- * 		AND id NOT IN (select * from unnest(:activeIds!::pgmb.subscription_id[]))
+ * 		AND id NOT IN (select * from unnest(:activeIds!::text[]))
  * 	RETURNING id
  * )
  * SELECT COUNT(*) AS "deleted!" FROM deleted
@@ -241,11 +241,11 @@ const updateConfigValueIR = { "usedParamSet": { "value": true, "key": true }, "p
  * ```
  */
 export const updateConfigValue = new PreparedQuery(updateConfigValueIR);
-const maintainEventsTableIR = { "usedParamSet": {}, "params": [], "statement": "SELECT pgmb.maintain_events_table()" };
+const maintainEventsTableIR = { "usedParamSet": { "ts": true }, "params": [{ "name": "ts", "required": false, "transform": { "type": "scalar" }, "locs": [{ "a": 41, "b": 43 }] }], "statement": "CALL pgmb.maintain_events_table(COALESCE(:ts, NOW()))" };
 /**
  * Query generated from SQL:
  * ```
- * SELECT pgmb.maintain_events_table()
+ * CALL pgmb.maintain_events_table(COALESCE(:ts, NOW()))
  * ```
  */
 export const maintainEventsTable = new PreparedQuery(maintainEventsTableIR);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@haathie/pgmb",
-  "version": "0.2.13",
+  "version": "0.2.15",
   "description": "PG message broker, with a type-safe typescript client with built-in webhook & SSE support.",
   "publishConfig": {
     "registry": "https://registry.npmjs.org",
@@ -10,16 +10,17 @@
   "main": "lib/index.js",
   "repository": "https://github.com/haathie/pgmb",
   "scripts": {
-    "test": "TZ=UTC NODE_ENV=test node --env-file ./.env.test --test tests/*.test.ts",
+    "test": "node --env-file ./.test.env --test tests/*.test.ts",
     "prepare": "npm run build",
     "build": "tsc -p tsconfig.build.json",
     "lint": "eslint ./ --ext .js,.ts,.jsx,.tsx",
     "lint:fix": "eslint ./ --fix --ext .js,.ts,.jsx,.tsx",
-    "benchmark": "TZ=utc node --env-file ./.env.test src/benchmark/run.ts",
+    "benchmark": "TZ=utc node --env-file ./.env.test benchmark/run.ts",
     "pg:typegen": "pgtyped --config ./pgtyped.config.json"
   },
   "devDependencies": {
     "@adiwajshing/eslint-config": "git+https://github.com/adiwajshing/eslint-config",
+    "@electric-sql/pglite": "^0.4.1",
     "@pgtyped/cli": "^2.4.3",
     "@types/amqplib": "^0.10.0",
     "@types/chance": "^1.1.6",

package/sql/pgmb-0.2.14-0.2.15.sql

@@ -0,0 +1,165 @@
+SET search_path TO pgmb;
+
+CREATE OR REPLACE FUNCTION maintain_time_partitions_using_event_id(
+	table_id regclass,
+	partition_interval INTERVAL,
+	future_interval INTERVAL,
+	retention_period INTERVAL,
+	additional_sql TEXT DEFAULT NULL,
+	current_ts timestamptz DEFAULT NOW()
+)
+RETURNS void AS $$
+DECLARE
+	ts_trunc timestamptz := date_bin(partition_interval, current_ts, '2000-1-1');
+	oldest_pt_to_keep text := pgmb
+		.get_time_partition_name(table_id, ts_trunc - retention_period);
+	lock_key CONSTANT BIGINT :=
+		hashtext('pgmb.maintain_tp.' || table_id::text);
+	ranges_to_create tstzrange[];
+	partitions_to_drop regclass[];
+	p_to_drop regclass;
+	cur_range tstzrange;
+	max_retries constant int = 50;
+BEGIN
+	ASSERT partition_interval >= interval '1 minute',
+		'partition_interval must be at least 1 minute';
+	ASSERT future_interval >= partition_interval,
+		'future_interval must be at least as large as partition_interval';
+
+	IF NOT pg_try_advisory_xact_lock(lock_key) THEN
+		-- another process is already maintaining partitions for this table
+		RETURN;
+	END IF;
+
+	-- find all intervals we need to create partitions for
+	WITH existing_part_ranges AS (
+		SELECT
+			tstzrange(
+	  		extract_date_from_event_id(lower_bound),
+	     	extract_date_from_event_id(upper_bound),
+	      '[]'
+	    ) as range
+    FROM pgmb.get_partitions_and_bounds(table_id)
+	),
+	future_tzs AS (
+		SELECT
+			tstzrange(dt, dt + partition_interval, '[]') AS range
+		FROM generate_series(
+			ts_trunc,
+			ts_trunc + future_interval,
+			partition_interval
+		) AS gs(dt)
+	),
+	diffs AS (
+		SELECT
+			CASE WHEN epr.range IS NOT NULL
+			THEN (ftz.range::tstzmultirange - epr.range::tstzmultirange)
+			ELSE ftz.range::tstzmultirange
+			END AS ranges
+		FROM future_tzs ftz
+		LEFT JOIN existing_part_ranges epr ON ftz.range && epr.range
+	)
+	select ARRAY_AGG(u.range) FROM diffs
+	CROSS JOIN LATERAL unnest(diffs.ranges) AS u(range)
+	INTO ranges_to_create;
+
+	ranges_to_create := COALESCE(ranges_to_create, ARRAY[]::tstzrange[]);
+
+	SELECT ARRAY_AGG(inhrelid::regclass) INTO partitions_to_drop
+	FROM pg_catalog.pg_inherits
+	WHERE inhparent = table_id
+		AND inhrelid::regclass::text < oldest_pt_to_keep;
+	partitions_to_drop := COALESCE(partitions_to_drop, ARRAY[]::regclass[]);
+
+	-- check if nothing to do
+	IF
+		array_length(partitions_to_drop, 1) = 0
+		AND array_length(ranges_to_create, 1) = 0
+	THEN
+		RETURN;
+	END IF;
+
+	-- go from now to future_interval
+	FOREACH cur_range IN ARRAY ranges_to_create LOOP
+		DECLARE
+			start_ev_id event_id := pgmb.create_event_id(lower(cur_range), 0);
+			end_ev_id event_id := pgmb.create_event_id(upper(cur_range), 0);
+			pt_name TEXT := pgmb.get_time_partition_name(table_id, lower(cur_range));
+		BEGIN
+			RAISE NOTICE 'creating partition "%". start: %, end: %',
+				pt_name, lower(cur_range), upper(cur_range);
+
+			EXECUTE FORMAT(
+				'CREATE TABLE %I PARTITION OF %I FOR VALUES FROM (%L) TO (%L)',
+				pt_name, table_id, start_ev_id, end_ev_id
+			);
+
+			IF additional_sql IS NOT NULL THEN
+				EXECUTE REPLACE(additional_sql, '$1', pt_name);
+			END IF;
+		END;
+	END LOOP;
+
+	-- Drop old partitions
+	FOREACH p_to_drop IN ARRAY partitions_to_drop LOOP
+		EXECUTE format('DROP TABLE %I', p_to_drop);
+	END LOOP;
+END;
+$$ LANGUAGE plpgsql VOLATILE PARALLEL UNSAFE SECURITY DEFINER;
+
+CREATE FUNCTION maintain_append_only_table(
+	tbl regclass,
+	current_ts timestamptz DEFAULT NOW()
+)
+RETURNS VOID AS $$
+	SELECT maintain_time_partitions_using_event_id(
+		tbl,
+		partition_interval := get_config_value('partition_interval')::interval,
+		future_interval := get_config_value('future_intervals_to_create')::interval,
+		retention_period := get_config_value('partition_retention_period')::interval,
+		-- turn off autovacuum on the events table, since we're not
+		-- going to be updating/deleting rows from it.
+		-- Also set fillfactor to 100 since we're only inserting.
+		additional_sql := 'ALTER TABLE $1 SET(
+			fillfactor = 100,
+			autovacuum_enabled = false,
+			toast.autovacuum_enabled = false
+		);',
+		current_ts := current_ts
+	);
+$$ LANGUAGE sql VOLATILE PARALLEL UNSAFE SECURITY DEFINER
+SET search_path TO pgmb;
+
+CREATE OR REPLACE PROCEDURE maintain_events_table(
+	current_ts timestamptz DEFAULT NOW()
+) AS $$
+DECLARE
+	pi INTERVAL := pgmb.get_config_value('partition_interval');
+	fic INTERVAL := pgmb.get_config_value('future_intervals_to_create');
+	rp INTERVAL := pgmb.get_config_value('partition_retention_period');
+BEGIN
+	SET search_path TO pgmb;
+
+	PERFORM maintain_append_only_table('events'::regclass, current_ts);
+	COMMIT;
+
+	PERFORM maintain_append_only_table('subscription_events'::regclass, current_ts);
+	COMMIT;
+END;
+$$ LANGUAGE plpgsql;
+
+DO $$
+BEGIN
+	IF get_config_value('use_pg_cron') <> 'true' THEN
+		RETURN;
+	END IF;
+
+	SELECT cron.schedule(
+		'pgmb_maintain_table_partitions',
+		get_config_value('pg_cron_partition_maintenance_cron'),
+		$CMD$ CALL pgmb.maintain_events_table(); $CMD$
+	);
+END
+$$;
+
+DROP FUNCTION IF EXISTS maintain_events_table(timestamptz);

package/sql/pgmb-0.2.8-0.2.14.sql

@@ -0,0 +1,113 @@
+SET search_path TO pgmb;
+
+-- Partition maintenance function for events table. Creates partitions for
+-- the current and next interval. Deletes partitions that are older than the
+-- configured time interval.
+-- Exact partition size and oldest partition interval can be configured
+-- using the "subscriptions_config" table.
+CREATE OR REPLACE FUNCTION maintain_time_partitions_using_event_id(
+	table_id regclass,
+	partition_interval INTERVAL,
+	future_interval INTERVAL,
+	retention_period INTERVAL,
+	additional_sql TEXT DEFAULT NULL,
+	current_ts timestamptz DEFAULT NOW()
+)
+RETURNS void AS $$
+DECLARE
+	ts_trunc timestamptz := date_bin(partition_interval, current_ts, '2000-1-1');
+	oldest_pt_to_keep text := pgmb
+		.get_time_partition_name(table_id, ts_trunc - retention_period);
+	p_info RECORD;
+	lock_key CONSTANT BIGINT :=
+		hashtext('pgmb.maintain_tp.' || table_id::text);
+	ranges_to_create tstzrange[];
+	cur_range tstzrange;
+	max_retries constant int = 50;
+BEGIN
+	ASSERT partition_interval >= interval '1 minute',
+		'partition_interval must be at least 1 minute';
+	ASSERT future_interval >= partition_interval,
+		'future_interval must be at least as large as partition_interval';
+
+	IF NOT pg_try_advisory_xact_lock(lock_key) THEN
+		-- another process is already maintaining partitions for this table
+		RETURN;
+	END IF;
+
+	-- find all intervals we need to create partitions for
+	WITH existing_part_ranges AS (
+		SELECT
+			tstzrange(
+	  		extract_date_from_event_id(lower_bound),
+	     	extract_date_from_event_id(upper_bound),
+	      '[]'
+	    ) as range
+    FROM pgmb.get_partitions_and_bounds(table_id)
+	),
+	future_tzs AS (
+		SELECT
+			tstzrange(dt, dt + partition_interval, '[]') AS range
+		FROM generate_series(
+			ts_trunc,
+			ts_trunc + future_interval,
+			partition_interval
+		) AS gs(dt)
+	),
+	diffs AS (
+		SELECT
+			CASE WHEN epr.range IS NOT NULL
+			THEN (ftz.range::tstzmultirange - epr.range::tstzmultirange)
+			ELSE ftz.range::tstzmultirange
+			END AS ranges
+		FROM future_tzs ftz
+		LEFT JOIN existing_part_ranges epr ON ftz.range && epr.range
+	)
+	select ARRAY_AGG(u.range) FROM diffs
+	CROSS JOIN LATERAL unnest(diffs.ranges) AS u(range)
+	INTO ranges_to_create;
+
+	ranges_to_create := COALESCE(ranges_to_create, ARRAY[]::tstzrange[]);
+
+	FOR i IN 1..max_retries LOOP
+		BEGIN
+			-- go from now to future_interval
+			FOREACH cur_range IN ARRAY ranges_to_create LOOP
+				DECLARE
+					start_ev_id event_id := pgmb.create_event_id(lower(cur_range), 0);
+					end_ev_id event_id := pgmb.create_event_id(upper(cur_range), 0);
+					pt_name TEXT := pgmb.get_time_partition_name(table_id, lower(cur_range));
+				BEGIN
+					RAISE NOTICE 'creating partition "%". start: %, end: %',
+						pt_name, lower(cur_range), upper(cur_range);
+
+					EXECUTE FORMAT(
+						'CREATE TABLE %I PARTITION OF %I FOR VALUES FROM (%L) TO (%L)',
+						pt_name, table_id, start_ev_id, end_ev_id
+					);
+
+					IF additional_sql IS NOT NULL THEN
+						EXECUTE REPLACE(additional_sql, '$1', pt_name);
+					END IF;
+				END;
+			END LOOP;
+
+			-- Drop old partitions
+			FOR p_info IN (
+				SELECT inhrelid::regclass AS child
+				FROM pg_catalog.pg_inherits
+				WHERE inhparent = table_id
+					AND inhrelid::regclass::text < oldest_pt_to_keep
+			) LOOP
+				EXECUTE format('DROP TABLE %I', p_info.child);
+			END LOOP;
+			EXIT;
+		EXCEPTION WHEN lock_not_available OR deadlock_detected THEN
+			IF i = max_retries THEN
+				RAISE;
+			END IF;
+			PERFORM pg_sleep(1);
+		END;
+	END LOOP;
+END;
+$$ LANGUAGE plpgsql VOLATILE PARALLEL UNSAFE SECURITY DEFINER;

package/sql/pgmb.sql

@@ -43,12 +43,12 @@ $$ LANGUAGE sql STRICT STABLE PARALLEL SAFE SET SEARCH_PATH TO pgmb;
 INSERT INTO config(id, value) VALUES
 ('plugin_version', '0.2.0'),
 ('partition_retention_period', '60 minutes'),
-('future_intervals_to_create', '120 minutes'),
+('future_intervals_to_create', '3 hours'),
 ('partition_interval', '30 minutes'),
 ('poll_chunk_size', '10000'),
 ('pg_cron_poll_for_events_cron', '1 second'),
 -- every 30 minutes
-('pg_cron_partition_maintenance_cron', '*/30 * * * *');
+('pg_cron_partition_maintenance_cron', '0 * * * *');
 
 -- we'll create the events table next & its functions ---------------
 
@@ -206,11 +206,13 @@ DECLARE
 	ts_trunc timestamptz := date_bin(partition_interval, current_ts, '2000-1-1');
 	oldest_pt_to_keep text := pgmb
 		.get_time_partition_name(table_id, ts_trunc - retention_period);
-	p_info RECORD;
 	lock_key CONSTANT BIGINT :=
 		hashtext('pgmb.maintain_tp.' || table_id::text);
 	ranges_to_create tstzrange[];
+	partitions_to_drop regclass[];
+	p_to_drop regclass;
 	cur_range tstzrange;
+	max_retries constant int = 50;
 BEGIN
 	ASSERT partition_interval >= interval '1 minute',
 		'partition_interval must be at least 1 minute';
@@ -256,6 +258,20 @@ BEGIN
 
 	ranges_to_create := COALESCE(ranges_to_create, ARRAY[]::tstzrange[]);
 
+	SELECT ARRAY_AGG(inhrelid::regclass) INTO partitions_to_drop
+	FROM pg_catalog.pg_inherits
+	WHERE inhparent = table_id
+		AND inhrelid::regclass::text < oldest_pt_to_keep;
+	partitions_to_drop := COALESCE(partitions_to_drop, ARRAY[]::regclass[]);
+
+	-- check if nothing to do
+	IF
+		array_length(partitions_to_drop, 1) = 0
+		AND array_length(ranges_to_create, 1) = 0
+	THEN
+		RETURN;
+	END IF;
+
 	-- go from now to future_interval
 	FOREACH cur_range IN ARRAY ranges_to_create LOOP
 		DECLARE
@@ -278,13 +294,8 @@ BEGIN
 	END LOOP;
 
 	-- Drop old partitions
-	FOR p_info IN (
-		SELECT inhrelid::regclass AS child
-		FROM pg_catalog.pg_inherits
-		WHERE inhparent = table_id
-			AND inhrelid::regclass::text < oldest_pt_to_keep
-	) LOOP
-		EXECUTE format('DROP TABLE %I', p_info.child);
+	FOREACH p_to_drop IN ARRAY partitions_to_drop LOOP
+		EXECUTE format('DROP TABLE %I', p_to_drop);
 	END LOOP;
 END;
 $$ LANGUAGE plpgsql VOLATILE PARALLEL UNSAFE SECURITY DEFINER;
@@ -799,20 +810,20 @@ END
 $$ LANGUAGE plpgsql VOLATILE PARALLEL UNSAFE
 SET search_path TO pgmb;
 
-CREATE OR REPLACE FUNCTION maintain_events_table(
+-- contains fn to maintain partitions for an append-only table, this
+-- can be used for both "events" and "subscription_events" tables.
+-- It trims old partitions that are outside the retention period, and creates new
+-- ones. Also ensures partitions aren't autovacuumed.
+CREATE FUNCTION maintain_append_only_table(
+	tbl regclass,
 	current_ts timestamptz DEFAULT NOW()
 )
 RETURNS VOID AS $$
-DECLARE
-	pi INTERVAL := get_config_value('partition_interval');
-	fic INTERVAL := get_config_value('future_intervals_to_create');
-	rp INTERVAL := get_config_value('partition_retention_period');
-BEGIN
-	PERFORM maintain_time_partitions_using_event_id(
-		'pgmb.events'::regclass,
-		partition_interval := pi,
-		future_interval := fic,
-		retention_period := rp,
+	SELECT maintain_time_partitions_using_event_id(
+		tbl,
+		partition_interval := get_config_value('partition_interval')::interval,
+		future_interval := get_config_value('future_intervals_to_create')::interval,
+		retention_period := get_config_value('partition_retention_period')::interval,
 		-- turn off autovacuum on the events table, since we're not
 		-- going to be updating/deleting rows from it.
 		-- Also set fillfactor to 100 since we're only inserting.
@@ -823,28 +834,28 @@ BEGIN
 		);',
 		current_ts := current_ts
 	);
+$$ LANGUAGE sql VOLATILE PARALLEL UNSAFE SECURITY DEFINER
+SET search_path TO pgmb;
 
-	PERFORM maintain_time_partitions_using_event_id(
-		'pgmb.subscription_events'::regclass,
-		partition_interval := pi,
-		future_interval := fic,
-		retention_period := rp,
-		-- turn off autovacuum on the events table, since we're not
-		-- going to be updating/deleting rows from it.
-		-- Also set fillfactor to 100 since we're only inserting.
-		additional_sql := 'ALTER TABLE $1 SET(
-			fillfactor = 100,
-			autovacuum_enabled = false,
-			toast.autovacuum_enabled = false
-		);',
-		current_ts := current_ts
-	);
+CREATE OR REPLACE PROCEDURE maintain_events_table(
+	current_ts timestamptz DEFAULT NOW()
+) AS $$
+BEGIN
+	SET search_path TO pgmb;
+	-- we commit after each maintainance function to release locks on the
+	-- partitions as soon as possible. This avoids blocking "poll_for_events",
+	-- & "read_next_events" functions, which when executing all concurrently,
+	-- may cause deadlocks due to lock contention on the partitions.
+	PERFORM maintain_append_only_table('events'::regclass, current_ts);
+	COMMIT;
+
+	PERFORM maintain_append_only_table('subscription_events'::regclass, current_ts);
+	COMMIT;
 END;
-$$ LANGUAGE plpgsql VOLATILE PARALLEL UNSAFE
-SET search_path TO pgmb;
+$$ LANGUAGE plpgsql;
 
--- create the initial partitions
-SELECT maintain_events_table();
+SELECT maintain_append_only_table('events'::regclass);
+SELECT maintain_append_only_table('subscription_events'::regclass);
 
 -- setup pg_cron if it's available ----------------
 
@@ -871,7 +882,7 @@ BEGIN
 		PERFORM cron.schedule(
 			'pgmb_maintain_table_partitions',
 			get_config_value('pg_cron_partition_maintenance_cron'),
-			$CMD$ SELECT pgmb.maintain_events_table(); $CMD$
+			$CMD$ CALL pgmb.maintain_events_table(); $CMD$
 		);
 
 		RAISE LOG 'Scheduled pgmb partition maintenance job: %',

package/sql/queries.sql

@@ -38,7 +38,7 @@ WHERE id IN :ids!;
 UPDATE pgmb.subscriptions
 SET
 	last_active_at = NOW()
-WHERE id IN (SELECT * FROM unnest(:ids!::pgmb.subscription_id[]));
+WHERE id IN (SELECT * FROM unnest(:ids!::text[]));
 
 /* @name pollForEvents */
 SELECT count AS "count!" FROM pgmb.poll_for_events() AS count;
@@ -145,7 +145,7 @@ WITH deleted AS (
 	WHERE group_id = :groupId!
 		AND expiry_interval IS NOT NULL
 		AND pgmb.add_interval_imm(last_active_at, expiry_interval) < NOW()
-		AND id NOT IN (select * from unnest(:activeIds!::pgmb.subscription_id[]))
+		AND id NOT IN (select * from unnest(:activeIds!::text[]))
 	RETURNING id
 )
 SELECT COUNT(*) AS "deleted!" FROM deleted;
@@ -160,4 +160,4 @@ WHERE id = :key!::pgmb.config_type
 RETURNING 1 AS "updated!";
 
 /* @name maintainEventsTable */
-SELECT pgmb.maintain_events_table();
+CALL pgmb.maintain_events_table(COALESCE(:ts, NOW()));