Curso de PL/Rust

Entender que PL/Rust se apoya en pgrx para integrarse con PostgreSQL.

Diferenciar una función `LANGUAGE plrust` de una extensión completa desarrollada con pgrx.

Comprender el concepto de función PL/Rust como mini-extensión compilada.

Revisar cómo PostgreSQL almacena definición, metadatos y código compilado de funciones.

Analizar el flujo de creación, compilación, carga y ejecución de una función PL/Rust.

Identificar dependencias entre PL/Rust, rustc, pgrx, `plrust-trusted-pgrx` y PostgreSQL.

Comprender qué partes del ecosistema Rust quedan expuestas al usuario PL/Rust.

Diferenciar desarrollo de funciones de base de datos frente a desarrollo de extensiones nativas.

Evitar confundir PL/Rust con escribir cualquier crate Rust dentro de PostgreSQL sin restricciones.

Realizar ejercicio de mapa arquitectónico PL/Rust, PostgreSQL, pgrx y funciones compiladas.

Preparar un entorno PostgreSQL de laboratorio sin datos productivos.

Instalar dependencias necesarias de Rust, Cargo, PostgreSQL y herramientas de compilación.

Configurar PL/Rust en una instancia local o contenedor Docker.

Revisar requisitos de `shared_preload_libraries` y directorios de trabajo de PL/Rust.

Crear una base de datos de prácticas, esquemas, roles y permisos controlados.

Verificar que `LANGUAGE plrust` está disponible y operativo.

Crear la primera función PL/Rust mínima y ejecutarla desde SQL.

Diagnosticar errores de instalación, rutas, toolchain, permisos, targets o librerías.

Documentar instalación para que pueda reproducirse por sistemas o DevOps.

Realizar ejercicio de entorno PL/Rust reproducible desde cero.

Comprender qué significa que PL/Rust pueda operar como lenguaje trusted.

Revisar el papel de `postgrestd` como entorno Rust especializado para PostgreSQL.

Entender las limitaciones de trusted mode según arquitectura y sistema operativo.

Diferenciar instalación trusted y untrusted desde la perspectiva de seguridad.

Analizar qué accesos quedan restringidos en trusted mode.

Comprender por qué PL/Rust bloquea `unsafe` en funciones de usuario.

Revisar el impacto de crates de terceros que internamente pueden usar código unsafe.

Diseñar política de aprobación de PL/Rust por tipo de entorno.

Evitar dar permisos de creación de funciones PL/Rust a roles no revisados.

Realizar ejercicio de análisis de riesgo de función PL/Rust trusted y untrusted.

Repasar sintaxis básica de Rust aplicada a funciones PostgreSQL.

Usar variables, mutabilidad, tipos, inferencia, referencias y control de flujo.

Trabajar con `Option<T>` para representar nulos y valores ausentes.

Trabajar con `Result<T, E>` para gestionar éxito, fallo y propagación de errores.

Comprender ownership, borrowing y lifetimes desde un enfoque práctico.

Usar `match`, `if let`, `unwrap_or`, `map`, `and_then` y patrones idiomáticos seguros.

Evitar `unwrap()` indiscriminado en funciones ejecutadas por la base de datos.

Escribir funciones pequeñas, claras y expresivas.

Aplicar formato, naming y estilo Rust mantenible.

Realizar ejercicio de Rust aplicado a entradas y salidas PostgreSQL.

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

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

Entender la estructura esperada del cuerpo Rust dentro de SQL.

Devolver `Ok(Some(valor))`, `Ok(None)` o errores según el contrato.

Gestionar funciones que aceptan valores nulos y funciones marcadas como `STRICT`.

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

Crear funciones pequeñas y reutilizables frente a bloques Rust excesivos.

Mantener el contrato SQL alineado con el tipo Rust devuelto.

Evitar cuerpos de función difíciles de revisar por DBA o seguridad.

Realizar ejercicio de varias funciones PL/Rust escalares.

Comprender cómo PL/Rust mapea tipos PostgreSQL a tipos Rust seguros.

Trabajar con `TEXT`, `VARCHAR`, `INT`, `BIGINT`, `REAL`, `DOUBLE PRECISION` y `BOOLEAN`.

