Curso de PL/v8

Revisar requisitos de PL/v8 para la versión de PostgreSQL utilizada.

Instalar PL/v8 desde paquetes, build propio o imagen Docker preparada.

Verificar que la extensión está disponible en el servidor PostgreSQL.

Ejecutar `CREATE EXTENSION plv8` en una base de datos de laboratorio.

Confirmar que el lenguaje `plv8` aparece correctamente en los catálogos de PostgreSQL.

Crear roles, esquemas, tablas y datos de prueba para trabajar de forma segura.

Preparar scripts reproducibles de inicialización, validación y limpieza.

Diagnosticar errores de instalación, librerías, permisos, versiones de PostgreSQL o paquetes ausentes.

Documentar la matriz de compatibilidad entre PostgreSQL, PL/v8, sistema operativo y entorno cloud.

Realizar ejercicio de entorno PostgreSQL + PL/v8 totalmente reproducible.

Repasar JavaScript aplicado a funciones de base de datos.

Trabajar con `const`, `let`, funciones, objetos, arrays, strings, números, booleanos y fechas.

Usar métodos de array como `map`, `filter`, `reduce`, `find`, `some`, `every` y `flatMap` con criterio.

Gestionar `null`, `undefined`, valores falsy y equivalencias con `NULL` de PostgreSQL.

Crear validaciones defensivas frente a entradas inesperadas.

Usar `try/catch` para controlar errores y devolver mensajes comprensibles.

Evitar patrones demasiado dinámicos que dificultan revisión por DBA o seguridad.

Escribir funciones pequeñas, explícitas y fáciles de testear.

Diferenciar código JavaScript de aplicación y código JavaScript ejecutado dentro de PostgreSQL.

Realizar ejercicio de normalización y validación con JavaScript puro orientado a PL/v8.

Crear funciones con `CREATE FUNCTION` y `LANGUAGE plv8`.

Definir argumentos, tipos de retorno, esquema, volatilidad, coste y comportamiento esperado.

Acceder a argumentos desde el cuerpo JavaScript de la función.

Devolver valores compatibles con la firma SQL declarada.

Gestionar nulos, entradas vacías, valores no válidos y errores controlados.

Crear funciones pequeñas con una única responsabilidad.

Marcar volatilidad de forma realista según dependencias internas o externas.

Evitar funciones largas que mezclan validación, consultas, transformación y auditoría.

Documentar propósito, parámetros, retorno, errores y ejemplos de llamada SQL.

Realizar ejercicio de funciones escalares PL/v8 con tipos simples y validaciones.

Comprender cómo PostgreSQL entrega tipos SQL al runtime JavaScript de PL/v8.

Trabajar con texto, enteros, numéricos, booleanos, fechas, timestamps y UUID.

Gestionar precisión numérica cuando se trabaja con importes, porcentajes o cálculos sensibles.

Tratar `NULL` de PostgreSQL de forma explícita en JavaScript.

Devolver tipos compatibles con `RETURNS text`, `integer`, `numeric`, `boolean`, `jsonb` o tipos compuestos.

Evitar conversiones implícitas difíciles de depurar.

Validar formatos antes de convertir fechas, códigos, identificadores o importes.

Documentar supuestos de tipo, rango, formato y comportamiento ante valores inválidos.

Comparar conversiones PL/v8 frente a operadores SQL nativos.

Realizar ejercicio de conversión segura entre PostgreSQL y JavaScript.

Procesar JSONB como objeto JavaScript dentro de funciones PL/v8.

Validar claves obligatorias, tipos esperados, arrays anidados y estructuras complejas.

Normalizar payloads procedentes de APIs, formularios, eventos o integraciones externas.

Extraer campos relevantes y devolver resultados estructurados.

Crear funciones para limpiar, enriquecer o transformar documentos JSONB.

Comparar operadores JSONB nativos de PostgreSQL frente a procesamiento PL/v8.

Evitar procesar grandes volúmenes JSONB fila a fila sin benchmark.

