Curso de PL/Perl

Revisar cómo PostgreSQL instala lenguajes procedurales mediante extensiones.

Verificar si PL/Perl está disponible para la instalación concreta de PostgreSQL.

Instalar paquetes del sistema necesarios para PL/Perl cuando el entorno lo requiere.

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

Validar disponibilidad de `plperl` y `plperlu` en el catálogo `pg_language`.

Crear roles, esquemas y tablas de laboratorio para trabajar sin datos sensibles.

Preparar scripts SQL reproducibles para creación de extensión, esquemas, funciones y datos.

Separar entornos de desarrollo, test, staging y producción.

Diagnosticar errores de instalación, paquete ausente, versión incompatible o permisos insuficientes.

Realizar ejercicio de entorno PostgreSQL con PL/Perl habilitado y validado.

Comprender qué significa que `plperl` sea trusted dentro de PostgreSQL.

Diferenciar `plperl` y `plperlu` desde permisos, restricciones y riesgo operativo.

Analizar qué operaciones se limitan en `plperl` para preservar la seguridad.

Revisar por qué `plperlu` debe reservarse a superusuarios o escenarios muy controlados.

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

Evaluar riesgos de acceso a sistema, módulos, IO, red, variables de entorno y código privilegiado.

Revisar funciones `SECURITY DEFINER` con especial atención al `search_path` y permisos efectivos.

Crear política corporativa sobre uso permitido de `plperl` y restricción de `plperlu`.

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

Realizar ejercicio de clasificación de funciones por riesgo trusted/untrusted.

Repasar sintaxis Perl aplicada a funciones dentro de PostgreSQL.

Trabajar con escalares, arrays, hashes, referencias, `undef`, contexto escalar y expresiones regulares.

Usar `my`, `use strict`, `use warnings`, operadores, condicionales, bucles y subrutinas anónimas.

Diferenciar cadenas, números, booleanos Perl y valores textuales procedentes de PostgreSQL.

Aplicar regex para validación, parsing, sustitución, extracción y normalización de campos.

Gestionar errores con `eval`, `die`, mensajes controlados y patrones defensivos.

Evitar código Perl críptico, golf, variables globales innecesarias y efectos secundarios invisibles.

Escribir funciones pequeñas, expresivas y revisables por DBA y seguridad.

Documentar supuestos, entradas, salidas, formatos y errores esperados.

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

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

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

Entender que el cuerpo PL/Perl se envuelve internamente como una subrutina Perl.

Acceder a argumentos mediante `@_` y variables locales.

Devolver resultados mediante `return` o la última expresión evaluada.

Devolver SQL `NULL` mediante `undef` cuando el contrato lo permite.

Crear funciones pequeñas con una responsabilidad clara.

Evitar subrutinas nombradas anidadas peligrosas dentro del cuerpo de función.

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

Realizar ejercicio de creación de funciones escalares PL/Perl.

Comprender cómo PostgreSQL entrega valores nulos a PL/Perl como `undef`.

Usar `STRICT` para que PostgreSQL no invoque la función cuando algún argumento es nulo.

Decidir cuándo conviene gestionar `undef` manualmente dentro de la función.

Diferenciar `undef`, cadena vacía, cero, falso y valores textuales.

Crear validaciones robustas para entradas incompletas.

Evitar que `undef` se convierta accidentalmente en cero o cadena vacía.

Diseñar retornos nulos explícitos y documentados.

Crear tests con argumentos nulos, vacíos y límites.

Documentar comportamiento ante nulos para usuarios SQL.

Realizar ejercicio de hardening de funciones con entradas nulas.

Comprender que muchos valores SQL llegan a Perl como representación textual externa.

Trabajar con integer, numeric, text, boolean, date, timestamp, UUID y bytea.

Revisar el problema específico de booleanos como `'t'` y `'f'` en Perl.

Usar transformaciones de booleanos cuando el entorno lo requiere.

Gestionar `bytea` mediante utilidades de codificación y decodificación.

Evitar pérdida de precisión en cálculos financieros o científicos.

Validar fechas, formatos, números y códigos antes de procesarlos.

Devolver valores compatibles con la firma SQL declarada.

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

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

Recibir arrays PostgreSQL como referencias tratables desde Perl.

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

Gestionar arrays vacíos, nulos internos, valores repetidos y tipos inesperados.

Devolver arrays PostgreSQL mediante referencias a arrays Perl.

