Curso de PL/R

Preparar un entorno PostgreSQL de laboratorio sin datos productivos.

Instalar R, PostgreSQL, headers de desarrollo, compilador, `pg_config` y dependencias necesarias.

Verificar que R está instalado correctamente y que `R_HOME` puede localizarse de forma fiable.

Configurar `R_HOME` en el entorno del usuario que ejecuta PostgreSQL.

Validar que R dispone de librería compartida cuando el build de PL/R lo requiere.

Instalar PL/R desde paquete disponible o compilación controlada desde código fuente.

Ejecutar `CREATE EXTENSION plr` en una base de datos de prácticas.

Comprobar disponibilidad del lenguaje `plr` en catálogos PostgreSQL.

Diagnosticar errores por `R_HOME`, librerías compartidas, permisos, rutas, versiones o paquetes ausentes.

Realizar ejercicio de instalación reproducible de PostgreSQL + R + PL/R.

Comprender por qué PL/R debe tratarse como lenguaje untrusted.

Analizar qué implica que una función PL/R pueda acceder a capacidades del entorno R y del sistema.

Restringir quién puede crear, modificar y desplegar funciones PL/R.

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

Evitar que usuarios de aplicación puedan crear código PL/R.

Revisar riesgos de funciones `SECURITY DEFINER` combinadas con PL/R.

Controlar acceso a ficheros, librerías, entorno, red, variables y rutas del servidor.

Crear checklist de revisión de seguridad antes de aprobar una función PL/R.

Documentar riesgos aceptados, owners, datos tratados y controles compensatorios.

Realizar ejercicio de auditoría de seguridad de una función PL/R peligrosa.

Repasar vectores, listas, matrices, factores, data frames y funciones R aplicadas a datos SQL.

Trabajar con `NA`, `NULL`, `NaN`, `Inf` y su relación con valores nulos de PostgreSQL.

Usar funciones base como `mean`, `median`, `sd`, `quantile`, `summary`, `scale` y `table`.

Crear funciones R pequeñas, claras y sin efectos secundarios innecesarios.

Gestionar errores con `tryCatch` y mensajes comprensibles.

Evitar dependencias excesivas de estado global dentro del intérprete R.

Controlar coerciones automáticas de R que pueden alterar tipos o precisión.

Escribir código R legible para perfiles DBA y data engineering.

Documentar supuestos estadísticos, formatos, rangos y valores esperados.

Realizar ejercicio de R aplicado a validación, limpieza y cálculo de métricas.

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

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

Escribir el cuerpo de función usando sintaxis R sin envoltorio explícito de función.

Acceder a argumentos mediante variables `arg1`, `arg2`, `arg3` y sucesivas.

Devolver valores mediante `return()` o el último valor evaluado según el caso.

Gestionar nulos, valores ausentes y conversiones entre SQL y R.

Crear funciones pequeñas con una única responsabilidad.

Evitar funciones largas que mezclan consultas, estadística, validación, escritura y auditoría.

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

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

Comprender cómo PL/R pasa valores PostgreSQL a objetos R.

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

Gestionar nulos PostgreSQL frente a `NA`, `NULL` y valores especiales de R.

Evitar pérdidas de precisión en cálculos financieros, científicos o estadísticos.

Validar entradas antes de operar con funciones matemáticas o estadísticas.

Devolver valores compatibles con la firma SQL declarada.

Controlar conversiones automáticas de vectores y tipos mixtos.

Documentar reglas de conversión, límites, rangos y comportamiento ante entradas inválidas.

Crear tests con tipos límite, valores nulos y casos extremos.

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

Recibir arrays PostgreSQL y procesarlos como vectores o listas en R.

Aplicar cálculos estadísticos sobre listas de valores numéricos.

Procesar colecciones de códigos, etiquetas, categorías, importes o resultados.

Gestionar arrays vacíos, nulos internos y tipos mezclados.

Convertir estructuras R en retornos compatibles con PostgreSQL.

Usar matrices cuando el caso requiere cálculos vectorizados o transformaciones tabulares.

Evitar operaciones R que reciclan vectores de forma silenciosa y generan resultados incorrectos.

Comparar procesamiento vectorizado en R frente a SQL set-based.

Documentar tamaño esperado de arrays y límites de uso.

Realizar ejercicio de limpieza, validación y scoring sobre arrays PostgreSQL.

Convertir resultados y estructuras en data frames R para análisis intermedio.

Crear data frames a partir de consultas internas, arrays o argumentos complejos.

Devolver resultados tabulares compatibles con tipos compuestos o `RETURNS TABLE`.

Gestionar nombres de columnas, tipos, longitudes y nulos.

Evitar devolver estructuras R que no encajan con el contrato SQL.

Aplicar transformaciones tabulares sin perder trazabilidad del dato original.

