Curso de PL/Ruby

Revisar el concepto de procedural language dentro de PostgreSQL.

Comparar SQL functions, PL/pgSQL, PL/Python, PL/Perl, PL/Rust, PL/Java, PL/R y PL/Ruby.

Diferenciar lenguajes incluidos en distribución base y lenguajes externos mantenidos por terceros.

Analizar trusted language, untrusted language y consecuencias sobre permisos.

Entender cuándo una función debe vivir en la base de datos y cuándo en una aplicación externa.

Evaluar criterios de selección: rendimiento, seguridad, mantenibilidad, equipo, despliegue y soporte.

Comparar PL/Ruby con lógica Ruby en Rails, Sidekiq, jobs, ETL o microservicios.

Identificar alternativas de migración según tipo de función.

Evitar elegir lenguaje procedural por comodidad del desarrollador sin revisar arquitectura.

Realizar ejercicio de matriz de decisión para ubicar lógica de negocio y datos.

Preparar entorno Linux o contenedor para compilar PL/Ruby.

Instalar PostgreSQL, headers de desarrollo, Ruby, compilador C, make y dependencias necesarias.

Revisar `pg_config`, rutas de PostgreSQL, librerías compartidas y compatibilidad binaria.

Ejecutar configuración mediante scripts de build como `extconf.rb` cuando el proyecto lo requiere.

Compilar e instalar la extensión en un entorno aislado de laboratorio.

Crear base de datos de prueba y habilitar lenguaje PL/Ruby según el procedimiento aplicable.

Diagnosticar errores de compilación, rutas, headers, permisos o incompatibilidad de versiones.

Documentar paso a paso la instalación reproducible para equipos de plataforma.

Evitar pruebas sobre servidores productivos o bases con datos reales.

Realizar ejercicio de build reproducible de PL/Ruby en contenedor.

Analizar compatibilidad entre versión de PostgreSQL, versión de Ruby y versión del código PL/Ruby.

Revisar impacto de cambios en APIs internas de PostgreSQL sobre extensiones antiguas.

Revisar impacto de cambios en Ruby moderno sobre mecanismos legacy del proyecto.

Identificar dependencias históricas como safe level, conversiones automáticas y runtime embebido.

Crear matriz de compatibilidad por entorno: desarrollo, test, staging y producción.

Detectar funciones que dependen de comportamientos antiguos de Ruby.

Probar builds contra varias versiones de PostgreSQL antes de decidir soporte.

Evitar asumir compatibilidad solo porque la extensión compila.

Documentar versiones exactas y limitaciones conocidas.

Realizar ejercicio de evaluación de compatibilidad de un entorno PL/Ruby heredado.

Comprender qué significa declarar un lenguaje como trusted dentro de PostgreSQL.

Revisar por qué los lenguajes embebidos pueden elevar riesgos si acceden al sistema o al servidor.

Analizar el modelo histórico de seguridad de PL/Ruby y sus limitaciones actuales.

Evaluar consecuencias de permitir que usuarios no superuser creen funciones PL/Ruby.

Diseñar política corporativa restrictiva para creación, modificación y ejecución de funciones.

Separar permisos de propietario, ejecución, despliegue, revisión y administración.

Identificar riesgos de acceso a ficheros, red, gems, objetos globales y estado compartido.

Evitar confiar en mecanismos legacy de sandboxing sin validación moderna.

Crear checklist de seguridad para funciones PL/Ruby.

Realizar ejercicio de auditoría de función potencialmente peligrosa.

Repasar sintaxis Ruby aplicada a funciones de base de datos.

Trabajar con strings, integers, floats, booleans, nil, arrays, hashes y symbols.

Usar bloques, iteradores, `map`, `select`, `reduce`, `each` y patrones expresivos.

Gestionar excepciones con `begin`, `rescue`, `ensure` y errores personalizados.

Evitar metaprogramación innecesaria en código embebido dentro de PostgreSQL.

Escribir código Ruby simple, legible y revisable por equipos no expertos en Ruby.

Controlar mutabilidad, objetos compartidos y efectos secundarios.

Usar clases o módulos solo cuando aportan claridad real.

Documentar supuestos, entradas, salidas y errores esperados.

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

Crear funciones PostgreSQL con cuerpo escrito en Ruby.

Definir firma SQL: parámetros, tipo de retorno, esquema, volatilidad y coste.