Trabajar con arrays multidimensionales como referencias anidadas.

Usar funciones auxiliares para codificar literales de arrays cuando se construye SQL.

Evitar arrays enormes en funciones llamadas por fila sin benchmark.

Comparar procesamiento Perl frente a SQL set-based.

Crear tests para arrays simples, multidimensionales y con nulos.

Realizar ejercicio de normalización y deduplicación de arrays con PL/Perl.

Recibir tipos compuestos PostgreSQL como referencias a hashes Perl.

Acceder a atributos por nombre y validar claves esperadas.

Devolver composite types mediante referencias a hashes con atributos correctos.

Gestionar campos ausentes, opcionales, nulos y calculados.

Crear resultados estructurados para reporting, APIs internas o procesos de validación.

Evitar hashes ambiguos cuando el contrato SQL debe ser estricto.

Comparar tipos compuestos frente a JSONB, arrays y tablas temporales.

Documentar columnas devueltas, significado y reglas de cálculo.

Crear pruebas de estructura, orden y valores esperados.

Realizar ejercicio de función que recibe y devuelve composite types.

Crear funciones PL/Perl que devuelven conjuntos de valores o filas.

Usar `return_next` para emitir resultados de forma incremental.

Devolver escalares, arrays o composites en funciones `RETURNS SETOF`.

Finalizar correctamente una función set-returning con `return undef`.

Controlar memoria cuando el resultado puede ser grande.

Comparar devolución incremental frente a devolver una referencia a array completa.

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

Evitar funciones set-returning costosas en rutas críticas sin medición.

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

Realizar ejercicio de expansión de datos semiestructurados a filas relacionales.

Crear procedimientos con `CREATE PROCEDURE` y `LANGUAGE plperl`.

Diferenciar funciones, procedimientos y bloques anónimos `DO`.

Entender que el valor devuelto por el código Perl en un procedimiento se ignora.

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

Diseñar procedimientos idempotentes y con trazabilidad.

Evitar procedimientos opacos que modifican muchos datos sin logs ni pruebas.

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

Separar procedimientos operativos de funciones llamadas dentro de consultas.

Crear contratos claros sobre efectos esperados y rollback.

Realizar ejercicio de procedimiento PL/Perl para proceso de normalización controlado.

Comprender el papel de SPI para ejecutar SQL desde funciones PL/Perl.

Usar `spi_exec_query` para ejecutar consultas o comandos internos.

Procesar resultados como arrays de hash references.

Obtener número de filas procesadas y estado de la operación.

Limitar resultados cuando se sabe que el conjunto debe ser pequeño.

Gestionar resultados vacíos, múltiples filas 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 Perl, SQL interno y reglas de negocio para facilitar mantenimiento.

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

Usar `spi_query` cuando el resultado puede ser grande o debe procesarse progresivamente.

Recorrer filas con `spi_fetchrow` sin cargar todo el conjunto en memoria.

Cerrar cursores con `spi_cursor_close` cuando procede.

Diseñar funciones que devuelven resultados a medida que se leen.

Comparar cursores SPI frente a `spi_exec_query`.

Evitar consumo excesivo de memoria en consultas grandes.

Gestionar errores durante lectura, cancelación o cierre de cursor.

Documentar casos donde se permite procesamiento progresivo.

Crear pruebas con resultados pequeños, grandes y vacíos.

Realizar ejercicio de función que procesa un conjunto grande mediante cursor SPI.

Crear planes preparados con `spi_prepare`.

Definir placeholders `$1`, `$2` y tipos de argumentos esperados.

Ejecutar planes con `spi_exec_prepared` y parámetros seguros.

Usar `spi_query_prepared` cuando se necesita cursor sobre un plan preparado.

Liberar planes con `spi_freeplan` cuando dejan de usarse.

Guardar planes en `$_SHARED` para reutilización controlada durante la sesión.

Evitar preparar la misma consulta en cada llamada de función.

Medir beneficio real de planes preparados frente a `spi_exec_query`.

Documentar consultas preparadas, tipos de parámetros y dependencias.

Realizar ejercicio de optimización usando `spi_prepare`, `$_SHARED` y parámetros.

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

Usar `quote_literal`, `quote_nullable` y `quote_ident` según el caso.

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

Priorizar prepared statements frente a SQL dinámico siempre que sea viable.

Evitar que argumentos de usuario definan tablas, columnas o cláusulas sin allowlist.