Comparar data frames en PL/R frente a tablas temporales, CTEs y vistas SQL.

Diseñar salidas claras para reporting, BI o pipelines posteriores.

Crear pruebas de estructura, orden de columnas y contenido esperado.

Realizar ejercicio de función PL/R que devuelve resultados tabulares.

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

Diseñar contratos `RETURNS SETOF` o `RETURNS TABLE` con columnas claras.

Expandir vectores, listas, data frames o resultados analíticos en filas SQL.

Controlar volumen de salida para no penalizar memoria ni latencia.

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

Comparar SRFs PL/R con soluciones SQL nativas.

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

Documentar límites de uso, orden, tipos y comportamiento ante entrada vacía.

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

Realizar ejercicio de expansión de un análisis R a filas relacionales.

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

Usar funciones de acceso interno para consultar tablas auxiliares.

Ejecutar consultas SELECT controladas desde el cuerpo R.

Procesar resultados SQL como estructuras R.

Ejecutar INSERT, UPDATE o DELETE solo cuando el diseño lo justifica.

Evitar consultas internas por cada fila sin medir impacto.

Documentar dependencias de tablas, vistas, esquemas y permisos.

Separar SQL interno, lógica R y reglas estadísticas para facilitar mantenimiento.

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

Realizar ejercicio de función PL/R que consulta reglas auxiliares con SPI.

Crear consultas preparadas para operaciones internas repetidas.

Parametrizar entradas para evitar SQL dinámico inseguro.

Ejecutar planes preparados con distintos valores.

Reutilizar planes cuando una función se invoca con frecuencia.

Evitar preparar la misma consulta en cada llamada si puede cachearse con seguridad.

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

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

Revisar errores de parámetros nulos, tipos incorrectos o resultados inesperados.

Crear patrón corporativo para consultas internas seguras desde PL/R.

Realizar ejercicio de SPI con plan preparado y parámetros controlados.

Identificar riesgos de construir SQL mediante concatenación de strings en PL/R.

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

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

Usar quoting seguro cuando sea imprescindible construir SQL dinámico.

Crear allowlists para nombres de columnas, tablas o métricas permitidas.

Revisar funciones legacy con riesgo de SQL injection.

Evitar que argumentos de usuario definan objetos SQL sin validación estricta.

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

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

Realizar ejercicio de corrección de función PL/R vulnerable.

Crear funciones PL/R con retorno `trigger`.

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

Acceder a información del trigger, tabla, operación, fila antigua y fila nueva.

Modificar valores antes de insertar o actualizar cuando procede.

Rechazar operaciones que incumplen validaciones críticas.

Crear triggers ligeros y predecibles para no degradar escrituras.

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

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

Evitar lógica estadística pesada dentro de triggers de alta frecuencia.

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

Crear triggers de auditoría para registrar cambios relevantes.

Guardar usuario, operación, timestamp, tabla, clave y diferencias importantes.

Normalizar datos antes de persistirlos cuando el coste es razonable.

Detectar valores atípicos en inserciones o actualizaciones críticas.

Enriquecer registros con métricas derivadas o flags analíticos.

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

Diseñar reglas de validación estadística explicables y testeables.

Crear mecanismos de bypass controlado para cargas masivas autorizadas.

Medir impacto de triggers en operaciones de escritura.

Realizar ejercicio de trigger de auditoría con detección de anomalías.

Comprender cuándo un agregado PL/R aporta valor frente a agregados SQL nativos.

Diseñar agregados para métricas estadísticas específicas.

Calcular medias robustas, percentiles, dispersiones, scores o indicadores propios.

Validar comportamiento con nulos, valores extremos y datasets pequeños.

Comparar resultados frente a funciones nativas de PostgreSQL.

Documentar fórmula, supuestos estadísticos, límites y coste.

Evitar agregados PL/R para cálculos que SQL ya resuelve de forma eficiente.

Crear pruebas de precisión y regresión para agregados críticos.

Medir rendimiento sobre volúmenes representativos.

Realizar ejercicio de agregado PL/R para métrica estadística corporativa.

Comprender el uso de funciones de ventana PL/R en análisis avanzado.

Diseñar cálculos por grupos, particiones, ventanas móviles o series temporales.

Aplicar rankings, desviaciones, z-scores, tendencias y comparativas por segmento.

Gestionar orden, partición, tamaño de ventana y valores nulos.

Comparar window functions PL/R frente a funciones ventana nativas de PostgreSQL.

Evitar cálculos innecesariamente complejos dentro de consultas críticas.

Documentar supuestos de orden y partición.

Crear pruebas con particiones pequeñas, grandes y vacías.

Medir impacto en planes de consulta y memoria.

Realizar ejercicio de análisis por particiones usando PL/R.

Calcular métricas descriptivas: media, mediana, desviación, varianza, percentiles y rangos.