Gestionar `NUMERIC` cuando se necesita precisión financiera o científica.

Trabajar con fechas, horas, timestamps e intervalos con criterios de conversión.

Representar nulos mediante `Option`.

Evitar pérdidas de precisión por conversiones inadecuadas.

Diseñar contratos de tipos claros para consumidores SQL.

Revisar errores típicos por retorno incompatible con la firma SQL.

Documentar tipos aceptados, límites y comportamiento ante entradas inválidas.

Realizar ejercicio de conversión segura entre tipos PostgreSQL y Rust.

Recibir arrays PostgreSQL y tratarlos como colecciones en Rust.

Procesar listas de valores numéricos, textos, identificadores o estados.

Devolver arrays desde funciones PL/Rust cuando el contrato lo requiere.

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

Aplicar operaciones de filtrado, transformación, deduplicación y agregación.

Comparar cuándo conviene usar SQL nativo frente a lógica Rust sobre arrays.

Diseñar funciones eficientes para colecciones pequeñas y medianas.

Evitar procesar arrays enormes sin medir memoria y tiempo.

Crear validaciones robustas sobre listas de entrada.

Realizar ejercicio de función PL/Rust para normalizar y deduplicar arrays.

Procesar documentos JSON y JSONB desde funciones PL/Rust.

Extraer claves, validar estructuras y transformar payloads semiestructurados.

Gestionar claves ausentes, valores nulos, tipos inesperados y arrays anidados.

Crear funciones para validar payloads de APIs almacenados en PostgreSQL.

Normalizar JSONB hacia estructuras relacionales o resultados tabulares.

Comparar el uso de operadores JSONB nativos frente a PL/Rust.

Evitar reimplementar en Rust lo que PostgreSQL resuelve mejor con índices JSONB.

Documentar schema esperado, claves obligatorias y errores posibles.

Crear mensajes claros cuando un JSONB no cumple contrato.

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

Trabajar con tipos compuestos definidos en PostgreSQL.

Devolver varios campos desde una función PL/Rust.

Diseñar contratos de retorno claros para reporting, APIs o procesos internos.

Procesar registros con estructura conocida y tipos controlados.

Convertir datos internos Rust en resultados compatibles con PostgreSQL.

Usar tipos compuestos para evitar JSON innecesario cuando el resultado es relacional.

Documentar orden, nombres y tipos de campos devueltos.

Evitar retornos opacos difíciles de consultar desde SQL.

Crear pruebas para validar estructura y contenido de resultados.

Realizar ejercicio de función que devuelve resultado estructurado.

Crear funciones PL/Rust que devuelven conjuntos de resultados.

Diferenciar funciones escalares, funciones tabulares y funciones set-returning.

Diseñar salidas para expandir datos, generar filas o transformar estructuras.

Controlar memoria cuando se generan muchos registros.

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

Comparar alternativas con funciones SQL, `jsonb_to_recordset` y PL/pgSQL.

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

Crear contratos de salida mantenibles para analítica y pipelines.

Documentar limitaciones de volumen y uso esperado.

Realizar ejercicio de expansión de JSONB o arrays a filas relacionales.

Comprender el Server Programming Interface de PostgreSQL desde PL/Rust.

Ejecutar consultas internas para leer datos auxiliares.

Insertar, actualizar o borrar registros desde una función PL/Rust cuando el diseño lo justifica.

Procesar resultados de consultas SPI dentro de código Rust.

Gestionar errores de consulta, tipos inesperados y resultados vacíos.

Evitar consultas internas dentro de bucles masivos sin estrategia de rendimiento.

Diseñar separación entre lógica Rust y SQL interno.

Documentar consultas SPI críticas y sus dependencias de esquema.

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

Realizar ejercicio de función que consulta tablas auxiliares mediante SPI.

Crear consultas preparadas desde PL/Rust para operaciones repetidas.

Parametrizar entradas de forma segura sin concatenar SQL peligroso.

Ejecutar prepared statements con distintos valores.

Usar cursors cuando el volumen de resultados exige procesamiento progresivo.

Diferenciar consulta dinámica, consulta parametrizada y plan preparado.

