For a cache layer in front of my database, the first results are readysettech/readyset (Readyset is a transparent caching proxy for PostgreSQL and MySQL that intercepts SQL queries and serves cached results from memory without requiring application changes, fitting the requirement for a database caching proxy with minimal latency improvement), sysown/proxysql (ProxySQL is a transparent database proxy that sits between applications and MySQL/PostgreSQL, with built-in query result caching, connection pooling, and automatic failover — exactly the kind of SQL cache proxy that reduces database load without requiring application changes) and doctrine/doctrinebundle (DoctrineBundle is a Symfony integration for Doctrine ORM and DBAL, not a standalone caching proxy; it supports query result caching at the application layer, but does not act as a transparent proxy between an app and a database). alibaba/druid and swoft-cloud/swoft round out the shortlist. Compare the match explanations and check the project documentation against your requirements.
High-performance proxy solutions that reduce database load by caching frequent queries and accelerating data retrieval.
Readyset is a transparent caching proxy for PostgreSQL and MySQL that sits between an application and its database, intercepting SQL queries and serving cached results from memory. It automatically caches query results on first execution and keeps those caches consistent by consuming the database’s replication stream in real time, enabling faster repeated reads without application code changes. The proxy also supports caching advanced SQL functions such as window functions, bucket functions, and locale-aware collation sorting, and exposes an interface that allows AI agents to inspect proxied q
Readyset is a transparent caching proxy for PostgreSQL and MySQL that intercepts SQL queries and serves cached results from memory without requiring application changes, fitting the requirement for a database caching proxy with minimal latency improvement.
ProxySQL is a database proxy designed to route and balance traffic between applications and MySQL or PostgreSQL servers. It provides database high availability by monitoring backend server health and automatically rerouting traffic to healthy nodes during failover events to prevent downtime. The system integrates with generative AI models by proxying requests through a protocol handler, creating a bridge that allows large language models to access structured data. The project includes capabilities for traffic management through automatic failover routing and cluster topology discovery. It op
ProxySQL is a transparent database proxy that sits between applications and MySQL/PostgreSQL, with built-in query result caching, connection pooling, and automatic failover — exactly the kind of SQL cache proxy that reduces database load without requiring application changes.
DoctrineBundle is a Symfony integration that configures and manages the Doctrine Object Relational Mapper and Database Abstraction Layer. It provides the fundamental tools required to map application objects to relational database tables and execute raw queries through a consistent programmatic interface. The project includes a database schema manager with command-line tools for synchronizing database structures with entity mappings and executing migrations. It also provides a database query debugger and activity debugging tools to track performance and execution details via a web-based inter
DoctrineBundle is a Symfony integration for Doctrine ORM and DBAL, not a standalone caching proxy; it supports query result caching at the application layer, but does not act as a transparent proxy between an app and a database.
Druid is a database connection management and monitoring framework designed to maintain persistent, high-performance links between applications and relational databases. It functions as a resource manager that automates the lifecycle of connection pools, reducing the overhead associated with repeatedly opening and closing network connections. The project distinguishes itself through an integrated query analysis engine that decomposes database statements into structured components. This capability enables real-time security auditing, syntax validation, and metadata extraction, allowing for the
Druid is a connection-pool management and SQL-analysis framework for databases, but it does not cache query results or act as a transparent proxy—it manages connections and monitors queries, not the caching layer the visitor needs.
Swoft is a high-performance PHP microservice framework designed to handle concurrent network traffic and asynchronous tasks using coroutines. It provides a foundation for building scalable backend services through a coroutine-driven runtime and high-performance servers supporting HTTP, WebSocket, RPC, and TCP protocols. The framework distinguishes itself through a set of governance and optimization tools, including a distributed service coordination system for registration, discovery, and circuit breaking. It also features a connection pool manager for reusable database and network sockets an
Swoft is a PHP microservice framework with connection pooling and asynchronous capabilities, but it is not a transparent caching proxy for databases — it would require custom development to act as a drop-in query cache between an application and a database.
This project is a pure JavaScript database driver for Node.js that implements the native MySQL binary protocol. It serves as a comprehensive connector for managing persistent network links to MySQL servers, enabling applications to execute queries, manage transactions, and handle complex data operations without requiring external middleware. The driver distinguishes itself through its integrated support for connection pooling and distributed database routing. It maintains managed sets of reusable network sockets to optimize resource usage under high request volumes, while simultaneously provi
This is a MySQL database driver and connector for Node.js, not a caching proxy — it connects an application directly to a database rather than sitting in between as a transparent cache layer, though its connection pooling is a feature you would need in a proxy.
HikariCP is a high-concurrency JDBC connection pooling library for Java applications. It provides a reusable set of database connections to reduce the overhead of creating new connections for every request, enabling low-latency database access for applications handling large volumes of simultaneous requests. The project utilizes lock-free connection pooling and non-blocking data structures to ensure high performance. It includes specialized optimizations such as bytecode-optimized statement caching on the driver side to reduce SQL parsing overhead and proxy-based connection wrapping to track
HikariCP is a high-performance JDBC connection pool library that reduces connection-creation overhead, but it is not a transparent caching proxy—it does not cache query results, support TTL-based expiration, or sit as an intermediary between an application and a database to serve cached responses.
This project is a MySQL database driver and client for Node.js. It provides a JavaScript implementation of the MySQL protocol to facilitate connecting to, querying, and managing data within MySQL databases. The driver includes a connection pool manager to maintain a cache of reusable database connections, reducing the overhead of frequent network handshakes. It also supports row-by-row result streaming to process large datasets without loading entire result sets into memory. Core capabilities cover SQL query execution, the management of database transactions, and the coordination of multiple
This is a MySQL database driver and client for Node.js with connection pooling, not a transparent caching proxy; it connects to and queries MySQL but does not cache results or sit between an application and a database as a proxy.
redis-py is a Python client library for interacting with Redis databases to execute commands and manage key-value data. It serves as a driver for programmatic data manipulation, providing interfaces for Redis command execution and key-value storage. The project includes a dedicated cluster client that handles topology discovery, slot mapping, and request routing across distributed nodes. It further supports high availability through active-active deployment coordination, utilizing health checks and failure detection to trigger automatic failover between instances. The library incorporates ne
redis-py is a Redis client library, not a transparent caching proxy that sits between an application and a database—it's a tool for interacting with Redis directly, not an interceptor that caches SQL queries.
PostgREST is a standalone server process that automatically transforms a relational database schema into a fully functional RESTful API. By querying system catalogs at startup, it maps tables, views, and stored procedures into standardized web endpoints, allowing developers to build backend services by focusing exclusively on database design. The service functions as a declarative engine that translates HTTP requests and query parameters directly into native SQL operations. It maintains stateless request processing and integrates connection pooling to manage high-frequency interactions effici
PostgREST is an automatic REST API generator for PostgreSQL databases, not a transparent caching proxy—it does not cache query results or sit between an application and a database; it exposes the database directly via HTTP.
redis-py is a Python client library for executing Redis commands and managing in-memory data structures. It provides the necessary components to integrate Python applications with Redis for data storage and retrieval. The project includes a cluster client for monitoring health and managing automatic failover across multiple active-active database replicas. It also features a connection pool manager to maintain reusable socket connections and a dedicated pub/sub client for subscribing to real-time message channels. The library covers broad capability areas including performance optimization t
redis-py is a Python client library for Redis, not a transparent caching proxy that sits between an application and a database — it only provides the means to talk to Redis rather than intercepting and caching SQL queries.
GORM is a developer-focused object-relational mapping library for Go that provides a comprehensive data persistence framework. It serves as a database access layer, allowing developers to map application structures to database tables and perform CRUD operations using a fluent, type-safe query builder instead of writing raw SQL. The library distinguishes itself through its association-aware persistence, which automatically tracks and synchronizes complex entity relationships during database operations. It utilizes a driver-agnostic interface to maintain consistent behavior across various stora
GORM is an ORM library for Go that simplifies database interactions through object mapping, but it is not a transparent caching proxy — it does not cache query results or sit between an application and a database to reduce latency.
| Repository | Stars | Language | License | Last push |
|---|---|---|---|---|
| readysettech/readyset | 5.2K | Rust | other | |
| sysown/proxysql | 6.8K | C++ | GPL-3.0 | |
| doctrine/doctrinebundle | 4.8K | PHP | MIT | |
| alibaba/druid | 28.2K | Java | apache-2.0 | |
| swoft-cloud/swoft | 5.5K | PHP | Apache-2.0 | |
| felixge/node-mysql | 18.6K | JavaScript | MIT | |
| brettwooldridge/hikaricp | 21.1K | Java | Apache-2.0 | |
| mysqljs/mysql | 18.6K | JavaScript | MIT | |
| redis/redis-py | 13.6K | Python | MIT | |
| postgrest/postgrest | 27.2K | Haskell | MIT |