Crear perfiles de calidad de datos por columna, tabla o segmento.

Detectar valores ausentes, duplicados, valores extremos y distribuciones anómalas.

Generar indicadores de completitud, consistencia, unicidad y validez.

Preparar resultados para BI, auditoría o reporting de calidad.

Comparar cálculo en PL/R frente a vistas materializadas, SQL o pipelines externos.

Evitar análisis estadístico en transacciones críticas.

Documentar fórmula, población analizada y frecuencia recomendada.

Crear tests con datasets controlados.

Realizar ejercicio de función PL/R para perfilado de calidad de datos.

Aplicar reglas de outlier basadas en z-score, IQR, percentiles o umbrales dinámicos.

Crear funciones de scoring deterministas y explicables.

Clasificar registros por riesgo bajo, medio, alto o crítico.

Ajustar reglas según segmento, categoría, producto, zona o periodo.

Evitar modelos opacos sin trazabilidad ni validación.

Documentar fórmula, pesos, umbrales y casos excepcionales.

Crear tests de regresión para asegurar estabilidad del scoring.

Medir coste de aplicar scoring por fila o por lote.

Preparar outputs útiles para reporting, alertas o procesos de negocio.

Realizar ejercicio de scoring de anomalías sobre transacciones simuladas.

Procesar datos temporales con R dentro de PostgreSQL.

Calcular medias móviles, variaciones, tendencias, estacionalidad simple y cambios abruptos.

Gestionar fechas, huecos, valores ausentes y granularidad temporal.

Comparar funciones R frente a SQL window functions y extensiones especializadas.

Evitar cálculos de series masivos en funciones fila a fila.

Diseñar análisis por lote cuando el volumen lo exige.

Documentar frecuencia, ventana, periodo base y criterios de alerta.

Crear resultados tabulares para dashboards o procesos de monitorización.

Medir rendimiento sobre datasets temporales representativos.

Realizar ejercicio de detección de cambios en serie temporal con PL/R.

Evaluar cuándo un modelo estadístico ligero puede ejecutarse en PL/R.

Crear regresiones simples, clasificaciones básicas o reglas paramétricas controladas.

Separar entrenamiento, validación y ejecución de scoring.

Evitar entrenar modelos pesados dentro de funciones llamadas por usuarios.

Cargar parámetros de modelo desde tablas controladas.

Documentar versión del modelo, variables, supuestos y métricas de validación.

Comparar PL/R frente a servicios ML, notebooks, pipelines o extensiones analíticas.

Crear pruebas de equivalencia entre scoring PL/R y modelo externo.

Medir latencia y coste por predicción.

Realizar ejercicio de scoring con parámetros de modelo almacenados en PostgreSQL.

Instalar y usar paquetes R permitidos en entornos PL/R controlados.

Diferenciar paquetes base, paquetes recomendados y paquetes externos.

Revisar licencias, mantenimiento, vulnerabilidades y compatibilidad de paquetes.

Controlar rutas de librerías R, versiones y disponibilidad por entorno.

Evitar paquetes pesados o con dependencias del sistema dentro del servidor PostgreSQL.

Crear allowlist corporativa de paquetes R permitidos.

Documentar cada paquete usado por función, versión y propósito.

Preparar builds reproducibles con librerías fijadas.

Crear proceso de actualización, revisión y rollback de paquetes.

Realizar ejercicio de auditoría de dependencias R usadas por funciones PL/R.

Comprender cómo PL/R permite cargar módulos R al inicializar el intérprete.

Crear y gestionar la tabla `plr_modules` cuando el entorno lo permite.

Definir módulos reutilizables para funciones comunes, validaciones o métricas.

Controlar orden de carga mediante secuencia.

Evitar cargar código no revisado o dependencias ocultas.

Documentar funciones globales instaladas en el intérprete R.

Probar impacto de módulos sobre sesiones, errores y memoria.

Crear proceso de revisión antes de actualizar módulos cargados globalmente.

Separar módulos de utilidades frente a lógica de negocio específica.

Realizar ejercicio de módulo R compartido para varias funciones PL/R.

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

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

Comparar SQL nativo, PL/pgSQL, PL/R y procesos R externos.

Evitar funciones llamadas por fila sobre tablas grandes sin benchmark.

Revisar volatilidad, coste declarado y efecto sobre el optimizador.

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

Controlar memoria al crear vectores, matrices, data frames o modelos temporales.

Detectar cuellos de botella por SPI repetitivo, librerías pesadas o triggers lentos.

Crear benchmarks reproducibles con datasets representativos.

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

Comprender que una función PL/R 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 cálculos estadísticos pesados dentro de triggers o transacciones críticas.

Revisar bloqueos provocados por consultas internas o escrituras desde PL/R.

Diseñar funciones idempotentes y reintentables cuando el proceso lo requiere.