Acceder a argumentos desde Ruby según el mecanismo de PL/Ruby disponible.

Devolver valores compatibles con el tipo declarado en PostgreSQL.

Gestionar valores nulos y conversiones con cuidado.

Crear funciones pequeñas con una responsabilidad clara.

Documentar propósito, parámetros, retorno, ejemplos y riesgos.

Evitar funciones largas que mezclan parsing, consultas, validación y escritura.

Comparar función PL/Ruby con su equivalente PL/pgSQL o Ruby externo.

Realizar ejercicio de creación y revisión de funciones escalares PL/Ruby.

Revisar cómo PL/Ruby convierte tipos PostgreSQL hacia clases Ruby.

Trabajar con texto, enteros, decimales, booleanos, fechas, timestamps y nulos.

Validar conversiones automáticas antes de depender de ellas en producción.

Tratar diferencias entre `nil` y `NULL`.

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

Controlar encoding, caracteres especiales, unicode y normalización de texto.

Diseñar funciones tolerantes a entradas inesperadas.

Devolver tipos coherentes con la firma SQL.

Documentar reglas de conversión críticas.

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

Procesar arrays PostgreSQL como colecciones Ruby cuando la conversión lo permite.

Usar hashes para representar estructuras intermedias y resultados agrupados.

Trabajar con records, filas y resultados compuestos.

Diseñar funciones que devuelven estructuras tabulares claras.

Validar arrays vacíos, nulos internos, claves ausentes y tipos inesperados.

Evitar estructuras Ruby demasiado libres cuando el contrato SQL debe ser estricto.

Transformar colecciones con métodos idiomáticos sin sacrificar legibilidad.

Comparar uso de arrays/hashes Ruby frente a SQL nativo y JSONB.

Crear pruebas para entradas complejas.

Realizar ejercicio de función PL/Ruby que procesa colecciones y devuelve resultados estructurados.

Procesar cadenas JSON o estructuras semiestructuradas desde funciones PL/Ruby.

Validar claves obligatorias, tipos, valores y formatos.

Normalizar datos procedentes de APIs, formularios, integraciones o sistemas heredados.

Crear funciones para extracción de campos, limpieza de texto y enriquecimiento básico.

Comparar Ruby JSON parsing frente a operadores JSONB nativos de PostgreSQL.

Evitar procesar grandes volúmenes JSON fila a fila sin medir rendimiento.

Diseñar mensajes claros cuando el payload no cumple contrato.

Documentar esquemas esperados y reglas de normalización.

Crear datasets de prueba con casos válidos e inválidos.

Realizar ejercicio de validación y parsing de datos semiestructurados.

Crear funciones trigger escritas en Ruby.

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

Acceder a fila antigua, fila nueva, operación, tabla y contexto según API disponible.

Modificar datos antes de insertarlos o actualizarlos cuando procede.

Cancelar operaciones que incumplen validaciones críticas.

Registrar auditoría tras cambios relevantes.

Evitar lógica pesada en triggers de tablas con muchas escrituras.

Documentar dependencias entre tablas, triggers y funciones.

Probar triggers con inserts, updates, deletes y rollbacks.

Realizar ejercicio de trigger PL/Ruby para normalización y auditoría.

Crear funciones para validar datos antes de persistirlos.

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

Aplicar reglas de negocio documentadas y verificables.

Registrar auditoría con usuario, operación, fecha, tabla, clave y cambio relevante.

Evitar logs con datos personales o secretos innecesarios.

Controlar diferencias entre valor antiguo y nuevo.

Diseñar reglas que no bloquean procesos legítimos por validaciones excesivas.

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

Crear informe de reglas implementadas en PL/Ruby.

Realizar ejercicio de auditoría controlada de cambios sobre tabla crítica.

Comprender el uso de SPI para ejecutar SQL desde funciones procedurales.

Leer datos auxiliares desde tablas de configuración o catálogos internos.

Ejecutar consultas parametrizadas cuando el mecanismo lo permite.

Insertar o actualizar registros desde funciones con justificación arquitectónica.

Evitar concatenar SQL con datos de usuario sin control.

Diseñar funciones que no lanzan una consulta interna por cada fila sin necesidad.

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

Documentar consultas internas y dependencias de esquema.

Comparar SPI con resolver la lógica mediante SQL externo.

Realizar ejercicio de función PL/Ruby que consulta reglas auxiliares.

