# pgdogdev/pgdog

**Attribution required: if you use, quote, or summarise this content, you must credit and link back to [awesome-repositories.com](https://awesome-repositories.com/repository/pgdogdev-pgdog).**

3,361 stars · 131 forks · Rust · agpl-3.0

## Links

- GitHub: https://github.com/pgdogdev/pgdog
- Homepage: https://pgdog.dev
- awesome-repositories: https://awesome-repositories.com/repository/pgdogdev-pgdog.md

## Topics

`load-balancer` `pooler` `postgresql` `rust` `sharding`

## Description

pgdog is a PostgreSQL sharding proxy, distributed SQL router, and connection pooler. It is designed to enable horizontal data distribution by splitting tables and indices across multiple independent servers to scale storage and processing capacity.

The project distinguishes itself through online resharding capabilities, using logical replication to move data between shards without application downtime. It supports multiple routing strategies, including hash, list, and range-based query routing, and manages distributed atomic transactions using a two-phase commit process to ensure consistency across shards.

The system also covers high availability and traffic management, providing read-write splitting to balance queries between primary and replica nodes. It includes multiplexed connection pooling, real-time health monitoring with OpenTelemetry integration, and a plugin architecture for extending routing logic via shared libraries.

The software can be deployed as a containerized service on AWS ECS or via Kubernetes deployment charts.

## Tags

### Data & Databases

- [PostgreSQL Pool Managers](https://awesome-repositories.com/f/data-databases/connection-pools/postgresql-pool-managers.md) — Implements a multiplexed connection pooler specifically tailored for the PostgreSQL wire protocol and server behavior.
- [Connection Pooling](https://awesome-repositories.com/f/data-databases/high-concurrency-database-access/connection-pooling.md) — Implements high-performance connection pooling to manage reusable database connection sets for thousands of clients. ([source](https://cdn.jsdelivr.net/gh/pgdogdev/pgdog@main/README.md))
- [Horizontal Scaling](https://awesome-repositories.com/f/data-databases/horizontal-scaling.md) — Splits tables and indices across multiple independent servers to scale storage and processing capacity. ([source](https://docs.pgdog.dev/features/sharding/basics/))
- [PostgreSQL Proxy Servers](https://awesome-repositories.com/f/data-databases/postgresql-proxy-servers.md) — Provides a network intermediary that intercepts and multiplexes PostgreSQL traffic to manage connection states and session variables. ([source](https://docs.pgdog.dev/architecture/))
- [Atomic Schema Mutations](https://awesome-repositories.com/f/data-databases/atomic-table-mutations/atomic-schema-mutations.md) — Wraps structural queries in two-phase commit transactions to guarantee schema mutations succeed on all shards or none. ([source](https://docs.pgdog.dev/features/sharding/schema_management/migrations/))
- [Automatic Failover Controllers](https://awesome-repositories.com/f/data-databases/automatic-failover-controllers.md) — Implements mechanisms that monitor database health and automatically promote standby nodes to primary roles during failures. ([source](https://cdn.jsdelivr.net/gh/pgdogdev/pgdog@main/README.md))
- [Logical Topology Mapping](https://awesome-repositories.com/f/data-databases/cluster-topology-caching/static-topology-definitions/logical-topology-mapping.md) — Maps logical database names to physical hosts while assigning primary or replica roles. ([source](https://docs.pgdog.dev/configuration/pgdog.toml/databases/))
- [Concurrent Shard Data Export](https://awesome-repositories.com/f/data-databases/concurrent-shard-data-export.md) — Streams results from all shards concurrently to output a combined data set for large reads. ([source](https://docs.pgdog.dev/features/sharding/cross-shard-queries/copy/))
- [Cross-Shard Result Aggregation](https://awesome-repositories.com/f/data-databases/cross-shard-result-aggregation.md) — Buffers and orders rows returned from multiple shards in memory to ensure correct output sequence. ([source](https://docs.pgdog.dev/features/sharding/cross-shard-queries/select/))
- [Cross-Shard Data Replication](https://awesome-repositories.com/f/data-databases/data-sharding/cross-shard-data-replication.md) — Maintains identical copies of tables on all shards by broadcasting writes and distributing reads. ([source](https://docs.pgdog.dev/features/sharding/cross-shard-queries/insert/))
- [Parallel Query Execution](https://awesome-repositories.com/f/data-databases/database-management-systems/database-systems-management/database-operations/sql-query-execution/parallel-query-execution.md) — Runs a single query across multiple shards in parallel and assembles the results into one response. ([source](https://docs.pgdog.dev/architecture/comparison/))
- [Logical Replication Ingestion](https://awesome-repositories.com/f/data-databases/database-replication-tools/logical-replication-ingestion.md) — Implements online resharding by streaming row changes between shards using logical replication protocols.
- [Schema Caches](https://awesome-repositories.com/f/data-databases/database-schema-managers/schema-caches.md) — Caches database schemas in memory to automatically identify sharded tables and accelerate routing decisions. ([source](https://docs.pgdog.dev/configuration/pgdog.toml/general/))
- [Online Sharding Key Updates](https://awesome-repositories.com/f/data-databases/database-sharding/row-based-sharding/online-sharding-key-updates.md) — Moves a row from one shard to another online by automating the select, insert, and delete process. ([source](https://cdn.jsdelivr.net/gh/pgdogdev/pgdog@main/README.md))
- [Shard Routing Logic](https://awesome-repositories.com/f/data-databases/database-sharding/shard-routing-logic.md) — Directs incoming data to a specific shard based on a sharding key or round-robin distribution. ([source](https://docs.pgdog.dev/features/sharding/cross-shard-queries/insert/))
- [Automated Sharded Table Detection](https://awesome-repositories.com/f/data-databases/database-sharding/shard-routing-logic/automated-sharded-table-detection.md) — Inspects database schemas to automatically identify sharded tables for routing purposes. ([source](https://docs.pgdog.dev/enterprise_edition/schema/))
- [SQL Query Rewriting](https://awesome-repositories.com/f/data-databases/database-sharding/shard-routing-logic/sql-query-rewriting.md) — Transforms SQL statements to handle sharding key updates and ensure data is routed to correct shards. ([source](https://docs.pgdog.dev/configuration/pgdog.toml/rewrite/))
- [Distributed Atomic Transactions](https://awesome-repositories.com/f/data-databases/distributed-atomic-transactions.md) — Uses prepared transactions to ensure atomic writes across multiple shards for consistency across nodes. ([source](https://docs.pgdog.dev/features/sharding/2pc/))
- [Schema-Based Sharding](https://awesome-repositories.com/f/data-databases/distributed-relational-databases/schema-based-sharding.md) — Routes queries to different shards based on the fully qualified schema name of the tables. ([source](https://docs.pgdog.dev/features/sharding/sharding-functions/))
- [Query Routing](https://awesome-repositories.com/f/data-databases/distributed-sql-databases/query-routing.md) — Directs SQL queries to the correct database shard based on sharding keys and server health metrics. ([source](https://docs.pgdog.dev/))
- [Read-Write Splitting](https://awesome-repositories.com/f/data-databases/multi-master-replication/read-write-splitting.md) — Implements routing strategies that separate read and write operations, directing writes to the primary and reads to replicas. ([source](https://docs.pgdog.dev/features/))
- [PostgreSQL Database Sharding](https://awesome-repositories.com/f/data-databases/postgresql-database-sharding.md) — Enables horizontal data distribution by splitting tables and indices across multiple independent PostgreSQL servers.
- [Distributed Query Routers](https://awesome-repositories.com/f/data-databases/query-middleware/distributed-query-routers.md) — Functions as a routing engine that executes queries across multiple shards and aggregates results into a single response.
- [Range-Based Query Routing](https://awesome-repositories.com/f/data-databases/range-based-query-routing.md) — Provides a routing strategy that directs queries to shards based on column value ranges. ([source](https://docs.pgdog.dev/features/sharding/sharding-functions/))
- [Read-Only Transaction Routing](https://awesome-repositories.com/f/data-databases/read-only-access-modes/api-read-only-modes/read-only-transaction-routing.md) — Identifies read-only transactions and routes them to replica databases to reduce primary load. ([source](https://docs.pgdog.dev/features/load-balancer/transactions/))
- [Replica Load Balancers](https://awesome-repositories.com/f/data-databases/replica-load-balancers.md) — Distributes database transactions across multiple primary and replica hosts using various distribution strategies to balance load. ([source](https://cdn.jsdelivr.net/gh/pgdogdev/pgdog@main/README.md))
- [Schema Change Broadcasting](https://awesome-repositories.com/f/data-databases/schema-change-broadcasting.md) — Sends structural statements to all shards in parallel to maintain consistent table layouts. ([source](https://docs.pgdog.dev/features/sharding/supported-queries/))
- [Schema Synchronizers](https://awesome-repositories.com/f/data-databases/schema-synchronizers.md) — Coordinates the reloading of schemas across all proxy nodes to ensure consistent routing after structural changes. ([source](https://docs.pgdog.dev/enterprise_edition/schema/))
- [Shard Schema Synchronization](https://awesome-repositories.com/f/data-databases/shard-schema-synchronization.md) — Replicates table definitions and constraints from source to destination shards to ensure compatibility. ([source](https://docs.pgdog.dev/features/sharding/resharding/databases/))
- [Sharding Proxies](https://awesome-repositories.com/f/data-databases/sharding-proxies.md) — Distributes data across multiple PostgreSQL shards using hash, list, or range-based routing strategies.
- [Cross-Shard Data Aggregation](https://awesome-repositories.com/f/data-databases/sharding-proxies/cross-shard-data-aggregation.md) — Calculates summaries across multiple shards by combining partial results from each database. ([source](https://docs.pgdog.dev/features/sharding/cross-shard-queries/select/))
- [Query Rewriting](https://awesome-repositories.com/f/data-databases/sql-statement-parsing/query-rewriting.md) — Parses and transforms SQL statements at runtime to handle sharding keys and route data to correct servers.
- [Distributed Identifier Generators](https://awesome-repositories.com/f/data-databases/data-management/unique-identifier-generators/distributed-identifier-generators.md) — Generates monotonically increasing 64-bit integers across multiple shards to serve as unique primary keys. ([source](https://docs.pgdog.dev/features/sharding/sequences/))
- [Uniqueness Enforcement](https://awesome-repositories.com/f/data-databases/data-management/unique-identifier-generators/uniqueness-enforcement.md) — Validates that primary keys and unique indexes remain unique across multiple distributed shards. ([source](https://docs.pgdog.dev/roadmap/))
- [Execution Plan Analysis](https://awesome-repositories.com/f/data-databases/database-query-execution/execution-plan-analysis.md) — Retrieves and analyzes execution plans for slow queries to assist in performance tuning. ([source](https://docs.pgdog.dev/enterprise_edition/))
- [Database Query Mirroring](https://awesome-repositories.com/f/data-databases/database-query-mirroring.md) — Duplicates live queries from a source database to a target database for performance testing or synchronization. ([source](https://docs.pgdog.dev/configuration/pgdog.toml/mirroring/))
- [Multi-Row Insert Distribution](https://awesome-repositories.com/f/data-databases/database-sharding/row-based-sharding/multi-row-insert-distribution.md) — Detects sharding keys in multi-row inserts and rewrites them to ensure each row reaches the correct shard. ([source](https://docs.pgdog.dev/features/sharding/supported-queries/))
- [Resharding Identity Validation](https://awesome-repositories.com/f/data-databases/database-sharding/row-based-sharding/resharding-identity-validation.md) — Validates table identity modes to ensure updates are correctly applied during online resharding. ([source](https://docs.pgdog.dev/features/sharding/resharding/replica-identity/))
- [Shard Hint Extraction](https://awesome-repositories.com/f/data-databases/database-sharding/shard-routing-logic/shard-hint-extraction.md) — Extracts sharding hints from query text or protocol parameters to direct requests to the correct shard. ([source](https://docs.pgdog.dev/features/sharding/internals/query-protocol/))
- [Connection Pinning](https://awesome-repositories.com/f/data-databases/database-transaction-management/connection-pinning.md) — Directs all statements within a single transaction to one connection to prevent fragmentation. ([source](https://docs.pgdog.dev/features/load-balancer/transactions/))
- [Automatic Primary Key Injection](https://awesome-repositories.com/f/data-databases/entity-modeling/primary-keys/automatic-primary-key-injection.md) — Populates missing primary keys during inserts using a generated unique identifier to maintain integrity. ([source](https://docs.pgdog.dev/configuration/pgdog.toml/rewrite/))
- [Schema Caching](https://awesome-repositories.com/f/data-databases/in-memory-caches/schema-caching.md) — Stores database table structures in memory to automatically identify sharded tables and accelerate routing.
- [Parallelized Ingestion](https://awesome-repositories.com/f/data-databases/large-scale-dataset-management/parallelized-ingestion.md) — Parses data streams and distributes rows to multiple shards in parallel to accelerate bulk loading. ([source](https://docs.pgdog.dev/features/sharding/cross-shard-queries/copy/))
- [Advisory Locking Mechanisms](https://awesome-repositories.com/f/data-databases/migration-management/advisory-locking-mechanisms.md) — Ties server connections to specific clients to ensure database advisory locks are maintained during connection reuse. ([source](https://docs.pgdog.dev/features/transaction-mode/))
- [Tenant Request Routing](https://awesome-repositories.com/f/data-databases/multi-tenant-data-management/tenant-request-routing.md) — Directs requests to specific databases based on a tenant identifier using mapping logic. ([source](https://docs.pgdog.dev/features/multi-tenancy/))
- [PostgreSQL Load Balancers](https://awesome-repositories.com/f/data-databases/postgresql-load-balancers.md) — Manages traffic by separating read and write operations and routing queries between primary and replica nodes.
- [Statement Synchronization](https://awesome-repositories.com/f/data-databases/prepared-statements/statement-synchronization.md) — Caches and synchronizes prepared statements across pooled connections to maintain session compatibility. ([source](https://docs.pgdog.dev/configuration/pgdog.toml/general/))
- [Replication Lag Monitors](https://awesome-repositories.com/f/data-databases/primary-replica-replication/replication-lag-monitors.md) — Monitors replication delay between primary and replica nodes to enable safe traffic failover. ([source](https://docs.pgdog.dev/administration/replication/))
- [Lag-Based Replica Exclusion](https://awesome-repositories.com/f/data-databases/primary-replica-replication/replication-lag-monitors/lag-based-replica-exclusion.md) — Removes replica databases from the load balancer when they exceed defined replication lag thresholds. ([source](https://docs.pgdog.dev/configuration/pgdog.toml/general/))
- [Query Annotators](https://awesome-repositories.com/f/data-databases/query-performance-monitors/query-annotators.md) — Appends routing metadata to query outputs to explain how data was distributed across shards. ([source](https://docs.pgdog.dev/configuration/pgdog.toml/general/))
- [Consistency-Based Routing](https://awesome-repositories.com/f/data-databases/read-replicas/traffic-routing/consistency-based-routing.md) — Routes manually started transactions to the primary database to ensure read-after-write consistency. ([source](https://docs.pgdog.dev/features/load-balancer/transactions/))
- [Read Load Balancers](https://awesome-repositories.com/f/data-databases/replica-load-balancers/read-load-balancers.md) — Distributes read traffic evenly across all shards for tables with identical replicated data. ([source](https://docs.pgdog.dev/configuration/pgdog.toml/sharded_tables/))
- [Parallel Data Migration](https://awesome-repositories.com/f/data-databases/schema-migrations/parallel-migration-execution/parallel-data-migration.md) — Distributes table copy loads across multiple read replicas in parallel to reduce resharding time. ([source](https://docs.pgdog.dev/features/sharding/resharding/move/))
- [Shard-Aware Sequence Generators](https://awesome-repositories.com/f/data-databases/shard-aware-sequence-generators.md) — Configures table columns to use a shard-aware sequence by replacing default values with a generator function. ([source](https://docs.pgdog.dev/features/sharding/schema_management/functions/))
- [Sharded Bulk Loading](https://awesome-repositories.com/f/data-databases/sharded-bulk-loading.md) — Moves large volumes of data across multiple shards using the standard copy protocol. ([source](https://docs.pgdog.dev/features/sharding/sharding-functions/))
- [Cross-Shard Query Restriction](https://awesome-repositories.com/f/data-databases/sharding-proxies/cross-shard-query-restriction.md) — Blocks queries that attempt to access data across multiple shards to ensure performance and stability. ([source](https://docs.pgdog.dev/configuration/pgdog.toml/general/))
- [Reference Table Replication](https://awesome-repositories.com/f/data-databases/table-definitions/object-mappings/table-to-code-mappers/reference-table-replication.md) — Stores copies of reference tables on every shard to enable high-performance local joins. ([source](https://docs.pgdog.dev/features/sharding/cross-shard-queries/copy/))
- [Multi-Tuple Insert Splitting](https://awesome-repositories.com/f/data-databases/tuple-data-structures/multi-tuple-insert-splitting.md) — Decomposes insert statements containing multiple tuples and routes each tuple to its corresponding shard. ([source](https://docs.pgdog.dev/features/sharding/cross-shard-queries/insert/))

### DevOps & Infrastructure

- [Database High Availability](https://awesome-repositories.com/f/devops-infrastructure/high-availability-clustering/database-high-availability.md) — Automates traffic redirection during primary failover and monitors replica health to ensure continuous database access.
- [Fleet Coordination](https://awesome-repositories.com/f/devops-infrastructure/fleet-coordination.md) — Coordinates a fleet of proxy instances and deployments from a centralized interface. ([source](https://docs.pgdog.dev/enterprise_edition/))

### Networking & Communication

- [Connection Multiplexing](https://awesome-repositories.com/f/networking-communication/connection-multiplexing.md) — Shares a small pool of server connections among thousands of concurrent clients to reduce resource overhead. ([source](https://docs.pgdog.dev/features/))
- [Session State Management](https://awesome-repositories.com/f/networking-communication/session-state-management.md) — Tracks client-specific parameters and updates server settings to prevent session state leakage between pooled connections. ([source](https://docs.pgdog.dev/features/transaction-mode/))
- [Network Connection Preservation](https://awesome-repositories.com/f/networking-communication/tcp-connection-lifecycles/connection-state-management/network-connection-preservation.md) — Maintains client connections during database incidents to prevent the need for application-side pool recreation. ([source](https://docs.pgdog.dev/features/connection-recovery/))
- [Automatic Traffic Switching](https://awesome-repositories.com/f/networking-communication/traffic-redirection-tools/automatic-traffic-switching.md) — Automatically redirects application queries from source to destination clusters during online resharding processes. ([source](https://docs.pgdog.dev/features/sharding/resharding/cutover/))

### Software Engineering & Architecture

- [Distributed Transaction Coordinators](https://awesome-repositories.com/f/software-engineering-architecture/distributed-transaction-coordinators.md) — Coordinates atomic writes across multiple database shards using a two-phase commit protocol to ensure consistency.
- [Two-Phase Commit Protocols](https://awesome-repositories.com/f/software-engineering-architecture/distributed-transaction-coordinators/two-phase-commit-protocols.md) — Manages a two-phase commit protocol to ensure atomic writes and schema changes across multiple database shards.
- [Distributed Transaction Management](https://awesome-repositories.com/f/software-engineering-architecture/distributed-transaction-management.md) — Manages distributed atomic transactions using a two-phase commit process to ensure consistency across multiple shards. ([source](https://docs.pgdog.dev/features/sharding/cross-shard-queries/copy/))
- [Hash-Based Data Distribution](https://awesome-repositories.com/f/software-engineering-architecture/hash-based-data-distribution.md) — Distributes data evenly across shards by calculating a hash of the sharding column. ([source](https://docs.pgdog.dev/features/sharding/sharding-functions/))
- [Database Resharding](https://awesome-repositories.com/f/software-engineering-architecture/shared-caching-topologies/shared-cache-write-permissions/atomic-write-coordinators/database-resharding.md) — Splits existing databases into more shards without downtime by synchronizing data and schema definitions. ([source](https://docs.pgdog.dev/roadmap/))
- [Control Planes](https://awesome-repositories.com/f/software-engineering-architecture/control-planes.md) — Links the system to a central management server to coordinate global state and configuration across distributed nodes. ([source](https://docs.pgdog.dev/configuration/pgdog.toml/control/))
- [Routing Extensions](https://awesome-repositories.com/f/software-engineering-architecture/integration-extensibility/extensibility/plugin-architectures/developer-authoring-interfaces/custom-module-implementations/query-extensions/routing-extensions.md) — Provides a plugin architecture for extending SQL routing logic via shared libraries. ([source](https://docs.pgdog.dev/features/plugins/))
- [Runtime Capability Extensions](https://awesome-repositories.com/f/software-engineering-architecture/modular-extension-systems/runtime-capability-extensions.md) — Integrates external libraries at runtime to add new functional capabilities without recompiling the binary. ([source](https://docs.pgdog.dev/features/))
- [Plugin-Based Architectures](https://awesome-repositories.com/f/software-engineering-architecture/software-architecture/architectural-patterns/plugin-module-systems/modular-plugin-architectures/plugin-based-architectures/plugin-based-architectures.md) — Implements an architecture that extends core proxy functionality by loading external shared libraries at runtime. ([source](https://docs.pgdog.dev/architecture/))

### System Administration & Monitoring

- [Node Health Tracking](https://awesome-repositories.com/f/system-administration-monitoring/node-health-tracking.md) — Monitors the operational status of database hosts in real-time to re-route queries away from failing nodes. ([source](https://cdn.jsdelivr.net/gh/pgdogdev/pgdog@main/README.md))
- [Migration Progress Monitors](https://awesome-repositories.com/f/system-administration-monitoring/data-migration/migration-progress-monitors.md) — Provides real-time status of table copies and replication lag to determine synchronization for cutover. ([source](https://docs.pgdog.dev/features/sharding/resharding/move/))
- [Database Query Monitors](https://awesome-repositories.com/f/system-administration-monitoring/database-query-monitors.md) — Tracks database queries in real-time to identify and diagnose performance bottlenecks. ([source](https://docs.pgdog.dev/enterprise_edition/))
- [Upstream Health Monitoring](https://awesome-repositories.com/f/system-administration-monitoring/health-monitoring/instance-health-monitors/microservices-health-monitoring/upstream-health-monitoring.md) — Performs periodic health checks on backend database servers and removes unhealthy nodes from the rotation. ([source](https://docs.pgdog.dev/architecture/comparison/))

### Web Development

- [List-Based Shard Routing](https://awesome-repositories.com/f/web-development/request-routing/list-based-shard-routing.md) — Directs queries to specific shards based on a defined mapping of column values to shard identifiers. ([source](https://docs.pgdog.dev/features/sharding/sharding-functions/))
- [Cross-Shard Query Broadcasting](https://awesome-repositories.com/f/web-development/request-routing/shard-routing/cross-shard-query-broadcasting.md) — Forwards a single request to every available shard to query replicated reference tables. ([source](https://docs.pgdog.dev/configuration/pgdog.toml/sharded_schemas/))
- [Database Connectivity Drivers](https://awesome-repositories.com/f/web-development/database-connectivity-drivers.md) — Maintains compatibility with standard language-specific database drivers for seamless application integration. ([source](https://docs.pgdog.dev/client-drivers/))

### Development Tools & Productivity

- [Real-Time Runtime Updates](https://awesome-repositories.com/f/development-tools-productivity/configuration-updates/real-time-runtime-updates.md) — Supports reloading system settings without restarting the process to ensure zero-downtime configuration updates. ([source](https://docs.pgdog.dev/configuration/))

### Security & Cryptography

- [Connection Authentication Mechanisms](https://awesome-repositories.com/f/security-cryptography/connection-authentication-mechanisms.md) — Verifies client identities using standard authentication mechanisms to secure access to the proxy. ([source](https://docs.pgdog.dev/configuration/pgdog.toml/general/))
- [Application Data Isolation](https://awesome-repositories.com/f/security-cryptography/multi-tenant-isolation-layers/application-data-isolation.md) — Isolates tenant data using either physical database separation or virtual schema-based boundaries. ([source](https://docs.pgdog.dev/features/multi-tenancy/))
- [Connection Mapping](https://awesome-repositories.com/f/security-cryptography/permission-systems/permission-request-workflows/observable-request-flows/request-state-tracking/session-state-tracking/connection-mapping.md) — Tracks client state and transaction boundaries to ensure consistent connection mapping across shards.
- [Session Parameter Persistence](https://awesome-repositories.com/f/security-cryptography/session-persistence-strategies/client-session-persistence/session-parameter-persistence.md) — Allocates dedicated server connections per client to maintain session-level variables and notifications. ([source](https://docs.pgdog.dev/features/session-mode/))
- [User-Based Access Restrictions](https://awesome-repositories.com/f/security-cryptography/user-access-management/user-based-access-restrictions.md) — Validates user access via password-based credentials or cloud-native identity services. ([source](https://cdn.jsdelivr.net/gh/pgdogdev/pgdog@main/README.md))

### Part of an Awesome List

- [Database Systems](https://awesome-repositories.com/f/awesome-lists/data/database-systems.md) — PostgreSQL proxy for connection pooling and sharding.