Evitar SQL injection en funciones que construyen consultas.

Medir impacto de planes preparados en funciones llamadas con frecuencia.

Gestionar cursores con control de errores y cierre correcto.

Documentar tipos de parámetros y objetivo de cada plan.

Realizar ejercicio de SPI con prepared statement y cursor controlado.

Usar mecanismos de logging de PL/Rust para comunicar avisos, información y errores.

Crear errores claros para usuario técnico y para operación.

Gestionar errores mediante `Result` sin provocar pánicos innecesarios.

Evitar `panic!` o `unwrap()` en funciones productivas.

Diferenciar errores de validación, datos, seguridad, rendimiento y sistema.

Crear mensajes que no filtren información sensible.

Registrar contexto suficiente para diagnosticar fallos.

Diseñar estrategia de error compatible con transacciones PostgreSQL.

Crear tests para entradas inválidas y errores esperados.

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

Crear funciones trigger con PL/Rust.

Diferenciar triggers `BEFORE`, `AFTER` e `INSTEAD OF`.

Diferenciar triggers por fila y por sentencia.

Acceder a información de fila antigua, fila nueva, tabla, operación y contexto.

Modificar valores antes de insertar o actualizar cuando procede.

Cancelar operaciones cuando una validación crítica falla.

Evitar triggers que ejecutan lógica pesada en operaciones frecuentes.

Documentar qué tablas dependen de cada trigger PL/Rust.

Crear estrategia de pruebas para triggers antes de producción.

Realizar ejercicio de trigger de normalización y validación de datos.

Crear auditoría de cambios relevantes usando triggers PL/Rust.

Registrar usuario, operación, timestamp, clave primaria y valores modificados.

Validar reglas complejas antes de permitir cambios.

Enriquecer registros con datos derivados o normalizados.

Detectar diferencias entre valor anterior y nuevo.

Controlar datos sensibles antes de guardarlos en auditoría.

Evitar auditorías que duplican información innecesaria o penalizan rendimiento.

Diseñar triggers compatibles con cargas masivas.

Crear mecanismos de mantenimiento para cargas autorizadas.

Realizar ejercicio de auditoría robusta con PL/Rust.

Comprender cuándo puede usarse una crate en funciones PL/Rust.

Diferenciar librerías estándar, crates aprobadas y crates prohibidas.

Revisar riesgos de dependencias: tamaño, mantenimiento, licencia, unsafe interno y supply chain.

Configurar allowlists de crates cuando el entorno lo permite.

Evaluar crates para regex, parsing, fechas, JSON, hashing, validación o cálculo.

Evitar dependencias pesadas para lógica que puede resolverse con Rust estándar.

Gestionar versiones de crates entre desarrollo, test y producción.

Documentar cada dependencia usada por funciones PL/Rust.

Crear proceso de aprobación de nuevas crates con seguridad y DBA.

Realizar ejercicio de revisión de crate antes de incorporarla a una función.

Comprender el papel de los lints en PL/Rust.

Revisar cómo se bloquea código `unsafe` en funciones de usuario.

Identificar patrones no permitidos o desaconsejados en código PL/Rust.

Aplicar estilo Rust idiomático para reducir errores.

Evitar macros, dependencias o patrones difíciles de auditar.

Diseñar funciones con complejidad limitada y responsabilidades claras.

Crear checklist de revisión de código Rust para base de datos.

Documentar excepciones y decisiones de seguridad.

Revisar código desde la perspectiva de compilador, DBA y equipo de seguridad.

Realizar ejercicio de corrección de una función que incumple buenas prácticas.

Medir rendimiento de funciones PL/Rust dentro de consultas reales.

Comparar SQL nativo, PL/pgSQL, PL/Python y PL/Rust en escenarios controlados.

Usar `EXPLAIN` y `EXPLAIN ANALYZE` para entender impacto en planes de consulta.

Definir coste y volatilidad de funciones con criterio.

Evitar llamadas por fila sobre tablas grandes sin medición.

Optimizar parsing, asignaciones, conversiones y estructuras intermedias.

Reducir trabajo duplicado mediante SQL previo, joins o procesamiento por lote.