Capturar excepciones Ruby dentro de funciones PL/Ruby.

Convertir errores técnicos en mensajes comprensibles para PostgreSQL y usuarios técnicos.

Diferenciar errores de datos, errores de programación, errores de seguridad y errores operativos.

Evitar silenciamiento de excepciones que deja datos incoherentes.

Crear mensajes sin exponer datos sensibles.

Registrar contexto mínimo: función, operación, valor problemático y causa.

Controlar errores de conversión, nulos, encoding, JSON inválido y consultas internas.

Diseñar estrategia de fallo: abortar, devolver nulo, rechazar fila o registrar incidencia.

Crear pruebas para errores esperados.

Realizar ejercicio de endurecimiento de funciones con errores provocados.

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

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

Evitar llamadas externas, IO no controlado o procesamiento pesado dentro de transacciones críticas.

Diseñar triggers que no bloqueen escrituras frecuentes.

Revisar deadlocks provocados por consultas internas o actualizaciones en orden inestable.

Evitar estado global Ruby dependiente de ejecución previa.

Probar funciones con concurrencia y cargas simultáneas.

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

Crear estrategia de rollback y recuperación ante fallos.

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

Evaluar uso de librerías Ruby dentro del entorno PostgreSQL.

Diferenciar librerías estándar, gems externas y código corporativo reutilizado.

Revisar licencias, mantenimiento, vulnerabilidades, versiones y compatibilidad.

Evitar dependencias pesadas o con efectos secundarios dentro del proceso de PostgreSQL.

Controlar rutas de carga, entorno Ruby, permisos y variables.

Diseñar allowlist de gems permitidas para entornos controlados.

Documentar cada dependencia usada por una función crítica.

Preparar builds reproducibles con versiones bloqueadas.

Crear procedimiento de actualización y revisión de vulnerabilidades.

Realizar ejercicio de auditoría de gems y dependencias de una instalación PL/Ruby.

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

Usar `EXPLAIN` y `EXPLAIN ANALYZE` para detectar costes inesperados.

Comparar rendimiento de SQL nativo, PL/pgSQL, PL/Python, PL/Ruby y servicio externo.

Evitar funciones llamadas por fila en tablas grandes sin benchmark.

Revisar volatilidad, coste declarado y posibilidad de usar índices.

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

Identificar cuellos de botella: conversiones, SPI repetitivo, parsing, regex y triggers.

Crear benchmarks reproducibles con datos representativos.

Definir umbrales de latencia aceptable por caso de uso.

Realizar ejercicio de optimización de una función PL/Ruby lenta.

Crear pruebas SQL para funciones PL/Ruby con entradas y salidas esperadas.

Probar casos normales, nulos, errores, arrays, strings, JSON y datos extremos.

Crear datasets de prueba reproducibles para funciones y triggers.

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

Comparar resultados PL/Ruby frente a implementación de referencia en SQL o Ruby externo.

Automatizar pruebas mediante scripts SQL, pgTAP, RSpec externo o pipeline propio.

Evitar desplegar funciones PL/Ruby sin tests de regresión.

Crear pruebas de seguridad sobre roles, permisos y datos sensibles.

Documentar cobertura mínima de reglas críticas.

Realizar ejercicio de suite de pruebas para funciones y triggers PL/Ruby.

Organizar funciones PL/Ruby en scripts SQL versionados.

Gestionar cambios de firma, retorno, esquema, permisos y dependencias.

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

Crear migraciones reversibles cuando el cambio lo permita.

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

Evitar editar funciones directamente en producción sin trazabilidad.

Documentar versión de PostgreSQL, Ruby, PL/Ruby, gems y sistema operativo.

Coordinar despliegues con DBA, backend, plataforma y seguridad.

Crear release notes para cambios de funciones críticas.

Realizar ejercicio de migración de una función PL/Ruby a nueva versión.

Crear contenedor PostgreSQL preparado para compilar y ejecutar PL/Ruby.

Instalar Ruby, headers, toolchain, dependencias y extensión en una imagen reproducible.

Levantar base, lenguaje, esquemas, funciones y datos de prueba con Docker Compose.

Ejecutar tests automáticos en pipeline CI/CD.

Validar compatibilidad antes de desplegar migraciones.

Separar configuración de desarrollo y producción.

Gestionar secretos sin incrustarlos en funciones ni scripts.

Publicar artefactos SQL, logs de build, resultados de test y documentación.

