Un cache de lignes
dans PostgreSQL.

Lisez les lignes par clé primaire avec RESP MGET authentifié. Les écritures PostgreSQL invalident automatiquement les entrées de cache concernées.

API RESP authentifiée · PostgreSQL 14–18 · Open source

La version 3.1.0 utilise une capacité en octets pouvant contenir des millions de petites clés si le budget le permet. Elle ajoute des verrous partitionnés, des hits mono-clé sans allocation, un suivi des écritures moins coûteux et le report des misses pendant les verrous de relation. Guide de mise à niveau.

3.1.0 · build final c431bcc

210krequêtes/s · RESP MGET

Par cœur physique du serveur épinglé
clés chaudes · 256 clients · Go/pgx

Valkey · io-threads=2N
91.5k req/s
SQL préparé
23.2k req/s
VM privées en 10 GbE · Xeon Gold 6354 · épinglé à un cœur physique.
Sur un cœur, Valkey io-threads=1 a atteint 180k req/s avec le moins de CPU serveur par requête.
Résultats, données brutes et conditions

Un appel. Deux chemins de lecture.

Un hit éligible renvoie la ligne stockée. Un miss ou un contournement lit la table source. Vos requêtes SELECT ordinaires gardent leur chemin actuel.

RESP2 │ lectures par clé primaire
-- Attach your table once.
SELECT local_cache.attach_table('public.items');

-- Read rows by primary key.
MGET CRUD:pglc_demo.public.items:{"id":42} CRUD:pglc_demo.public.items:{"id":7}
Le parcours de lecture RESP MGET L’application envoie RESP MGET authentifié. Un hit éligible renvoie la ligne complète stockée. Un miss ou un contournement lit la table source avec le rôle de worker configuré et renvoie la ligne via RESP. PostgreSQL Application RESP MGET Éligibilité + snapshot Trouvé Absent / ignoré Stockéeligne Sourcetable
Les deux parcours renvoient des lignes complètes via RESP. Une lecture de la table source peut remplir le cache.
Ce qu'évite un hit du cache de lignes
RESP MGET

Authentifié et limité à 1 024 clés par requête. Les lignes absentes renvoient null.

Écritures ordinaires

INSERT, UPDATE et DELETE invalident les entrées concernées.

Capacité fixe

Allouez le cache de lignes partagé au démarrage de PostgreSQL.

Validation de la génération du fence et de la charge utile

Les lectures non éligibles utilisent la table source selon les règles de visibilité de PostgreSQL.

Lancez le même test.
Avec chaque client.

Node.js et Go. SQL préparé et RESP MGET.

Un seul exécuteur utilise les mêmes clés, tailles de lots, nombres de connexions, durée et vérifications des résultats. Comparez le débit, la latence, ainsi que le CPU et la mémoire PostgreSQL sur votre machine.

Lancer la comparaison

Cette charge vous correspond-elle ?

Vous choisissez un cache ? Comparez les pages PostgreSQL, les lignes, les vues matérialisées et Redis.

À mesurer

  • Lectures répétées de lignes complètes par clé primaire.
  • Un petit ensemble chaud de lignes complètes.
  • READ COMMITTED sur un primaire inscriptible.
  • Une application capable d’utiliser RESP MGET authentifié.

Gardez le SQL ordinaire

  • Jointures, plages, agrégats ou résultats de requêtes arbitraires.
  • Tables avec RLS, partitionnées ou héritées.
  • Une base de données où vous ne pouvez pas installer d'extension native.
  • Charges de travail sans bénéfice mesuré.

Lancez une démo locale.

Clonez le dépôt et démarrez un serveur PostgreSQL éphémère avec des lignes d'exemple. Docker compile l'extension et garde la démo séparée de vos bases de données.

Git et Docker Compose sont requis
git clone https://github.com/profundium/pg_local_cache.git
cd pg_local_cache
docker compose -f examples/compose.yaml -f examples/compose.resp.yaml up --build --wait

Lisez les lignes d'exemple et vérifiez les hits du cache. Vous avez déjà cloné le dépôt ? Exécutez la dernière commande depuis sa racine. Pour un serveur existant, utilisez le guide d'installation.

L'installation sur un serveur existant nécessite un redémarrage de PostgreSQL.

Documentation

Essayer pg_local_cache localementExécutez pg_local_cache 3.1.0 dans un PostgreSQL éphémère, lisez des lignes d’exemple via RESP, observez les hits du cache, testez les mises à jour et supprimez la démo sans modifier une base existante. Installer pg_local_cache sur PostgreSQL 14–18Installez un paquet Debian ou RPM vérifié, utilisez PGXN ou PGXS, configurez preload, redémarrez PostgreSQL, puis initialisez, mettez à niveau ou désinstallez pg_local_cache. Clients RESPConnectez des clients compatibles avec Redis pour lire des lignes PostgreSQL via RESP2 MGET, avec authentification par jeton et TLS natif. Benchmarks du cache PostgreSQL, 3.1.0Résultats pg_local_cache 3.1.0 sur deux machines : lectures épinglées et complètes, écritures, lectures pendant les écritures et méthode. Référence technique de pg_local_cacheRéférence technique de pg_local_cache : lectures RESP, tables prises en charge, barrières transactionnelles, TLS, mémoire partagée, métriques et paramètres PostgreSQL. Mettre pg_local_cache à niveau vers 3.1.0Mettre pg_local_cache à niveau depuis 3.0.0 ou 2.x, vérifier les paramètres de capacité et de workers de 3.1, puis contrôler l’extension après redémarrage. Guide de décision sur la mise en cache PostgreSQLComparez le cache de pages PostgreSQL, le SQL préparé, le cache de lignes complètes, les vues matérialisées et Redis selon le travail évité par chaque chemin de lecture. Recherches PostgreSQL par clé primaire en lotsDécouvrez comment éviter les lectures N+1 par clé primaire et lire des lignes complètes par lots avec RESP MGET authentifié. Cache-aside PostgreSQL et RedisComparez le cache-aside Redis géré par l’application aux lectures RESP de pg_local_cache, notamment les courses de remplissage obsolète et l’invalidation des écritures. Cache de lignes PostgreSQL et shared_buffersComparez le cache de pages PostgreSQL au cache de lignes complètes de pg_local_cache : travail source évité, coûts du cache et charges qui doivent conserver le SQL ordinaire. Invalidation du cache PostgreSQL tenant compte des transactionsDécouvrez comment les triggers PostgreSQL établissent des barrières pour les lectures de lignes RESP lors des commits, rollbacks et remplissages concurrents du cache.

Notes pratiques sur la mise en cache PostgreSQL

Tous les articles →

Avant d'essayer

Est-ce que cela remplace shared_buffers ?

Non. PostgreSQL met en cache les pages de la base de données. Cette extension met séparément en cache des lignes complètes sérialisées par clé primaire. Consultez la comparaison des chemins de lecture.

Met-il en cache les requêtes SELECT ordinaires ?

Non. Seul RESP MGET authentifié utilise le cache de lignes partagé. Les requêtes existantes conservent leur parcours PostgreSQL normal.

Remplace-t-il Redis ?

Non. Le point de terminaison RESP2 est limité. Il n'y a ni ensemble général de commandes Redis, ni TTL, ni pub/sub, ni coordination distribuée. Comparez les chemins cache-aside PostgreSQL et Redis.

Comment vérifier les mises à jour et le rollback ?

Le guide d’invalidation explique le comportement des écritures. Le guide de mise à niveau couvre le passage de 3.0.0 à 3.1.0 ainsi que la migration antérieure depuis 2.x.