Curso de PL/TCL

Revisar cómo PostgreSQL instala lenguajes procedurales mediante extensiones.

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

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

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

Verificar disponibilidad de `pltcl` y `pltclu` en `pg_language`.

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

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

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

Diagnosticar errores de instalación, paquetes ausentes, permisos o versiones incompatibles.

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

Comprender qué significa que PL/Tcl sea un lenguaje trusted.

Diferenciar PL/Tcl y PL/TclU desde permisos, seguridad y capacidades.

Analizar por qué PL/TclU debe tratarse con mucha más cautela.

Revisar qué usuarios pueden crear funciones trusted y qué límites deben aplicarse.

Controlar quién puede crear, modificar y ejecutar funciones PL/TclU.

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

Crear política corporativa para uso permitido de PL/Tcl y prohibición o restricción de PL/TclU.

Identificar funciones que requieren revisión DBA y seguridad antes de desplegarse.

Evitar que PL/Tcl 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 Tcl necesaria para escribir funciones PL/Tcl.

Trabajar con variables, sustitución, listas, strings, arrays asociativos y comandos.

Usar `expr` para cálculos y condiciones numéricas de forma segura.

Crear estructuras `if`, `switch`, `for`, `foreach` y `while` aplicadas a datos SQL.

Gestionar errores con `catch`, mensajes y control de flujo.

Diferenciar listas Tcl, strings y arrays para evitar errores de interpretación.

Aplicar estilo claro en scripts Tcl embebidos dentro de SQL.

Evitar scripts demasiado crípticos, con sustituciones difíciles o lógica poco revisable.

Crear pequeñas funciones Tcl idiomáticas dentro del cuerpo PL/Tcl.

Realizar ejercicio de Tcl aplicado a validación y normalización de datos.

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

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

Acceder a argumentos mediante variables `$1`, `$2`, `$3` y sucesivas.

Devolver resultados mediante `return` y devolver nulos con `return_null`.

Entender cómo una función no estricta recibe nulos como cadenas vacías.

Usar `argisnull` para distinguir nulos reales de cadenas vacías.

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

Crear funciones pequeñas con una responsabilidad clara.

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

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

Comprender que muchos valores SQL llegan al cuerpo Tcl como representaciones textuales.

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

Controlar conversiones numéricas mediante `expr` y validaciones previas.

Distinguir `NULL`, cadena vacía y valores no informados.

Devolver tipos compatibles con la firma declarada en PostgreSQL.

Evitar pérdida de precisión en importes, porcentajes o cálculos sensibles.

Crear validaciones de formato antes de procesar fechas, códigos o identificadores.

Gestionar errores de casteo devueltos por PostgreSQL al retornar valores inválidos.

Documentar supuestos de tipo, formato y rango.

Realizar ejercicio de conversión segura de tipos SQL a Tcl y retorno SQL.

Recibir argumentos composite como arrays Tcl indexados por nombre de atributo.

Leer y validar atributos presentes, ausentes o nulos dentro de un composite.

Devolver composite results mediante listas de pares columna/valor.

Usar `array get` para construir resultados desde arrays Tcl.

Crear funciones con `OUT` parameters y retorno estructurado.

Diseñar contratos tabulares claros para reporting o procesos internos.

Evitar columnas inesperadas o nombres incorrectos que provocan errores.

Documentar qué campos son obligatorios, opcionales o calculados.

Comparar composite types frente a JSONB y tablas temporales.

Realizar ejercicio de función PL/Tcl que recibe y devuelve un tipo compuesto.

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

Usar `return_next` para emitir resultados uno a uno.

Devolver escalares, composites o `RETURNS TABLE` desde PL/Tcl.

Controlar memoria y volumen cuando se generan muchos resultados.

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

Evitar funciones set-returning costosas en rutas críticas sin benchmark.

Diseñar salidas tabulares con tipos, nombres y orden claros.

Crear validaciones sobre límites, rangos y volumen máximo.

Comparar con SQL set-based cuando la generación puede resolverse sin PL/Tcl.

Realizar ejercicio de función que genera serie, tabla calculada o expansión de datos.

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

Diferenciar funciones y procedimientos desde retorno, llamada y objetivo operativo.

Usar procedimientos para tareas controladas de mantenimiento, normalización o preparación.

Gestionar parámetros IN, OUT e INOUT cuando el caso lo requiere.

Diseñar procedimientos idempotentes y con trazabilidad.

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

Registrar resultados, errores y métricas de ejecución.

Separar procedimientos técnicos de funciones usadas dentro de consultas.

Crear contratos claros sobre efectos esperados.

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

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

Usar `spi_exec` para ejecutar consultas y comandos internos.

Procesar resultados SELECT mediante variables Tcl generadas por nombre de columna.