Diseñar mensajes de error claros para payloads incompletos o inválidos.

Documentar esquema esperado, reglas de transformación y criterios de aceptación.

Realizar ejercicio de validación y transformación de JSONB con PL/v8.

Recibir arrays PostgreSQL y tratarlos como arrays JavaScript.

Procesar listas de códigos, estados, etiquetas, importes, referencias o identificadores.

Gestionar arrays vacíos, nulos internos, duplicados y valores no esperados.

Devolver arrays compatibles con la firma SQL declarada.

Trabajar con tipos compuestos y resultados estructurados.

Representar filas como objetos JavaScript cuando se procesan resultados SQL.

Diseñar contratos claros para entradas y salidas complejas.

Evitar estructuras ambiguas cuando el resultado debe ser relacional.

Crear tests para arrays, objetos, composites y combinaciones de nulos.

Realizar ejercicio de deduplicación, normalización y retorno estructurado.

Crear funciones PL/v8 que devuelven múltiples filas o valores.

Diseñar funciones `RETURNS SETOF` y `RETURNS TABLE` con contratos claros.

Generar resultados tabulares desde arrays, JSONB o datos calculados.

Controlar volumen de salida para evitar consumo excesivo de memoria.

Integrar funciones set-returning con consultas, CTEs y joins.

Evitar SRFs costosas en rutas críticas sin medición.

Comparar funciones set-returning PL/v8 con SQL set-based y funciones nativas.

Documentar columnas, tipos, orden y límites de uso.

Crear pruebas para resultados vacíos, múltiples filas y errores esperados.

Realizar ejercicio de expansión de JSONB a filas relacionales.

Comprender cuándo ejecutar SQL desde una función PL/v8 está justificado.

Usar `plv8.execute` para consultas internas controladas.

Procesar resultados devueltos como arrays de objetos JavaScript.

Ejecutar consultas SELECT, INSERT, UPDATE o DELETE solo cuando la arquitectura lo permite.

Gestionar resultados vacíos, múltiples filas, rowcount y errores SQL.

Evitar consultas internas por cada fila cuando puede resolverse con SQL set-based.

Documentar dependencias de tablas, vistas, esquemas y permisos.

Separar lógica JavaScript de consultas SQL complejas para facilitar mantenimiento.

Comparar `plv8.execute` con resolver la lógica fuera de la función.

Realizar ejercicio de función PL/v8 que consulta una tabla auxiliar.

Crear planes preparados en PL/v8 cuando una consulta se ejecuta repetidamente.

Parametrizar valores para evitar SQL dinámico inseguro.

Ejecutar prepared plans con distintos argumentos.

Liberar recursos cuando los planes ya no se necesitan.

Cachear planes de forma controlada cuando la función se invoca con frecuencia.

Medir beneficio real de planes preparados frente a `plv8.execute`.

Evitar preparar la misma consulta en cada llamada sin necesidad.

Documentar tipos de parámetros, objetivo del plan y dependencias.

Crear patrón corporativo para consultas internas seguras.

Realizar ejercicio de optimización con prepared plan parametrizado.

Comprender cuándo un cursor es más adecuado que cargar todos los resultados en memoria.

Abrir cursores desde consultas internas cuando el volumen puede ser elevado.

Recorrer resultados por lotes o de forma progresiva.

Cerrar cursores correctamente para evitar fugas de recursos.

Comparar cursores frente a funciones set-returning y consultas SQL normales.

Diseñar límites de consumo para funciones que procesan muchos registros.

Evitar mantener cursores abiertos más tiempo del necesario.

Gestionar errores durante el recorrido de resultados.

Documentar casos donde se permite el uso de cursor dentro de PL/v8.

Realizar ejercicio de lectura progresiva con cursor en una función PL/v8.

Identificar riesgos de construir SQL mediante concatenación de strings.

Diferenciar valores, identificadores, fragmentos SQL y nombres de objetos.

Priorizar parámetros y prepared plans frente a SQL dinámico.