Controlar uso de CPU, memoria y tiempo de compilación.

Crear benchmarks reproducibles con datasets realistas.

Realizar ejercicio de optimización de función PL/Rust usada masivamente.

Comprender cómo una función PL/Rust se ejecuta dentro de una transacción PostgreSQL.

Analizar impacto de funciones lentas en locks, latencia y concurrencia.

Evitar lógica bloqueante dentro de triggers críticos.

Diseñar operaciones SPI que respeten aislamiento y consistencia.

Gestionar concurrencia cuando varias sesiones invocan funciones sobre los mismos datos.

Evitar estado global mutable o comportamiento dependiente de ejecución previa.

Crear pruebas concurrentes para funciones críticas.

Detectar deadlocks provocados por triggers o consultas internas.

Documentar comportamiento transaccional esperado.

Realizar ejercicio de análisis de bloqueo y optimización de trigger PL/Rust.

Comprender particularidades de usar PL/Rust en Amazon RDS for PostgreSQL.

Revisar habilitación mediante parámetros, extensiones y permisos disponibles.

Diferenciar capacidades en entorno gestionado frente a instalación propia.

Diseñar funciones que respeten restricciones del proveedor cloud.

Controlar crates, configuración y acceso según políticas de la plataforma.

Preparar migraciones compatibles con desarrollo local y RDS.

Validar comportamiento en versiones soportadas antes de producción.

Evitar asumir permisos superuser completos en servicios gestionados.

Coordinar despliegue con DBAs cloud, seguridad y plataforma.

Realizar ejercicio de arquitectura PL/Rust para RDS o entorno gestionado.

Diferenciar PL/Rust como lenguaje procedural y pgrx como framework de extensiones Rust.

Identificar cuándo basta con una función PL/Rust.

Identificar cuándo conviene una extensión PostgreSQL completa con pgrx.

Comparar complejidad de despliegue, permisos, rendimiento, API y mantenimiento.

Revisar casos donde se necesita definir tipos, operadores, índices o hooks.

Evitar usar pgrx cuando una función PL/Rust simple resuelve el caso.

Evitar forzar PL/Rust cuando se necesita una extensión de bajo nivel.

Documentar criterios de arquitectura para elegir una opción.

Preparar matriz de decisión PL/pgSQL, PL/Rust, pgrx, C y backend externo.

Realizar ejercicio de clasificación de casos de uso según tecnología adecuada.

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

Validar nulos, errores, arrays, JSONB, registros, límites y casos extremos.

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

Crear datasets de prueba reproducibles.

Comparar resultados contra funciones SQL o implementaciones de referencia.

Usar contenedores para ejecutar pruebas en entornos limpios.

Integrar tests en pipelines CI/CD.

Evitar desplegar funciones compiladas sin pruebas de regresión.

Medir cobertura funcional de reglas críticas.

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

Organizar funciones PL/Rust en scripts SQL versionados.

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

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

Preparar despliegues repetibles para desarrollo, test, staging y producción.

Crear rollback cuando una función nueva falla o degrada rendimiento.

Evitar modificar funciones manualmente en producción.

Documentar versión de PostgreSQL, PL/Rust, Rust, crates y configuración usada.

Coordinar revisiones con DBA, backend, seguridad y data engineering.

Crear release notes para cambios de funciones críticas.

Realizar ejercicio de migración de versión de una función PL/Rust.

Crear contenedor PostgreSQL preparado para PL/Rust.

Instalar toolchain Rust y dependencias necesarias para compilar funciones.

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

Ejecutar tests automáticos en pipeline.

Validar que PL/Rust está instalado antes de aplicar migraciones.

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

Gestionar secretos mediante variables y mecanismos seguros del pipeline.

Publicar reportes de pruebas, benchmarks y validación.

Evitar pipelines dependientes de entornos manuales no reproducibles.

Realizar ejercicio de CI/CD para funciones PL/Rust con contenedor PostgreSQL.

Registrar uso de funciones críticas, errores, latencia y llamadas frecuentes.

Crear auditoría de cambios generados por triggers PL/Rust.

Medir impacto de funciones en consultas lentas.