Evitar pipelines dependientes de servidores manuales difíciles de reconstruir.

Realizar ejercicio de pipeline local para build, test y validación de PL/Ruby.

Registrar uso, errores, tiempos de ejecución y frecuencia de funciones críticas.

Integrar logs PostgreSQL con herramientas corporativas de observabilidad.

Crear métricas de errores de validación, filas rechazadas y triggers ejecutados.

Detectar funciones que aparecen en consultas lentas o bloqueos.

Crear runbooks para fallos de extensión, errores Ruby, permisos y rendimiento.

Evitar logs con datos personales, secretos o payloads completos innecesarios.

Relacionar función, tabla, proceso de negocio, owner y criticidad.

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

Preparar procedimiento de desactivación o rollback.

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

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

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

Analizar dependencias con vistas, funciones, 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 documentación o con dependencias rotas.

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

Preparar informe técnico para dirección de tecnología y DBA.

Priorizar quick wins frente a migraciones complejas.

Realizar ejercicio de auditoría completa de un esquema con funciones legacy.

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

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

Mover lógica de negocio a servicios Ruby, Rails, jobs o APIs cuando no debe estar en la base.

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

Crear pruebas de equivalencia antes de migrar.

Diseñar migraciones por fases: inventario, cobertura, duplicación, shadow run, corte y retirada.

Evitar reescrituras completas sin entender comportamiento actual.

Documentar diferencias funcionales y decisiones de arquitectura.

Preparar plan de rollback por función migrada.

Realizar ejercicio de migración de función PL/Ruby a PL/pgSQL o servicio externo.

Definir si se permite nuevo desarrollo PL/Ruby o solo mantenimiento controlado.

Crear estándar de revisión para funciones, triggers, permisos y dependencias.

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

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

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

Crear catálogo de funciones PL/Ruby con documentación mínima obligatoria.

Establecer periodicidad de revisión de dependencias y compatibilidad.

Definir criterios de retirada o sustitución por tecnologías modernas.

Evitar que PL/Ruby siga creciendo por inercia en sistemas heredados.

Realizar ejercicio de política corporativa para PL/Ruby en empresa.

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

Analizar parsing de texto donde Ruby puede ser expresivo pero no necesariamente óptimo.

Revisar triggers de auditoría y alternativas más simples.

Evaluar normalización de datos maestros y limpieza avanzada.

Desaconsejar llamadas externas desde funciones de base de datos.

Desaconsejar lógica de negocio extensa dentro de triggers.

Desaconsejar dependencias Ruby complejas dentro del servidor PostgreSQL.

Identificar casos donde PL/Rust, PL/Python o pgrx pueden ser más defendibles.

Crear matriz de riesgo por caso de uso.

Realizar ejercicio de clasificación de veinte funciones potenciales.

Recibir un esquema PostgreSQL de laboratorio con funciones PL/Ruby y triggers legacy.

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

Preparar entorno Docker reproducible con PostgreSQL, Ruby, PL/Ruby y datos de prueba.

Compilar o habilitar PL/Ruby en entorno aislado y documentar pasos de instalación.

Ejecutar pruebas iniciales para verificar comportamiento actual.

Analizar seguridad de lenguaje, permisos, trusted mode, dependencias y gems.

Revisar una función escalar de normalización y documentar contrato de entrada y salida.

Revisar una función de parsing sobre texto o JSON y crear casos de prueba.

Revisar un trigger de validación o auditoría y medir impacto en operaciones de escritura.

Añadir manejo de errores más claro sin ocultar fallos críticos.

Crear suite de tests de regresión para funciones y triggers principales.

Medir rendimiento con consultas representativas y detectar cuellos de botella.

Identificar funciones candidatas a PL/pgSQL, PL/Python, PL/Rust o servicio externo.

Migrar una función sencilla a PL/pgSQL y comparar resultados.

Migrar o rediseñar una función compleja hacia servicio Ruby externo o alternativa acordada.

Crear scripts de migración versionados para instalar, actualizar o retirar funciones.

Preparar checklist de despliegue, rollback y validación post-release.

Crear informe de riesgos con permisos, dependencias, seguridad, compatibilidad y soporte.

Diseñar política de gobierno para mantener o retirar PL/Ruby en la organización.

Presentar la solución final defendiendo continuidad, seguridad, reducción de riesgo, pruebas y estrategia de modernización.