Usar la opción `-array` para guardar columnas en arrays asociativos.

Usar `-count` para limitar número de filas procesadas.

Ejecutar un cuerpo Tcl por cada fila devuelta por una consulta.

Gestionar resultados vacíos, nulos y errores SQL.

Evitar construir SQL dinámico inseguro con datos de usuario.

Comparar SPI con resolver la operación mediante SQL externo.

Realizar ejercicio de función PL/Tcl que consulta tablas auxiliares con `spi_exec`.

Crear planes preparados con `spi_prepare`.

Entender cómo se definen parámetros `$1`, `$2` en la consulta preparada.

Ejecutar planes con `spi_execp` y listas de valores.

Gestionar parámetros nulos con la opción `-nulls`.

Guardar planes en `GD` para reutilizarlos durante la sesión.

Evitar preparar el mismo plan en cada llamada de función.

Usar planes preparados para mejorar seguridad frente a SQL dinámico.

Medir beneficio real de planes preparados en funciones llamadas con frecuencia.

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

Realizar ejercicio de función optimizada con `spi_prepare`, `spi_execp` y `GD`.

Entender el riesgo de concatenar valores dentro de strings SQL.

Usar `quote` para escapar cadenas cuando se construyen comandos dinámicos.

Diferenciar quoting de valores y quoting de identificadores.

Priorizar planes preparados frente a SQL dinámico siempre que sea viable.

Detectar patrones inseguros en funciones PL/Tcl existentes.

Evitar interpolación directa de argumentos de usuario en consultas SQL.

Crear checklist de revisión de seguridad para SPI.

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

Preparar tests de entradas con comillas, barras, nulos y caracteres raros.

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

Comprender qué es `GD` y cómo permite almacenar datos persistentes por función.

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

Diferenciar datos globales privados de función y variables globales compartidas.

Entender el aislamiento por intérprete Tcl y por rol SQL.

Revisar implicaciones de `SECURITY DEFINER`, `SET ROLE` y ownership.

Evitar estado global que genera resultados impredecibles o difíciles de depurar.

Crear estrategias de invalidación cuando una configuración cambia.

Medir memoria y ciclo de vida de datos guardados en sesión.

Documentar cualquier uso de `GD` en funciones críticas.

Realizar ejercicio de caché de plan preparado usando `GD`.

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

Entender cuándo un `ERROR` aborta la transacción o subtransacción actual.

Capturar errores Tcl con `catch` cuando se necesita recuperación controlada.

Diferenciar errores de validación, errores de datos, errores SQL y errores técnicos.

Crear mensajes claros sin exponer información sensible.

Evitar `FATAL` salvo escenarios extremadamente excepcionales y justificados.

Registrar contexto mínimo: función, tabla, operación, clave y causa.

Evitar ocultar errores dejando datos incoherentes.

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

Realizar ejercicio de endurecimiento de errores y mensajes en funciones existentes.

Comprender por qué varias operaciones SPI pueden dejar estados parciales si se gestionan mal.

Usar `subtransaction` para agrupar operaciones que deben confirmarse o revertirse juntas.

Combinar `subtransaction` con `catch` para capturar errores y registrar resultados.

Diferenciar rollback de subtransacción y rollback completo de transacción.

Diseñar procesos donde los errores parciales quedan registrados sin corromper datos.

Evitar abusar de subtransacciones en bucles masivos sin medir impacto.

Registrar operaciones fallidas en tablas de auditoría o rechazo.

Crear tests para comprobar rollback correcto ante fallos intencionados.

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

Realizar ejercicio de transferencia o actualización multi-tabla con subtransacción.

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

Diferenciar triggers `BEFORE`, `AFTER`, `INSTEAD OF`, `ROW` y `STATEMENT`.

Usar variables `$TG_name`, `$TG_table_name`, `$TG_table_schema`, `$TG_when`, `$TG_level` y `$TG_op`.

Acceder a argumentos de trigger mediante `$args` y `$1`, `$2`, `$3`.

Leer fila nueva mediante array `$NEW` y fila antigua mediante array `$OLD`.

Gestionar columnas nulas que no aparecen en los arrays.

Devolver `OK`, `SKIP` o una lista de columna/valor según el efecto deseado.

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

Evitar triggers con lógica opaca o efectos no documentados.

Realizar ejercicio de trigger PL/Tcl para normalización y control de cambios.

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

Normalizar campos como emails, códigos, identificadores, nombres o referencias.

Crear triggers `AFTER` para auditoría controlada de cambios relevantes.

Registrar operación, usuario, fecha, tabla, clave y diferencias importantes.

Evitar auditar datos personales o secretos más allá de lo necesario.

Gestionar triggers reutilizables con argumentos configurables.

Evitar triggers pesados en tablas con alta frecuencia de escritura.