Revisar funciones legacy con riesgo de SQL injection.

Crear pruebas con comillas, backslashes, nulos, caracteres raros y payloads maliciosos.

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

Crear checklist corporativo de revisión de SQL dinámico en PL/Perl.

Realizar ejercicio de corrección de función vulnerable a inyección SQL.

Comprender qué es `$_SHARED` y cómo permite compartir datos entre llamadas de una misma función o sesión.

Usar `$_SHARED` para guardar planes preparados, configuraciones o cachés ligeras.

Diferenciar caché útil, estado peligroso y dependencia oculta.

Diseñar invalidación cuando cambian tablas auxiliares, reglas o configuración.

Evitar resultados dependientes del orden de ejecución o de sesiones anteriores.

Controlar memoria ocupada por estructuras compartidas.

Documentar cualquier uso de `$_SHARED` en funciones críticas.

Crear funciones de inicialización y liberación de planes cuando procede.

Probar comportamiento en sesiones diferentes, roles distintos y despliegues nuevos.

Realizar ejercicio de caché de plan preparado con `$_SHARED`.

Usar `elog` con niveles `DEBUG`, `LOG`, `INFO`, `NOTICE`, `WARNING` y `ERROR`.

Comprender que `ERROR` aborta la transacción o subtransacción si no se captura.

Usar `die`, `eval` y control de excepciones con criterio.

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

Crear mensajes claros sin exponer datos sensibles.

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

Evitar ocultar errores que dejan datos incoherentes.

Crear patrón común de manejo de errores para funciones PL/Perl corporativas.

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

Realizar ejercicio de endurecimiento de errores y mensajes.

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

Usar `spi_commit` y `spi_rollback` solo en procedimientos o bloques DO llamados desde nivel superior.

Entender por qué no se deben ejecutar `COMMIT` o `ROLLBACK` mediante consultas SPI normales.

Diseñar procesos que registran avances, errores y resultados de forma controlada.

Evitar operaciones lentas dentro de transacciones abiertas.

Gestionar errores parciales con patrones de recuperación adecuados.

Analizar bloqueos provocados por funciones y triggers PL/Perl.

Documentar comportamiento transaccional de cada función crítica.

Crear pruebas con rollback, commit parcial y errores provocados.

Realizar ejercicio de procedimiento PL/Perl con commit y rollback controlado.

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

Comprender `$_TD` como hash reference con información del evento de trigger.

Acceder a `$_TD->{new}` y `$_TD->{old}` para leer filas nuevas y antiguas.

Usar campos como `event`, `when`, `level`, `table_name`, `table_schema` y argumentos.

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

Devolver `SKIP` para cancelar operación en triggers por fila.

Devolver `MODIFY` cuando se altera la fila nueva en un trigger `BEFORE`.

Devolver sin valor cuando la operación debe continuar sin modificación.

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

Realizar ejercicio de trigger PL/Perl para validación y modificación controlada.

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, secretos o payloads completos sin necesidad.

Diseñar triggers reutilizables mediante argumentos de trigger.

Crear mecanismos de bypass controlado para cargas masivas autorizadas.

Medir impacto de triggers en operaciones INSERT, UPDATE y DELETE.

Crear tests de regresión para cada trigger crítico.

Realizar ejercicio de auditoría y normalización sobre tabla sensible.

Comprender qué son los event triggers y cuándo se usan en PostgreSQL.

Crear funciones PL/Perl para reaccionar ante eventos DDL.

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

Capturar evento, comando, usuario, timestamp y contexto de cambio.

Usar event triggers para gobierno, trazabilidad y revisión de cambios.

Diferenciar auditoría DDL de control real de permisos.

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

Integrar auditoría DDL con gestión de cambios y revisión técnica.

Crear reportes de cambios DDL por entorno, usuario y tipo de objeto.

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

Usar expresiones regulares Perl para validar y transformar texto.

Extraer códigos, referencias, fechas, identificadores y segmentos de cadenas complejas.

Normalizar formatos heredados procedentes de ERP, CRM, logs o integraciones.

Crear funciones de parsing robustas frente a variaciones reales de datos.

Evitar regex ilegibles sin comentarios ni tests.

Medir coste de regex complejas sobre grandes volúmenes de datos.

Comparar regex Perl con funciones nativas PostgreSQL.

Documentar patrones, ejemplos válidos, inválidos y casos límite.

