awesome-repositories.com
Blog
MCP
awesome-repositories.com

Discover the best open-source repositories with AI-powered search.

ExploreCurated searchesOpen-source alternativesSelf-hosted softwareBlogSitemap
ProjectMCP serverAboutHow we rankPress
LegalPrivacyTerms
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
pgmq avatar

pgmq/pgmq

0
View on GitHub↗
pgmq.github.io/pgmq↗

Pgmq

PGMQ is a lightweight message queuing system implemented as a PostgreSQL extension to manage asynchronous tasks. It functions as a database-backed message broker that leverages PostgreSQL for persistent storage, atomic operations, and notification-driven delivery.

The system provides an SQS-compatible queue model featuring visibility timeouts and delayed delivery. It supports strict first-in-first-out ordering through group keys and batch retrieval to ensure sequential processing of related tasks.

The project covers a full message lifecycle including production, consumption via atomic pop operations, and administrative management such as queue purging and lifecycle control. It includes routing capabilities through topic-based patterns and reliability features like dead letter queueing, message archiving, and retry logic. Monitoring tools are provided to track operational metrics such as queue length and throughput.

AI search

Explore more awesome repositories

Describe what you need in plain English — the AI ranks thousands of curated open-source projects by relevance.

Start searching with AI

Features

  • Postgres Message Queueing - Implements a full asynchronous task processing system as a PostgreSQL extension using the database as the broker.
  • Database-Backed Brokers - A broker that leverages PostgreSQL for persistent storage, atomic operations, and notification-driven message delivery.
  • PostgreSQL Task Queues - Provides a lightweight message queuing system implemented as a PostgreSQL extension to manage asynchronous tasks.
  • Distributed Task Workers - Manages the delivery and consumption of tasks across multiple distributed worker processes.
  • Atomic Queue Transitions - Provides atomic operations to retrieve and delete messages in a single step to ensure at-most-once delivery.
  • Message Queues - Provides the primary mechanism for adding data payloads to a queue with optional delivery delays.
  • Message Consumption - Implements message retrieval mechanisms including long-polling and visibility timeouts to manage consumer access.
  • Message Deletion Operations - Provides capabilities to remove single or batch messages from the queue after successful processing.
  • Table-Based Storage - Uses dedicated PostgreSQL tables to store message payloads and metadata for persistent queue management.
  • FIFO - Provides a queueing system that ensures strict first-in-first-out ordering of messages using group keys.
  • Message Processing Timeouts - Implements visibility timeouts to prevent premature message redelivery while a task is being processed.
  • Visibility Timeout Controls - Provides granular control over message visibility timeouts to manage processing attempts and redelivery.
  • Atomic Pop Operations - Implements atomic pop operations that combine message retrieval and deletion in one transaction for at-most-once delivery.
  • Skip Locked Concurrency - Employs the FOR UPDATE SKIP LOCKED clause to allow multiple consumers to process messages without blocking each other.
  • FIFO Group Processing - Supports strict first-in-first-out ordering for related tasks using group keys to prevent race conditions.
  • FIFO Task Sequencing - Ensures strict order of operations for related tasks using group identifiers to prevent race conditions.
  • Group-Keyed FIFO Ordering - Maintains strict processing sequences for related messages using group keys and index-based sorting.
  • Database Insert Notifications - Employs Postgres NOTIFY events to alert consumers of new messages immediately without requiring constant polling.
  • Queue Purging - Ships a dedicated operation to clear all pending messages from a queue without deleting the queue itself.
  • Dead Letter Queues - Moves repeatedly failing messages to a separate dead-letter queue to prevent processing blocks.
  • Queue-Specific Metrics - Provides detailed operational statistics including queue length, message age, and overall throughput.
  • Message Requeuing - Implements the ability to re-inject failed messages into the queue by resetting their visibility timeouts.
  • Queue Lifecycle Management - Implements administrative tools for creating and deleting the database tables used for queue storage.
  • Topic Routing Patterns - Implements flexible message distribution using topics and wildcard patterns for complex data delivery.
  • SQS-Compatible Queues - Offers an SQS-compatible queue model featuring visibility timeouts and delayed delivery.
  • Database Trigger Notifications - Uses Postgres NOTIFY events to alert consumers of new message inserts without requiring constant polling.
  • Queue Throughput Analytics - Provides tools for tracking queue length and message throughput to monitor background processing health.
  • Job Queues - Lightweight message queue built on PostgreSQL.
