Curso de PL/Lua

Revisar disponibilidad de PL/Lua para la distribución PostgreSQL usada.

Instalar dependencias de compilación: PostgreSQL headers, `pg_config`, Lua, LuaJIT, make y toolchain C.

Compilar PL/Lua indicando rutas de Lua, librerías, compilador y versión de PostgreSQL.

Instalar la extensión en un entorno de laboratorio sin datos productivos.

Ejecutar `CREATE EXTENSION pllua` en una base de datos controlada.

Verificar disponibilidad de `pllua` y `plluau` en el catálogo de lenguajes.

Crear roles, esquemas, tablas y datos de prueba para trabajar con seguridad.

Preparar scripts reproducibles de instalación y validación.

Diagnosticar errores habituales de `pg_config`, headers, Lua, librerías compartidas y permisos.

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

Comprender la diferencia entre `pllua` trusted y `plluau` untrusted.

Revisar qué restricciones aplica el sandbox de PL/Lua trusted.

Entender por qué PL/LuaU debe reservarse para superusuarios o casos muy controlados.

Analizar acceso a módulos, librerías, entorno global, `os`, `package`, `require` y recursos externos.

Definir política corporativa sobre uso permitido de PL/Lua y PL/LuaU.

Controlar quién puede crear, modificar y ejecutar funciones en cada lenguaje.

Evaluar riesgos de funciones `SECURITY DEFINER` combinadas con PL/Lua.

Crear checklist de seguridad para funciones trusted y untrusted.

Evitar que PL/Lua se convierta en vía indirecta para saltarse permisos de aplicación.

Realizar ejercicio de clasificación de funciones por nivel de riesgo.

Repasar sintaxis Lua aplicada a funciones de base de datos.

Trabajar con variables locales, tablas, funciones, closures, metatables básicas y módulos.

Usar `if`, `elseif`, `for`, `while`, `repeat`, `pairs`, `ipairs` y patrones idiomáticos.

Diferenciar `nil`, `false`, string vacío y valores nulos procedentes de PostgreSQL.

Manipular strings, números, booleanos, tablas y funciones como valores de primera clase.

Usar `pcall`, `xpcall` y manejo de errores con criterio de base de datos.

Aplicar estilo claro, nombres comprensibles y funciones pequeñas.

Evitar abuso de globales, metaprogramación y lógica difícil de auditar.

Crear utilidades Lua reutilizables para validación, normalización y transformación.

Realizar ejercicio de Lua aplicado a limpieza y validación de datos.

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

Definir argumentos nombrados, tipos de retorno, esquema, volatilidad, coste y `STRICT`.

Entender cómo PL/Lua transforma el cuerpo SQL en una función Lua invocable.

Acceder a argumentos por nombre y devolver valores compatibles con el tipo SQL declarado.

Gestionar `nil` como valor equivalente a NULL en retornos cuando procede.

Crear funciones pequeñas con una responsabilidad clara y pruebas asociadas.

Usar closures y upvalues locales para inicialización y caché controlado.

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

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

Realizar ejercicio de funciones escalares PL/Lua con entradas nulas y tipos simples.

Comprender cómo PL/Lua convierte tipos básicos de PostgreSQL a tipos Lua.

Trabajar con booleanos, enteros, flotantes, texto, bytea y valores nulos.

Gestionar tipos no básicos como userdata con conversión, métodos o representación textual.

Tratar fechas, timestamps, intervalos y numeric con cuidado de precisión y formato.

Devolver valores compatibles con la firma SQL declarada.

Evitar conversiones implícitas difíciles de depurar.

Validar entradas antes de procesarlas para prevenir errores de runtime.

Documentar reglas de conversión, límites y supuestos.

Comparar procesamiento Lua frente a operadores nativos de PostgreSQL.

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

Recibir arrays PostgreSQL y tratarlos desde Lua como estructuras indexables.

Procesar listas de textos, números, estados, códigos y etiquetas.

Gestionar arrays vacíos, valores nulos internos y dimensiones inesperadas.

Trabajar con composite types como tablas con claves por nombre de atributo.

Devolver composites mediante tablas Lua con campos compatibles.

Crear contratos de entrada y salida para resultados estructurados.

Evitar estructuras ambiguas cuando el retorno debe ser relacional.