Evitar estado global R que produzca resultados impredecibles entre llamadas.

Probar funciones con sesiones concurrentes y cargas simultáneas.

Documentar comportamiento transaccional de funciones críticas.

Crear estrategia de rollback, recuperación y reejecución.

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

Usar mecanismos de logging y mensajes disponibles desde PL/R.

Crear mensajes claros para DBA, desarrollo, data engineering y soporte.

Gestionar errores R con `tryCatch` y validaciones defensivas.

Diferenciar errores de datos, estadística, tipos, SQL, permisos y sistema.

Evitar ocultar errores que dejan datos incoherentes o métricas incorrectas.

No exponer datos sensibles en mensajes de error o logs.

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

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

Probar errores esperados, entradas inválidas y casos límite.

Realizar ejercicio de hardening de errores en funciones PL/R.

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

Probar nulos, arrays, data frames, tipos compuestos, errores y valores extremos.

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

Crear datasets estadísticos controlados para pruebas reproducibles.

Comparar resultados con scripts R externos o implementación SQL de referencia.

Automatizar pruebas mediante scripts SQL, pgTAP, R scripts o pipeline propio.

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

Crear pruebas específicas de permisos, datos sensibles y funciones privilegiadas.

Medir estabilidad estadística de resultados ante cambios de paquetes o versiones R.

Realizar ejercicio de suite de tests para funciones, triggers y métricas PL/R.

Organizar funciones PL/R en scripts SQL versionados.

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

Gestionar cambios de firma, tipo de retorno, permisos, triggers, módulos 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/R, R, paquetes y sistema operativo.

Crear release notes para funciones críticas y cambios estadísticos.

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

Coordinar revisión con DBA, datos, seguridad, plataforma y arquitectura.

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

Crear contenedor PostgreSQL con R y PL/R disponible.

Instalar R, paquetes, headers, `R_HOME`, `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 `plr`, R y paquetes antes de aplicar funciones.

Gestionar configuración y secretos sin incrustarlos en funciones.

Publicar reportes de tests, logs de migración, benchmarks y documentación.

Evitar dependencias manuales difíciles de reproducir.

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

Registrar errores, tiempos y frecuencia de funciones PL/R 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 procesos analíticos.

Relacionar función, tabla, owner, paquete R, proceso y criticidad.

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

Crear runbooks para errores de extensión, `R_HOME`, paquetes, permisos y rendimiento.

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

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

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

Crear inventario de funciones, triggers, agregados, módulos, paquetes y permisos.

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

Analizar dependencias entre funciones, vistas, jobs, informes y procesos 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, analítica y responsables de negocio.

Priorizar quick wins frente a migraciones complejas.

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

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

Migrar validaciones complejas a PL/Python o PL/Rust cuando encaja mejor.

Mover análisis pesados a scripts R externos, pipelines, notebooks, jobs o servicios analíticos.

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 estadísticas, funcionales y operativas.

Preparar rollback por función migrada.

Realizar ejercicio de migración de función PL/R a PL/pgSQL o proceso R externo.

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

Crear estándar de naming, estructura, documentación, errores, SPI, paquetes 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, datos, plataforma y arquitectura.

Crear catálogo corporativo de funciones PL/R.

Revisar periódicamente permisos, `SECURITY DEFINER`, paquetes R y funciones críticas.

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

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

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

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

Analizar métricas estadísticas donde R aporta expresividad y precisión.

Revisar triggers de auditoría y alternativas nativas.

Evaluar normalización de datos maestros, outliers, scoring y perfilado de calidad.

Desaconsejar llamadas externas desde funciones de base de datos.

Desaconsejar entrenamiento de modelos pesados dentro de PostgreSQL.

Identificar casos donde SQL, PL/Python, PL/Rust o procesos externos 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 datos analíticos, funciones PL/R y tablas de negocio.

Crear entorno reproducible con Docker, PostgreSQL, R, PL/R, paquetes, esquemas y datos de prueba.

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

Crear inventario de funciones, triggers, agregados, módulos, owners y dependencias.

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

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

Implementar función sobre arrays para calcular métricas estadísticas robustas.

Implementar función set-returning para devolver resultados tabulares desde un análisis R.

Crear función con SPI para consultar tabla auxiliar de reglas o parámetros.

Optimizar consulta interna usando plan preparado cuando el caso lo justifique.

Implementar función para detección de outliers usando z-score, IQR o percentiles.

Implementar función de scoring con pesos, umbrales y explicación de resultado.

Crear trigger `BEFORE` para validación estadística o normalización controlada.

Crear trigger `AFTER` para auditoría de cambios relevantes.

Crear agregado PL/R o función de ventana para una métrica analítica específica.

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

Crear tests SQL y R para funciones, triggers, métricas, 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, valor analítico, gobierno y estrategia de modernización.