Escapar valores e identificadores con mecanismos seguros cuando el caso lo exige.

Revisar funciones existentes con riesgo de SQL injection.

Evitar usar argumentos de usuario para formar nombres de tabla o columna sin allowlist.

Crear allowlists explícitas para operaciones dinámicas autorizadas.

Documentar cuándo se permite SQL dinámico y con qué controles.

Preparar pruebas con comillas, caracteres especiales, nulos y entradas maliciosas.

Realizar ejercicio de corrección de función vulnerable.

Usar `try/catch` para capturar errores JavaScript.

Diferenciar errores de validación, conversión, SQL, permisos y programación.

Crear mensajes claros sin exponer datos sensibles.

Elevar errores cuando la operación debe abortarse.

Devolver resultados controlados cuando la función permite recuperación.

Registrar contexto mínimo: función, parámetro, tabla, operación y causa.

Evitar silenciamiento de errores que deja datos incoherentes.

Diseñar estrategia común de errores para funciones PL/v8 corporativas.

Crear tests para errores esperados, entradas inválidas y límites.

Realizar ejercicio de endurecimiento de errores y mensajes en funciones PL/v8.

Crear funciones trigger con `RETURNS trigger` y `LANGUAGE plv8`.

Diferenciar triggers `BEFORE`, `AFTER`, `INSTEAD OF`, por fila y por sentencia.

Acceder a datos de fila nueva, fila antigua y contexto del trigger.

Modificar valores antes de insertar o actualizar cuando procede.

Rechazar operaciones que incumplen validaciones críticas.

Diseñar triggers que devuelven correctamente la fila esperada.

Evitar triggers con lógica pesada en tablas de alta escritura.

Documentar tablas, columnas, efectos y dependencias de cada trigger.

Probar triggers con INSERT, UPDATE, DELETE, rollback y cargas masivas.

Realizar ejercicio de trigger PL/v8 para normalización y validación.

Crear triggers `AFTER` para registrar cambios relevantes.

Guardar auditoría con usuario, operación, timestamp, tabla, clave y diferencias.

Comparar valores anteriores y nuevos para detectar cambios significativos.

Evitar auditar datos personales, secretos o payloads completos sin necesidad.

Diseñar auditoría eficiente para tablas críticas.

Crear triggers reutilizables con argumentos o configuración por tabla.

Preparar mecanismos de bypass controlado para cargas autorizadas.

Medir impacto de auditoría en INSERT, UPDATE y DELETE.

Documentar política de retención y consulta de auditoría.

Realizar ejercicio de auditoría avanzada con PL/v8.

Validar emails, códigos, identificadores, referencias, estados y campos obligatorios.

Normalizar textos, mayúsculas, espacios, acentos, caracteres invisibles y formatos.

Aplicar reglas deterministas sobre datos antes de insertarlos o actualizarlos.

Crear funciones reutilizables para calidad de datos.

Distinguir validación técnica, validación funcional y validación de compliance.

Evitar reglas de negocio extensas que deberían vivir en servicios externos.

Documentar cada regla con ejemplos válidos e inválidos.

Preparar tests de regresión para cambios de reglas.

Medir impacto de reglas ejecutadas por trigger.

Realizar ejercicio de validación y normalización de datos maestros.

Usar PL/v8 en bases PostgreSQL con uso intensivo de JSONB.

Crear funciones para validar documentos con estructura flexible.

Enriquecer documentos JSONB con campos calculados.

Crear transformaciones entre versiones de esquema JSON.

Preparar funciones de compatibilidad para payloads antiguos y nuevos.

Comparar enfoque PL/v8 frente a validación en API Node.js.

Evitar convertir PostgreSQL en una base documental sin modelo ni restricciones.

Medir coste de procesar documentos grandes dentro de consultas.

Documentar versiones de esquema, transformaciones y reglas de negocio.

Realizar ejercicio de migración de documento JSONB entre versiones.

Situar PL/v8 dentro de arquitecturas donde la aplicación backend ya usa JavaScript o TypeScript.

