GuíaAvanzado
Guía de PostgreSQL Avanzado para Backend
Saca a PostgreSQL del modo "tabla relacional con índices" y úsalo a fondo como motor de aplicaciones backend serias. Esta guía cubre los features avanzados que el dev senior necesita cuando el motor estándar se queda corto: JSONB profundo con operadores y GIN indexes, full-text search en español como reemplazo viable de Elasticsearch, partitioning nativo para tablas masivas (>10M filas), materialized views para construir analytics in-DB, advisory locks que reemplazan a Redis para coordinación distribuida, savepoints para nested transactions con SQLAlchemy, extensiones útiles (`pg_trgm`, `citext`, `uuid-ossp`, `hstore`) con decision matrix de cuándo usar cada una, y CTEs recursivas para jerarquías (categorías anidadas, org charts) y grafos. Cierra el sub-track Data Layer del path Backend Python con un proyecto final integrador: refactorizar el Blog API con todos los features y medir con benchmarks.
- 64
- lecciones
- 8
- módulos
- Inglés · Español
- disponible en
- Sí
- certificado
- Gratis
- acceso
Resultados
Lo que vas a poder hacer
- Usar JSONB a profundidad: operadores (`->`, `->>`, `@>`, `?`, `#>`), JSON Path queries, GIN indexes (`jsonb_ops` vs `jsonb_path_ops`), partial e expression indexes
- Traducir patterns JSONB de forma idiomática a SQLAlchemy 2.0: `Mapped[dict]`, `func.jsonb_extract_path_text`, `MutableDict`, updates parciales con `jsonb_set`
- Implementar full-text search en español con `tsvector`/`tsquery`, ranking con `ts_rank_cd`, diccionarios multilingual y `unaccent` para búsqueda sin acentos
- Combinar FTS con `pg_trgm` para fuzzy matching, autocomplete y typo tolerance — y decidir conscientemente cuándo PostgreSQL FTS reemplaza Elasticsearch
- Particionar tablas masivas (>10M filas) con range/list/hash, aprovechar partition pruning y automatizar mantenimiento con `pg_partman`
- Construir analytics in-DB con materialized views, refresh `CONCURRENTLY`, indexes en MVs y refresh strategies (cron, app-driven, trigger-driven)
- Reemplazar Redis para distributed locks con `pg_advisory_lock` / `pg_try_advisory_lock` (session vs transaction-level) — y saber cuándo Redis sigue siendo mejor opción
- Manejar nested transactions con savepoints y `session.begin_nested()` para batch processing donde fallos parciales no destruyen toda la transacción
- Elegir entre extensiones: `pg_trgm` vs FTS, `citext` vs `LOWER`, `uuid-ossp` vs `gen_random_uuid` (PG 13+), `hstore` vs JSONB
- Escribir CTEs recursivas (`WITH RECURSIVE`) para jerarquías (categorías anidadas, org charts), grafos y breadcrumbs
Antes de empezar
Qué necesitas traer
Es para ti si...
- Backend Python devs senior con apps FastAPI en producción donde el motor PostgreSQL "estándar" se queda corto
- Devs evaluando agregar Elasticsearch al stack solo para búsqueda — y quieren verificar primero si PostgreSQL FTS alcanza
- Equipos con tablas masivas (>10M filas) decidiendo entre partitioning, sharding o migración a un motor OLTP especializado
- Devs construyendo dashboards y analytics in-DB que necesitan materialized views bien diseñadas
- Devs usando Redis solo para distributed locks que quieren simplificar el stack
- Senior devs preparándose para entrevistas técnicas donde se pregunta "¿cuándo JSONB vs MongoDB?", "¿cómo escalar una tabla de 100M filas?" o "¿cómo implementarías búsqueda?"
Requisitos y materiales
- Guía PostgreSQL & SQLAlchemy completada (o equivalente: SQL, ACID, B-tree indexes, EXPLAIN básico, SQLAlchemy ORM con relationships, Alembic)
- Guía Database Performance & Query Tuning completada (o equivalente: EXPLAIN profundo, indexing avanzado, N+1, profiling, pooling)
- Guía SQL Patterns for Production APIs completada (o equivalente: cursor pagination, soft deletes, audit logs, multitenancy con RLS, zero-downtime migrations)
- App FastAPI funcional con SQLAlchemy 2.0 async y datos reales
- PostgreSQL 14+ instalado local o en Docker (16+ recomendado para algunos features)
Contenido
El temario, módulo por módulo
Abre cualquiera para ver sus lecciones.
- Introducción: JSONB Operators e Indexing
- JSONB vs JSON vs TEXT: el modelo mental antes de los operadores
- Operadores JSONB fundamentales: acceso, búsqueda y manipulación
- JSONB Path queries: la sintaxis para lo que los operadores básicos no expresan
- GIN indexes en JSONB: la decisión más importante del módulo
- Queries complejos: filtros, JOINs y agregaciones sobre JSONB
- JSONB Anti-Patterns: cuándo NO usar JSONB y cómo detectarlo
- Proyecto del módulo: replicar el caso 4s → 12ms con 5M filas propias
- Módulo 2: JSONB con SQLAlchemy y patterns de uso
- `Mapped[dict]` y tipos JSONB en SQLAlchemy 2.0
- Mutaciones y `MutableDict`: el gotcha que pierde tus cambios silenciosamente
- Validación con Pydantic v2 y JSONB: el JSONB tipado
- Pattern: configuración dinámica con JSONB
- Pattern: metadata extensible con JSONB
- Pattern: datos polimórficos con JSONB y discriminated unions
- Proyecto del módulo: extender el Blog API con `posts.metadata` JSONB
- Módulo 3: Full-Text Search + pg_trgm — buscador de calidad sin Elasticsearch
- `tsvector` y `tsquery`: los dos tipos que hacen posible FTS
- FTS multilingual: diccionario `spanish` y `unaccent`
- GIN indexes para FTS y columnas generadas: el salto de Seq Scan a Bitmap Index Scan
- Ranking con `ts_rank` y `ts_rank_cd`: ordenar por relevancia, no por fecha
- `pg_trgm`: fuzzy search, similarity y autocomplete sin Elasticsearch
- FTS vs Elasticsearch: cuándo PostgreSQL basta y cuándo no
- Proyecto del módulo: buscador del blog en español
- Módulo 4: Partitioning Nativo en PostgreSQL
- Cuándo particionar y cuándo no: el decision matrix antes de la sintaxis
- Range partitioning por fecha: el caso del 80%
- List partitioning por categoría/tenant: el caso multi-tenant SaaS
- Hash partitioning para distribución uniforme: el tercer tipo
- Partition pruning y constraint exclusion: cómo verificar que el planner hace su trabajo
- `pg_partman` y mantenimiento automatizado: la pieza operacional que hace partitioning sustentable
- Proyecto del módulo: particionar `events` con 50M filas y migración zero-downtime
- Módulo 5 — Materialized Views: dashboards y reportes que vuelan sin agregar otro servicio al stack
- Views vs materialized views: cuándo cada una
- Creación y refresh: fundamentos para tu primera MV ejecutable
- Refresh `CONCURRENTLY` vs `FULL`: el trade-off de locking que define producción
- Indexes en materialized views: la MV es una tabla, indexala como tal
- Casos analíticos: dashboards y reportes con materialized views
- MVs vs cache de aplicación (Redis): decision matrix con criterios cuantitativos
- Entrega del módulo 5: dashboard de blog con materialized views
- Módulo 6: Advisory Locks + Savepoints
- Advisory locks: el patrón básico
- Session-level vs transaction-level: la decisión central
- Pattern desde SQLAlchemy con context manager
- Decision matrix: advisory locks vs Redis vs ZooKeeper/etcd
- Savepoints: rollback parcial dentro de una transaction
- Pattern combinado: advisory lock + savepoints
- Mini-proyecto: job runner completo con benchmarks
- Módulo 7: Extensiones Útiles
- Instalación de extensiones + gotchas con cloud providers
- `citext` vs `LOWER()`: case-insensitive text
- UUIDs: `gen_random_uuid()` vs `uuid-ossp`
- `hstore` vs JSONB: por qué JSONB casi siempre gana
- `pg_trgm` casos avanzados: deduplicación, "did you mean"
- Extensiones grandes (mención): `pgcrypto`, `postgis`, `pgvector`
- Mini-proyecto: refactor de sistema de usuarios con extensiones
- Módulo 8: CTEs Recursivas + Proyecto Final
- CTEs recursivas: anatomía y caso simple
- 3 patterns canónicos: descendente, ascendente, path concatenado
- `CYCLE` clause y grafos: evitar loops infinitos
- Closure table: alternativa cuando CTE recursiva no alcanza
- Proyecto final — fase 1: setup, baseline, 3 componentes (JSONB, FTS, MV)
- Proyecto final — fase 2: partitioning, advisory lock, recursive categories
- Documentación final + cierre de la guía
Dónde encaja
Esta guía es parte de algo más grande
Se estudia dentro de estos programas, con acompañamiento y fechas.
Dudas frecuentes
Lo que suele preguntarse
Sin límite. Es una guía gratuita: entras cuando quieras, las veces que quieras.
No. Los módulos están ordenados de menos a más, pero puedes saltar al que necesites. Tu progreso se guarda por lección.
Lo que haga falta está en «Qué necesitas traer», arriba. Si no aparece nada ahí, puedes empezar desde cero.
En el grupo de WhatsApp del Club, y cada quince días hay un live con un instructor donde se resuelven dudas en vivo.
Sí. Al terminar todas las lecciones se emite automáticamente, con un código verificable que puedes compartir en LinkedIn.
No. Esta guía es autoguiada y sin fechas. El bootcamp es en vivo, por cohorte, con entregas que alguien revisa.
Empieza cuando quieras
Lo que dicen los estudiantes
Estas reseñas son de estudiantes inscritos que completaron al menos el 50% del curso. Moderamos las reseñas solo por motivos de contenido (spam, lenguaje ofensivo, datos personales), nunca por ser críticas o negativas.
Aún no hay reseñas aprobadas.
¡Sé el primero en compartir tu experiencia!