Integrar logs PostgreSQL con herramientas corporativas de observabilidad.

Crear runbooks para errores de compilación, ejecución, permisos y rendimiento.

Definir alertas ante incremento de errores o degradación de latencia.

Evitar logs con datos personales, secretos o payloads sensibles.

Documentar relación entre función, tabla, proceso de negocio y owner.

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

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

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

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

Crear catálogo de funciones con owner, criticidad, datos tratados y dependencias.

Revisar código Rust antes de aprobar despliegue.

Aplicar política de crates permitidas y versionado de dependencias.

Clasificar funciones por riesgo: bajo, medio, alto y crítico.

Revisar datos sensibles tratados por cada función.

Definir controles para entornos trusted, untrusted y cloud.

Evitar proliferación de lógica Rust sin arquitectura ni ownership.

Realizar ejercicio de diseño de política corporativa para PL/Rust.

Crear validación de datos maestros con reglas complejas.

Normalizar identificadores, códigos, textos y estructuras semiestructuradas.

Procesar JSONB de eventos, APIs, formularios o integraciones.

Implementar scoring rápido sobre datos transaccionales.

Crear triggers de auditoría enriquecida en tablas críticas.

Aplicar parsing de cadenas técnicas, logs, referencias o codificaciones internas.

Generar resultados tabulares para reporting avanzado.

Apoyar procesos de migración, limpieza y conciliación de datos.

Evaluar cada caso frente a SQL, PL/pgSQL, PL/Python, pgrx y servicios externos.

Realizar ejercicio de selección de casos viables y no viables para PL/Rust.

Diagnosticar errores de instalación, extensión, lenguaje no disponible o configuración incompleta.

Resolver fallos de compilación Rust dentro de `CREATE FUNCTION`.

Corregir errores por tipos de retorno incompatibles.

Investigar problemas con `Option`, nulos, arrays y JSONB inesperado.

Resolver errores de crates no autorizadas o no disponibles.

Detectar funciones que compilan pero fallan al ejecutarse con datos reales.

Analizar rendimiento deficiente por llamadas fila a fila o SPI repetitivo.

Resolver triggers que se ejecutan en momento incorrecto o generan efectos no deseados.

Crear checklist de diagnóstico antes de escalar a DBA o plataforma.

Realizar ejercicio de reparación de funciones PL/Rust con fallos provocados.

Diseñar una solución PostgreSQL con PL/Rust para validación, transformación, auditoría y procesamiento avanzado.

Crear entorno reproducible con PostgreSQL, PL/Rust, Rust toolchain, datos de prueba y scripts de inicialización.

Configurar roles, esquemas, permisos y extensión PL/Rust en base de datos de laboratorio.

Implementar funciones escalares PL/Rust para normalización de textos, códigos o identificadores.

Implementar funciones con arrays para limpiar, validar, deduplicar y transformar colecciones.

Implementar función sobre JSONB para validar payloads, extraer campos y devolver errores claros.

Implementar función con tipo compuesto o retorno tabular para generar resultados estructurados.

Usar SPI para consultar tablas auxiliares y aplicar reglas de negocio parametrizadas.

Crear prepared statement para una consulta repetida y segura.

Implementar trigger `BEFORE` para validar y modificar datos antes de inserción o actualización.

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

Añadir gestión de errores robusta mediante `Result`, mensajes claros y sin `unwrap()` innecesario.

Revisar seguridad de código, permisos, crates, trusted mode y datos tratados.

Medir rendimiento con `EXPLAIN ANALYZE` y comparar con SQL o PL/pgSQL cuando aplique.

Crear tests unitarios e integración para funciones, triggers, casos límite y errores esperados.

Preparar scripts de migración versionados para instalar, actualizar y retirar funciones.

Crear entorno Docker o pipeline local para ejecutar pruebas de forma reproducible.

Documentar arquitectura, contratos de funciones, dependencias, riesgos, permisos y runbook operativo.

Crear informe de gobierno con owners, criticidad, revisión de crates, métricas y mantenimiento.

Presentar la solución final defendiendo seguridad, rendimiento, trazabilidad, mantenibilidad y valor empresarial.