Documentar campos obligatorios, opcionales y calculados.

Crear tests para arrays, composites y combinaciones de nulos.

Realizar ejercicio de función PL/Lua que recibe composite y devuelve resultado estructurado.

Usar capacidades de PL/Lua para procesar JSONB dentro de PostgreSQL.

Convertir documentos JSONB en tablas Lua manejables cuando el entorno lo permite.

Validar claves obligatorias, tipos, arrays, objetos anidados y valores permitidos.

Crear funciones para normalizar payloads procedentes de APIs, formularios o eventos.

Comparar uso de PL/Lua frente a operadores JSONB nativos de PostgreSQL.

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

Crear mensajes claros para JSON inválido o incompleto.

Diseñar salidas relacionales o JSONB normalizado según el caso.

Documentar esquema esperado, errores y criterios de aceptación.

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

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

Usar `coroutine.yield` para emitir resultados progresivamente.

Entender el modo value-per-call de las SRF en PL/Lua.

Diseñar funciones tabulares para expandir arrays, JSONB o estructuras internas.

Gestionar cierre temprano de ejecución cuando la consulta usa LIMIT o se cancela.

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

Integrar SRFs con consultas, CTEs y joins.

Definir tipos de retorno claros con `RETURNS SETOF` o `RETURNS TABLE`.

Comparar SRFs PL/Lua con SQL set-based y funciones nativas.

Realizar ejercicio de función set-returning basada en datos semiestructurados.

Crear procedimientos PL/Lua cuando el objetivo es ejecutar una acción controlada.

Diferenciar funciones, procedimientos y bloques `DO LANGUAGE pllua`.

Usar procedimientos para procesos internos de mantenimiento, normalización o preparación.

Revisar cuándo un procedimiento puede gestionar transacciones en contextos no atómicos.

Diseñar procedimientos idempotentes y con logs claros.

Evitar procedimientos que modifican muchos datos sin trazabilidad.

Registrar resultados, errores, métricas y filas afectadas.

Separar procedimientos operativos de funciones usadas dentro de consultas.

Crear contratos claros sobre efectos esperados y rollback.

Realizar ejercicio de procedimiento PL/Lua para normalización controlada.

Comprender el uso de SPI para ejecutar SQL desde funciones PL/Lua.

Usar `spi.execute` para consultas y comandos internos.

Pasar argumentos de forma parametrizada a las consultas.

Procesar resultados devueltos como tablas de filas.

Distinguir resultados SELECT de rowcount en comandos que no devuelven filas.

Usar `spi.execute_count` para limitar el número de filas recuperadas.

Gestionar resultados vacíos, errores SQL y tipos inesperados.

Evitar SQL dinámico construido con concatenación insegura.

Comparar SPI interno frente a resolver la lógica mediante SQL externo.

Realizar ejercicio de función PL/Lua que consulta tablas auxiliares con SPI.

Crear planes preparados con `spi.prepare`.

Definir tipos de argumentos del plan y opciones cuando proceda.

Ejecutar statement objects con `stmt:execute` y parámetros seguros.

Usar el entorno local de la función para cachear planes preparados.

Evitar preparar el mismo plan en cada llamada si se invoca con frecuencia.

Usar `stmt:rows` para recorrer resultados de forma clara.

Documentar consultas preparadas, tipos esperados y dependencias.

Medir beneficio real de prepared statements frente a ejecución directa.

Evitar cachés globales difíciles de invalidar.

Realizar ejercicio de optimización de función con `spi.prepare` y caché local.

Usar `spi.newcursor` y `spi.findcursor` cuando se necesita procesar resultados por partes.

Abrir cursores desde statements preparados o queries.

Usar `cur:fetch`, `cur:move`, `cur:close`, `cur:isopen` y gestión de ownership.

Devolver refcursors a consultas o clientes cuando el patrón lo requiere.

Entender cuándo un cursor puede cerrarse por garbage collection si no se gestiona ownership.

Evitar cargar grandes volúmenes completos en memoria si puede iterarse.

Diseñar cursores con límites, dirección y comportamiento documentado.

Gestionar errores de cursor cerrado, portal inexistente y transacción finalizada.

Comparar cursores frente a SRFs y consultas set-based.