Compartir criterios de validación entre backend y base de datos sin duplicar lógica sin control.

Evaluar si una validación debe ejecutarse en API, base de datos o ambos niveles.

Evitar copiar librerías de aplicación dentro de PL/v8 sin revisar compatibilidad.

Crear contratos claros entre API, payload JSONB y funciones PL/v8.

Diseñar estrategia de pruebas compartidas para datos críticos.

Documentar qué lógica vive en aplicación y qué lógica vive en PostgreSQL.

Evitar llamadas externas desde PL/v8 a servicios de aplicación.

Crear patrón de outbox cuando la base debe disparar trabajo externo.

Realizar ejercicio de diseño de flujo API + PostgreSQL + PL/v8.

Definir quién puede crear, modificar y ejecutar funciones PL/v8.

Separar permisos de desarrollo, despliegue, ejecución y administración.

Revisar riesgos de funciones `SECURITY DEFINER`.

Fijar `search_path` seguro en funciones privilegiadas.

Evitar que una función PL/v8 exponga datos que el usuario no debería consultar.

Controlar acceso a tablas mediante roles, esquemas y grants mínimos.

Revisar funciones que ejecutan SQL interno con privilegios elevados.

Crear checklist de seguridad antes de producción.

Auditar owners, grants, dependencias y datos tratados.

Realizar ejercicio de hardening de una función PL/v8 con permisos elevados.

Comprender el modelo de ejecución de JavaScript dentro de PL/v8.

Diferenciar JavaScript en navegador, Node.js y V8 embebido en PostgreSQL.

Revisar qué APIs de Node.js no están disponibles dentro de PL/v8.

Entender límites sobre IO, red, módulos externos y entorno de ejecución.

Analizar qué significa que PL/v8 esté planteado como lenguaje trusted.

Revisar riesgos de funciones que consumen CPU o memoria excesiva.

Crear límites internos de complejidad y volumen para funciones PL/v8.

Evitar asumir que cualquier código JavaScript de backend puede ejecutarse sin cambios.

Documentar diferencias entre runtime PL/v8 y entorno Node.js corporativo.

Realizar ejercicio de adaptación de lógica JavaScript externa a PL/v8 seguro.

Medir impacto de funciones PL/v8 dentro de consultas SQL reales.

Usar `EXPLAIN` y `EXPLAIN ANALYZE` para revisar coste y planes de ejecución.

Comparar rendimiento de SQL nativo, PL/pgSQL, PL/v8 y lógica externa.

Evitar funciones llamadas por fila sobre tablas grandes sin benchmark.

Revisar volatilidad, coste declarado y efecto sobre el optimizador.

Reducir procesamiento JavaScript cuando PostgreSQL puede resolverlo de forma set-based.

Detectar cuellos de botella: JSONB grande, bucles, regex, SPI repetitivo y triggers pesados.

Medir latencia, CPU, memoria y locks asociados.

Crear benchmarks reproducibles con datos representativos.

Realizar ejercicio de optimización de función PL/v8 lenta.

Comprender el ciclo de vida del runtime PL/v8 dentro de sesiones PostgreSQL.

Revisar impacto de variables globales, closures, inicialización y cachés.

Evitar estado persistente que produzca resultados impredecibles.

Gestionar estructuras de datos grandes sin cargar más de lo necesario.

Medir uso de memoria cuando se procesan arrays o documentos JSONB extensos.

Evitar dependencias de orden de ejecución o estado residual.

Probar funciones con sesiones concurrentes y distintos roles.

Diseñar funciones idempotentes y reentrantes.

Documentar cualquier uso de caché interna o variables persistentes.

Realizar ejercicio de diagnóstico de consumo de memoria en PL/v8.

Comprender que PL/v8 se ejecuta dentro de la transacción PostgreSQL que invoca la función.

Analizar impacto de errores JavaScript sobre rollback de la operación.

Evitar lógica lenta dentro de triggers o transacciones críticas.

Diseñar operaciones internas con orden estable para reducir deadlocks.