Crear batería de pruebas con entradas reales anonimizadas.

Realizar ejercicio de parsing avanzado de referencias comerciales o logs.

Entender qué operaciones y módulos pueden estar restringidos en `plperl` trusted.

Diferenciar librerías core, módulos instalados y módulos permitidos en `plperlu`.

Evaluar riesgos de dependencias Perl externas en el servidor PostgreSQL.

Revisar licencias, mantenimiento, vulnerabilidades y compatibilidad de módulos.

Evitar módulos que hacen IO, red, procesos externos o acceso al sistema en funciones críticas.

Crear allowlist corporativa de módulos permitidos cuando procede.

Documentar cada módulo usado, versión, propósito y función asociada.

Preparar entornos reproducibles con dependencias controladas.

Revisar impacto de actualizaciones de Perl y módulos sobre funciones PL/Perl.

Realizar ejercicio de auditoría de dependencias Perl en funciones existentes.

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

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/Perl exponga datos que el usuario no debería consultar.

Controlar consultas SPI ejecutadas con privilegios elevados.

Auditar owners, grants, esquemas, dependencias y datos tratados.

Crear checklist de seguridad antes de producción.

Documentar funciones críticas con permisos especiales.

Realizar ejercicio de hardening de función PL/Perl con privilegios elevados.

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

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

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

Evitar funciones llamadas por fila sobre tablas grandes sin benchmark.

Revisar volatilidad, coste declarado y efecto sobre el optimizador.

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

Detectar cuellos de botella: regex complejas, SPI repetitivo, arrays grandes 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/Perl lenta.

Comprender el comportamiento de intérpretes PL/Perl por rol SQL y sesión.

Revisar diferencias de estado entre `plperl` y `plperlu`.

Evitar estado compartido que produzca resultados impredecibles.

Analizar impacto de funciones lentas en locks, latencia y experiencia de aplicación.

Diseñar funciones idempotentes y reentrantes.

Probar funciones con sesiones concurrentes y distintos roles.

Detectar deadlocks provocados por triggers, SPI o actualizaciones en orden inestable.

Documentar comportamiento esperado bajo carga.

Crear estrategia de invalidación de cachés en `$_SHARED`.

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

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

Probar nulos, cadenas vacías, arrays, composites, booleanos, bytea, 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 Perl externo.

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

Evitar desplegar funciones PL/Perl 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/Perl 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, Perl, módulos, extensiones y sistema operativo.

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

Crear contenedor PostgreSQL con PL/Perl disponible.

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

Instalar módulos Perl autorizados cuando el entorno de prácticas lo requiere.

Ejecutar scripts de migración en entornos limpios.

Ejecutar tests automáticos en pipeline CI/CD.

Validar disponibilidad de `plperl` 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.

Realizar ejercicio de pipeline local para PL/Perl con pruebas automáticas.

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

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

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

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/Perl 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, jobs o pipelines externos.

Sustituir triggers por constraints, generated columns, reglas SQL o procesos batch 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/Perl a PL/pgSQL o servicio externo.

Definir si PL/Perl 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/Perl.

Revisar periódicamente permisos, `SECURITY DEFINER`, `plperlu` y triggers críticos.

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

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

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

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

Analizar parsing de texto donde Perl aporta expresividad y mantenibilidad.

Revisar triggers de auditoría y alternativas nativas.

Evaluar normalización de datos maestros, códigos, referencias, logs y formatos heredados.

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/Perl, triggers y tablas de negocio.

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

Habilitar `plperl` 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/Perl para normalización de texto, códigos o identificadores.

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

Implementar función con arrays PostgreSQL y referencias Perl.

Implementar función con composite type y retorno mediante hash reference.

Implementar función set-returning usando `return_next`.

Crear función con `spi_exec_query` para consultar tabla auxiliar.

Optimizar consulta interna usando `spi_prepare`, `spi_exec_prepared` y `$_SHARED`.

Crear función con `spi_query` y `spi_fetchrow` para procesar resultados grandes.

Corregir una función vulnerable sustituyendo SQL dinámico inseguro por prepared statements o quoting controlado.

Implementar trigger `BEFORE` con `$_TD` para validación y modificación de datos.

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

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

Añadir manejo robusto de errores con `eval`, `elog` y mensajes claros.

Crear tests SQL de funciones, triggers, event triggers, arrays, composites, 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.