Realizar ejercicio de cursor PL/Lua para lectura progresiva de resultados.

Usar `print` para diagnósticos interactivos en laboratorio, sabiendo que emite mensajes INFO.

Usar funciones de logging como `elog`, `info`, `notice`, `warning`, `debug` y `error`.

Diferenciar errores de validación, datos, SPI, seguridad y programación.

Usar `pcall` y `xpcall` con soporte de subtransacciones cuando se necesita recuperación.

Crear mensajes útiles sin exponer datos sensibles.

Evitar silenciar errores dejando datos incoherentes.

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

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

Crear tests para errores esperados y entradas inválidas.

Realizar ejercicio de endurecimiento de errores en funciones PL/Lua.

Comprender cómo PL/Lua se ejecuta dentro del contexto transaccional de PostgreSQL.

Revisar el soporte de `pcall` y `xpcall` con subtransacciones.

Usar subtransacciones para aislar operaciones que pueden fallar parcialmente.

Diferenciar rollback parcial y rollback completo de la transacción.

Diseñar procesos donde errores por registro se capturan sin corromper datos.

Evitar abusar de subtransacciones en bucles masivos sin medir impacto.

Revisar cuándo `spi.commit` y `spi.rollback` están permitidos en contextos no atómicos.

Documentar qué operaciones forman una unidad lógica indivisible.

Crear pruebas con fallos provocados para validar rollback.

Realizar ejercicio de proceso multi-tabla con recuperación parcial.

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

Comprender los parámetros implícitos de trigger: trigger, old, new y argumentos.

Acceder a `trigger.new`, `trigger.old`, `trigger.row`, operación, nivel, momento y relación.

Modificar filas en triggers `BEFORE INSERT` o `BEFORE UPDATE`.

Devolver la fila correcta según el tipo de operación.

Crear triggers `AFTER` para auditoría y efectos posteriores.

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/Lua para normalización de datos.

Crear triggers `BEFORE` para validar datos antes de persistirlos.

Normalizar emails, códigos, referencias, identificadores, nombres y estados.

Crear triggers `AFTER` para registrar cambios relevantes.

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

Evitar auditar datos personales o secretos sin necesidad.

Enriquecer registros con datos derivados controlados.

Diseñar triggers reutilizables con argumentos claros.

Crear mecanismos de bypass controlado para cargas autorizadas.

Medir impacto de triggers en escrituras frecuentes.

Realizar ejercicio de auditoría y validación avanzada con PL/Lua.

Comprender qué son los event triggers en PostgreSQL.

Crear funciones PL/Lua para reaccionar ante eventos DDL.

Usar `trigger.event` y `trigger.tag` para identificar evento y comando.

Registrar cambios de esquema relevantes en tablas de auditoría.

Crear controles de gobierno para `CREATE`, `ALTER`, `DROP` y cambios críticos.

Diferenciar auditoría DDL de control de permisos reales.

Evitar event triggers que bloquean trabajo DBA legítimo sin proceso claro.

Integrar event triggers con gestión de cambios y revisión técnica.

Crear reportes de cambios DDL por entorno y usuario.

Realizar ejercicio de event trigger PL/Lua para auditoría de cambios de esquema.

Entender qué módulos están disponibles en PL/Lua trusted.

Revisar restricciones sobre `package`, `require`, `os`, entorno global y escritura de globales.

Usar `pllua.trusted` para exponer módulos aprobados en el sandbox.

Evaluar módulos como `lpeg` o `re` cuando el administrador los autoriza.

Analizar riesgos de módulos Lua o C que acceden a IO, red o estado global.

Definir allowlist de módulos permitidos por entorno.

Evitar incorporar módulos complejos sin revisión de seguridad y estabilidad.

Documentar inicialización `on_trusted_init`, `on_untrusted_init` y cambios de configuración.

Probar funciones después de modificar módulos disponibles.

Realizar ejercicio de evaluación de módulo Lua antes de habilitarlo.

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

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

Comparar SQL nativo, PL/pgSQL, PL/Lua y alternativas externas.

Evitar funciones llamadas por fila sobre tablas grandes sin benchmark.

Analizar uso de memoria en arrays, JSONB, cursores, SRFs y estructuras Lua.

Revisar garbage collection y opciones de configuración relacionadas.