Evitar llamadas SQL internas que bloquean tablas innecesariamente.

Crear pruebas concurrentes para funciones y triggers críticos.

Medir bloqueos causados por auditoría, validación o enriquecimiento.

Documentar comportamiento transaccional esperado.

Crear estrategias de rollback, reintento y recuperación.

Realizar ejercicio de análisis de bloqueo provocado por trigger PL/v8.

Crear tests SQL para funciones PL/v8 con entradas y salidas esperadas.

Probar nulos, strings vacíos, arrays, JSONB, tipos compuestos, errores y límites.

Probar triggers con INSERT, UPDATE, DELETE, rollback y cargas masivas.

Crear datasets reproducibles para validación funcional y de rendimiento.

Comparar resultados con implementación SQL, PL/pgSQL o JavaScript externo.

Automatizar tests mediante scripts SQL, pgTAP, contenedores o pipeline propio.

Evitar desplegar funciones PL/v8 sin pruebas de regresión.

Crear pruebas específicas de permisos y funciones `SECURITY DEFINER`.

Medir cobertura de reglas críticas y casos límite.

Realizar ejercicio de suite de tests para funciones y triggers PL/v8.

Organizar funciones PL/v8 en archivos SQL versionados.

Usar herramientas como Flyway, Liquibase, Sqitch o migraciones propias.

Gestionar cambios de firma, tipo de retorno, permisos, triggers y dependencias.

Crear scripts reversibles cuando el cambio lo permite.

Evitar editar funciones manualmente en producción sin trazabilidad.

Documentar versión de PostgreSQL, PL/v8, sistema operativo y supuestos técnicos.

Crear release notes para funciones y triggers críticos.

Preparar despliegues por entornos: desarrollo, test, staging y producción.

Coordinar revisión con DBA, backend, seguridad y arquitectura.

Realizar ejercicio de migración versionada de funciones PL/v8.

Crear contenedor PostgreSQL con PL/v8 disponible.

Levantar base, extensión, esquemas, datos y funciones con Docker Compose.

Ejecutar scripts de migración en entornos limpios.

Ejecutar tests automáticos en pipeline CI/CD.

Validar disponibilidad de `plv8` antes de aplicar funciones.

Separar configuración de desarrollo, test y producción.

Gestionar secretos sin incrustarlos en funciones ni scripts.

Publicar reportes de tests, logs de migración y documentación técnica.

Evitar dependencias manuales difíciles de reproducir.

Realizar ejercicio de pipeline local para PL/v8 con tests automáticos.

Registrar errores, tiempos y frecuencia de funciones PL/v8 críticas.

Medir impacto de funciones en consultas lentas y escrituras.

Integrar logs PostgreSQL con herramientas corporativas de observabilidad.

Crear auditoría específica para triggers críticos.

Relacionar función, tabla, trigger, owner, proceso y criticidad.

Evitar logs con datos personales, secretos o payloads innecesarios.

Crear runbooks para errores de extensión, permisos, JSONB, triggers y rendimiento.

Revisar periódicamente funciones sin uso o con coste elevado.

Crear alertas ante incremento de errores o degradación de escritura.

Realizar ejercicio de diagnóstico operativo de incidencia PL/v8.

Crear inventario de funciones, triggers, esquemas, owners y permisos.

Identificar tablas críticas afectadas por lógica PL/v8.

Analizar dependencias entre funciones, vistas, triggers, APIs y jobs externos.

Revisar uso real mediante logs, catálogos y consultas de actividad.

Clasificar funciones por criticidad, riesgo, complejidad y posibilidad de migración.

Detectar funciones huérfanas, duplicadas, sin owner o sin documentación.

Crear matriz de decisión: mantener, refactorizar, migrar, retirar o aislar.

Preparar informe técnico para DBA, arquitectura y responsables de aplicación.

Priorizar quick wins frente a migraciones complejas.

Realizar ejercicio de auditoría completa de esquema con PL/v8 heredado.