4,976 stars·139 forks·PLpgSQL·PostgreSQL·23 views

Star history

Star history chart for pgmq/pgmqStar history chart for pgmq/pgmq

How this analysis was created: This summary and feature list are AI-generated from collected project material and can contain mistakes. Stars, license and language are imported from GitHub. Inclusion does not mean that we have tested or audited this project. Check the source documentation for any feature you depend on. Learn more on our About page.

Frequently asked questions

What does pgmq/pgmq do?

PGMQ is a lightweight message queuing system implemented as a PostgreSQL extension to manage asynchronous tasks. It functions as a database-backed message broker that leverages PostgreSQL for persistent storage, atomic operations, and notification-driven delivery.

What are the main features of pgmq/pgmq?

The main features of pgmq/pgmq are: Postgres Message Queueing, Database-Backed Brokers, PostgreSQL Task Queues, Distributed Task Workers, Atomic Queue Transitions, Message Queues, Message Consumption, Message Deletion Operations.

Which projects share features with pgmq/pgmq?

Projects with overlapping indexed features include: rabbitmq/rabbitmq-tutorials — This project is a collection of learning resources and instructional guides for implementing asynchronous messaging… airtai/faststream — FastStream is an asynchronous Python framework designed for building event-driven microservices. It provides a unified… taskforcesh/bullmq — BullMQ is a Redis-backed message queue library and background processor designed for distributed task queueing. It… queueclassic/queue_classic — Queue Classic is a background processing framework for Ruby applications that manages asynchronous tasks by utilizing… bogdanp/dramatiq — Dramatiq is a distributed task queue and workload manager used to offload function execution to background workers. It… optimalbits/bull — Bull is a Node.js library for managing distributed jobs and message queues using Redis as the primary data store. It…

Projects sharing features with Pgmq

These projects share indexed features with Pgmq. Shared tags can include platform or build tooling; verify the primary use case before treating a result as a replacement.
  • rabbitmq/rabbitmq-tutorialsrabbitmq avatar

    rabbitmq/rabbitmq-tutorials

    6,889View on GitHub↗

    This project is a collection of learning resources and instructional guides for implementing asynchronous messaging patterns using RabbitMQ. It provides a series of tutorials and runnable code examples focused on the Advanced Message Queuing Protocol to help users decouple services via a message broker. The resources cover practical implementation patterns including request-reply, pub-sub, and stream processing. These guides demonstrate how to use official client libraries to balance worker loads, route messages across multiple consumers in a distributed system, and deploy high availability b

    Javarabbitmqtutorials
    View on GitHub↗6,889
  • airtai/faststreamairtai avatar

    airtai/faststream

    5,234View on GitHub↗

    FastStream is an asynchronous Python framework designed for building event-driven microservices. It provides a unified abstraction layer for interacting with various message brokers, enabling developers to manage event production and consumption through a consistent interface while maintaining access to native provider-specific features. The framework centers on a decorator-based routing model that binds application logic directly to broker topics, supported by a built-in dependency injection container that resolves resources at runtime. The framework distinguishes itself through its deep int

    Python
    View on GitHub↗5,234
  • taskforcesh/bullmqtaskforcesh avatar

    taskforcesh/bullmq

    8,432View on GitHub↗

    BullMQ is a Redis-backed message queue library and background processor designed for distributed task queueing. It functions as a distributed queue manager and task scheduler, utilizing Redis to manage asynchronous job processing and persistence. The system distinguishes itself through its role as a job workflow orchestrator, enabling the definition of complex parent-child job dependencies and hierarchies for multi-step workflows. It provides sandboxed process execution to isolate heavy workloads and prevent event loop blocking, alongside distributed rate limiting to protect downstream servic

    TypeScriptbackground-jobselixirnodejs
    View on GitHub↗8,432
  • queueclassic/queue_classicQueueClassic avatar

    QueueClassic/queue_classic

    1,188View on GitHub↗

    Queue Classic is a background processing framework for Ruby applications that manages asynchronous tasks by utilizing relational database tables for job persistence. By storing tasks directly within the database, the system ensures that job creation remains coupled with application transactions, guaranteeing that tasks are only queued when associated data changes are successfully committed. The framework coordinates concurrent worker processes through database-level locking mechanisms, which prevent redundant execution and allow for distributed task processing without the need for an external

    Rubyactivejobqueuequeuing
    View on GitHub↗1,188
Compare all 30 related projects→