Evitar cargar datasets grandes en tablas Lua si puede resolverse set-based.

Reducir SPI repetitivo mediante prepared statements y consultas set-based.

Crear benchmarks reproducibles con datos representativos.

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

Comprender el ciclo de vida de intérpretes Lua dentro de sesiones PostgreSQL.

Revisar diferencias entre estado local de función, upvalues, globales restringidos y módulos.

Evitar estado mutable que genera resultados impredecibles entre llamadas.

Analizar impacto de `shared_preload_libraries` y prebuilt interpreters si se usan.

Controlar cachés locales, planes preparados y valores inicializados una vez.

Probar funciones en sesiones concurrentes y con distintos roles.

Evitar comportamiento dependiente de orden de ejecución o estado residual.

Documentar cualquier uso de caché, upvalues o estado persistente.

Crear estrategia de invalidación cuando cambian reglas o tablas auxiliares.

Realizar ejercicio de diagnóstico de estado persistente y concurrencia.

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

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

Revisar riesgos de funciones `SECURITY DEFINER` con SPI, triggers y datos sensibles.

Fijar `search_path` seguro en funciones privilegiadas.

Evitar que funciones PL/Lua expongan datos que el usuario no debería consultar.

Controlar módulos, untrusted language, IO, red y acceso al entorno.

Crear checklist de revisión de seguridad antes de producción.

Auditar owners, grants, esquemas y funciones críticas.

Documentar datos tratados y roles autorizados.

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

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

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

Probar triggers con INSERT, UPDATE, DELETE, TRUNCATE y rollback.

Validar event triggers con comandos DDL controlados.

Crear datasets reproducibles para pruebas funcionales y de rendimiento.

Comparar resultados con implementación SQL, PL/pgSQL o referencia externa.

Automatizar tests mediante scripts SQL, pgTAP o pipeline propio.

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

Crear pruebas específicas de permisos, `SECURITY DEFINER` y datos sensibles.

Realizar ejercicio de suite de tests para funciones, triggers y event triggers.

Organizar funciones PL/Lua en archivos SQL versionados.

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

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

Crear scripts reversibles cuando el cambio lo permite.

Evitar modificar funciones manualmente en producción sin trazabilidad.

Documentar versión de PostgreSQL, PL/Lua, Lua, LuaJIT, módulos y configuración.

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/Lua.

Crear contenedor PostgreSQL con PL/Lua disponible o compilado durante el build.

Instalar Lua, LuaJIT, headers, `pg_config`, toolchain y extensión en imagen controlada.

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 `pllua` antes de aplicar funciones.

Gestionar configuración y secretos sin incrustarlos en código.

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/Lua con tests automáticos.

Registrar errores, tiempos y frecuencia de funciones PL/Lua 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 y event triggers.

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, SPI, módulos, 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/Lua.

Crear inventario de funciones, procedimientos, triggers, event triggers y permisos.

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

Analizar dependencias entre funciones, vistas, triggers, jobs y aplicaciones externas.

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/Lua heredado.

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

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

Mover lógica de negocio extensa a servicios backend o jobs externos.

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/Lua a PL/pgSQL o servicio externo.

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

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

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/Lua.

Revisar periódicamente permisos, `SECURITY DEFINER`, PL/LuaU y event triggers.

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

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

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

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

Analizar parsing ligero donde Lua es suficiente 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/Lua, triggers y tablas de negocio.

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

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

Crear inventario de funciones, procedimientos, triggers, event triggers, owners y dependencias.

Implementar función escalar PL/Lua para normalización de texto o identificadores.

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

Implementar función con composite type y retorno estructurado.

Implementar función set-returning usando coroutines y `coroutine.yield`.

Crear función con `spi.execute` para consultar tabla auxiliar.

Optimizar consulta interna usando `spi.prepare`, `stmt:execute` y caché local.

Implementar cursor para lectura progresiva de resultados.

Crear función sobre JSONB para validar payloads y extraer campos normalizados.

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

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

Crear event trigger PL/Lua para registrar comandos DDL relevantes.

Añadir manejo robusto de errores con `pcall`, logging y mensajes claros.

Usar subtransacciones cuando el caso requiera recuperación parcial.

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

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

Preparar scripts de migración, rollback, documentación y runbook operativo.

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