Identificar funciones candidatas a PL/pgSQL por ser lógica SQL simple.

Migrar validaciones complejas a PL/Python o PL/Rust cuando aporta valor.

Mover lógica de negocio extensa a servicios Node.js, jobs o APIs.

Sustituir triggers por constraints, generated columns, reglas SQL o pipelines cuando procede.

Crear pruebas de equivalencia antes de migrar.

Diseñar migración por fases: inventario, cobertura, ejecución paralela, corte y retirada.

Evitar reescrituras sin entender comportamiento real de producción.

Documentar diferencias funcionales y riesgos aceptados.

Preparar rollback por función migrada.

Realizar ejercicio de migración de función PL/v8 a PL/pgSQL o servicio Node.js externo.

Definir si PL/v8 se permite para nuevo desarrollo, mantenimiento o solo sistemas heredados.

Crear estándar de naming, estructura, documentación, errores, SPI, triggers y JSONB.

Establecer owners técnicos y funcionales para cada función.

Clasificar funciones por criticidad, datos tratados, frecuencia de uso y riesgo.

Definir proceso de revisión con DBA, seguridad, backend y arquitectura.

Crear catálogo corporativo de funciones PL/v8.

Revisar periódicamente permisos, `SECURITY DEFINER`, SQL dinámico y triggers críticos.

Establecer criterios de retirada o sustitución por tecnologías más adecuadas.

Evitar crecimiento descontrolado de lógica JavaScript dentro de PostgreSQL.

Realizar ejercicio de política corporativa para PL/v8.

Evaluar validaciones simples que podrían resolverse con constraints, domains o PL/pgSQL.

Analizar parsing JSONB donde JavaScript resulta expresivo y mantenible.

Revisar triggers de auditoría y alternativas nativas.

Evaluar normalización de datos maestros y limpieza de formatos.

Desaconsejar llamadas externas desde funciones de base de datos.

Desaconsejar lógica de negocio extensa dentro de triggers.

Identificar casos donde PL/pgSQL, PL/Python o PL/Rust serían más defendibles.

Crear matriz de riesgo por caso de uso.

Documentar criterios de decisión para nuevos desarrollos.

Realizar ejercicio de clasificación de casos viables, dudosos y descartables.

Recibir una base PostgreSQL de laboratorio con funciones PL/v8, triggers, tablas y datos JSONB.

Crear entorno reproducible con Docker, PostgreSQL, PL/v8, esquemas, datos y scripts de migración.

Habilitar `plv8` y documentar instalación, permisos, compatibilidad y validación inicial.

Crear inventario de funciones, triggers, owners, permisos, tablas afectadas y dependencias.

Implementar función escalar PL/v8 para normalización de texto, códigos o identificadores.

Implementar función con nulos, validaciones, errores controlados y retornos tipados.

Implementar función sobre JSONB para validar payloads, extraer campos y normalizar estructura.

Implementar función set-returning para convertir arrays o JSONB en filas relacionales.

Crear función con `plv8.execute` para consultar una tabla auxiliar de reglas.

Optimizar consulta interna usando prepared plans y parámetros seguros.

Corregir una función vulnerable sustituyendo SQL dinámico inseguro por parametrización o allowlist.

Implementar trigger `BEFORE` para validación y normalización de datos.

Implementar trigger `AFTER` para auditoría controlada de cambios relevantes.

Añadir manejo robusto de errores con `try/catch` y mensajes claros.

Medir rendimiento con `EXPLAIN ANALYZE` y detectar puntos de mejora.

Crear tests SQL de funciones, triggers, JSONB, nulos, errores esperados y permisos.

Preparar scripts de migración, actualización, rollback y retirada de funciones.

Crear pipeline local con Docker para ejecutar migraciones y tests automáticamente.

Documentar arquitectura, funciones, permisos, riesgos, runbook, troubleshooting y política de gobierno.

Presentar la solución final defendiendo seguridad, rendimiento, trazabilidad, mantenibilidad y estrategia de modernización.