Diseñar bypass controlado para cargas masivas autorizadas.

Medir impacto de triggers en INSERT, UPDATE y DELETE.

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

Comprender qué son los event triggers en PostgreSQL.

Crear funciones PL/Tcl con `RETURNS event_trigger`.

Usar `$TG_event` para identificar el evento DDL.

Usar `$TG_tag` para conocer el comando que dispara el event trigger.

Registrar comandos DDL relevantes en una tabla de auditoría.

Crear controles de cambios sobre esquemas, tablas, funciones o extensiones.

Diferenciar auditoría DDL de control de acceso y permisos reales.

Evitar event triggers que bloquean operaciones administrativas legítimas sin proceso claro.

Integrar event triggers con gobierno de cambios y revisión DBA.

Realizar ejercicio de event trigger PL/Tcl para auditoría de DDL.

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

Diferenciar funciones invocadas dentro de consultas y procedimientos llamados explícitamente.

Revisar limitaciones y comportamiento de comandos transaccionales en procedimientos.

Evitar operaciones lentas dentro de transacciones abiertas.

Diseñar procedimientos que registran avances y errores sin romper consistencia.

Analizar bloqueos provocados por triggers o funciones con SPI.

Crear estrategias de rollback y recuperación.

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

Probar comportamiento ante error, rollback y reintento.

Realizar ejercicio de proceso controlado con errores y recuperación.

Entender qué aporta PL/TclU frente a PL/Tcl trusted.

Analizar riesgos de PL/TclU por su carácter untrusted.

Definir escenarios excepcionales donde PL/TclU podría estar justificado.

Controlar permisos de creación y modificación de funciones PL/TclU.

Evitar acceso a sistema, red o recursos externos desde funciones de base de datos.

Revisar funciones PL/TclU existentes con criterios de seguridad reforzados.

Crear plan de reducción de uso de PL/TclU cuando sea posible.

Documentar owner, propósito, permisos y alternativas de cada función PL/TclU.

Evaluar migración a procesos externos o extensiones más controladas.

Realizar ejercicio de auditoría de función PL/TclU de alto riesgo.

Medir impacto de funciones PL/Tcl dentro de consultas SQL.

Usar `EXPLAIN` y `EXPLAIN ANALYZE` para analizar funciones en planes de ejecución.

Comparar rendimiento de SQL nativo, PL/pgSQL, PL/Tcl y alternativas externas.

Evitar llamadas por fila sobre tablas grandes sin benchmark.

Revisar volatilidad, coste declarado y efecto sobre optimizador.

Reducir SPI repetitivo mediante SQL set-based o planes preparados.

Detectar triggers que penalizan operaciones de escritura.

Medir latencia, CPU, locks y volumen de operaciones.

Crear benchmarks reproducibles con datos representativos.

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

Analizar cómo las funciones PL/Tcl se comportan bajo sesiones concurrentes.

Revisar riesgos de bloqueos por triggers, consultas internas y actualizaciones en orden inestable.

Evitar estado global compartido que afecte resultados entre llamadas o roles.

Medir impacto de funciones lentas en transacciones y experiencia de aplicación.

Diseñar funciones idempotentes cuando se usan en procesos reintentables.

Crear tests de concurrencia para operaciones críticas.

Detectar deadlocks provocados por triggers de auditoría o validación.

Separar validaciones ligeras de procesos pesados.

Documentar comportamiento esperado bajo carga.

Realizar ejercicio de diagnóstico de bloqueo asociado a trigger PL/Tcl.

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

Probar nulos, cadenas vacías, valores extremos, errores, arrays y composites.

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

Validar event triggers con comandos DDL controlados.

Crear datasets de prueba reproducibles.

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

Automatizar tests mediante scripts SQL, pgTAP o pipeline propio.

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

Crear pruebas específicas de seguridad y permisos.

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

Organizar funciones PL/Tcl en archivos SQL versionados.

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

Gestionar cambios de firma, 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, extensión, 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/Tcl.

Crear contenedor PostgreSQL con PL/Tcl disponible.

Levantar base de datos, 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 `pltcl` antes de aplicar funciones.

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

Gestionar secretos y credenciales sin incrustarlos en funciones.

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

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

Medir impacto de funciones en consultas lentas.

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, 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/Tcl.

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

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

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

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

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

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

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

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

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

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

Evaluar validaciones simples que podrían resolverse con constraints o domains.

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

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

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

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

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

Implementar función con nulos usando `argisnull` y `return_null`.

Implementar función con composite type y retorno estructurado.

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

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

Optimizar consulta interna usando `spi_prepare`, `spi_execp` y `GD`.

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

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

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

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

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

Usar `subtransaction` para agrupar operaciones que deben confirmarse o revertirse juntas.

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