Curso de PL/Java

Revisar qué son los procedural languages en PostgreSQL y cómo se integran con el motor.

Entender que PL/Java no forma parte de la distribución base de PostgreSQL y se instala como extensión externa.

Diferenciar lenguajes core, lenguajes externos, extensiones, handlers y librerías compartidas.

Revisar cómo PostgreSQL delega la ejecución de funciones a un handler de lenguaje.

Comparar lenguajes trusted, untrusted y modelos de permisos.

Entender el papel del esquema `sqlj` dentro de PL/Java.

Revisar cómo se almacenan JARs, descriptores y classpaths dentro de PostgreSQL.

Identificar qué responsabilidades recaen en DBA, desarrollo, plataforma y seguridad.

Evitar adoptar PL/Java por familiaridad con Java sin revisar alternativa SQL o backend.

Realizar ejercicio de comparación entre PL/pgSQL, PL/Python, PL/Rust, PL/Java y servicio externo.

Preparar entorno PostgreSQL de laboratorio sin datos productivos.

Instalar PL/Java desde paquete disponible o build controlado.

Configurar ubicación de `libjvm` mediante `pljava.libjvm_location`.

Configurar `pljava.module_path` para que PostgreSQL encuentre módulos y JARs necesarios.

Habilitar la extensión con `CREATE EXTENSION pljava` en una sesión adecuada.

Verificar creación de lenguajes `java` y `javau`.

Comprobar disponibilidad del esquema `sqlj` y funciones auxiliares de instalación.

Ejecutar primera función Java de prueba para validar carga de JVM y classpath.

Diagnosticar errores comunes de rutas, permisos, JVM, librerías nativas y sesión.

Realizar ejercicio de instalación completa y validación funcional de PL/Java.

Comprender cómo PL/Java carga la JVM dentro del backend de PostgreSQL.

Analizar qué significa ejecutar Java en el proceso asociado a una conexión.

Revisar implicaciones de memoria, classloading, threads, lifecycle y errores.

Diferenciar JVM de aplicación externa y JVM embebida en servidor de base de datos.

Gestionar limitaciones operativas al cargar una JVM dentro de PostgreSQL.

Evitar patrones Java propios de aplicaciones servidor que no encajan dentro de la base.

Analizar riesgos de librerías con hilos, IO, red, caches globales o estado mutable.

Definir límites de uso para código Java ejecutado en funciones SQL.

Documentar configuración JVM necesaria por entorno.

Realizar ejercicio de análisis de impacto JVM en un servidor PostgreSQL.

Diferenciar `LANGUAGE java` y `LANGUAGE javau` desde la perspectiva de permisos y seguridad.

Comprender quién puede crear funciones en cada lenguaje según configuración.

Revisar el principio de mínimo privilegio en creación y ejecución de funciones PL/Java.

Analizar acceso a ficheros, red, propiedades del sistema y recursos externos.

Revisar política de seguridad de PL/Java y su relación con versiones de Java.

Evaluar implicaciones de ejecutar PL/Java con o sin policy enforcement.

Tratar con especial cuidado escenarios Java 24+ donde cambian las condiciones de seguridad.

Crear matriz de permisos por rol: DBA, deployer, developer, auditor y usuario de aplicación.

Evitar conceder `USAGE` amplio sin revisión de riesgos.

Realizar ejercicio de diseño de política segura para `java` y `javau`.

Crear proyecto Maven para empaquetar funciones PL/Java.

Definir `groupId`, `artifactId`, versión, paquetes Java y estructura de carpetas.

Añadir dependencias necesarias sin incluir librerías innecesarias.

Configurar compilación, tests, JAR final y recursos de despliegue.

Separar código de funciones, clases auxiliares, tests y descriptors.

Crear perfiles Maven para desarrollo, test y release.

Documentar versión de Java, PL/Java, PostgreSQL y dependencias del proyecto.

Evitar builds manuales no reproducibles.

Preparar naming corporativo de artefactos JAR.

Realizar ejercicio de proyecto Maven preparado para PL/Java.

Comprender cómo las anotaciones de PL/Java exponen métodos Java a PostgreSQL.

Usar anotaciones para definir funciones, tipos SQL, nombres, esquemas y contratos.

Entender el SQLJ deployment descriptor generado durante la compilación.

Revisar cómo el descriptor contiene instrucciones de instalación y desinstalación.

Relacionar clases Java, métodos anotados, SQL generado y funciones disponibles.

Crear documentación entre método Java y función SQL resultante.

Evitar descriptores opacos sin revisión de lo que instalarán en la base.

Revisar compatibilidad entre anotaciones, JAR y versión de PL/Java.

Preparar inspección del descriptor antes de despliegue.

Realizar ejercicio de función anotada y revisión del SQLJ descriptor generado.

Empaquetar clases Java y descriptor SQLJ dentro de un JAR.

Instalar JAR en PostgreSQL usando `sqlj.install_jar`.

Actualizar JAR instalado con versiones nuevas de código.

Eliminar JARs obsoletos de forma controlada.

Configurar classpath con `sqlj.set_classpath` por esquema.

Entender cómo el classpath afecta a la resolución de clases Java.

Gestionar varios JARs, versiones, dependencias y esquemas.

Evitar colisiones de clases y dependencias entre aplicaciones.

Documentar JARs instalados, versión, owner, funciones y dependencias.

Realizar ejercicio de instalación, actualización y retirada de un JAR PL/Java.

Crear métodos Java `public static` invocables como funciones SQL.

Definir argumentos SQL y tipos Java compatibles.

Devolver valores escalares, nulos, estructuras y colecciones según contrato.

Gestionar excepciones Java y su traducción a errores PostgreSQL.

Crear funciones pequeñas, puras y con responsabilidad clara.

Marcar volatilidad, coste, seguridad y comportamiento esperado desde SQL.

Evitar funciones que mezclan validación, consultas, escritura y logging sin separación.

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

Comparar función Java con equivalente PL/pgSQL o SQL nativo.

Realizar ejercicio de funciones escalares PL/Java para validación y cálculo.

Mapear tipos PostgreSQL hacia tipos Java: texto, enteros, decimales, booleanos, fechas y timestamps.

Gestionar `NULL` mediante objetos, wrappers y control explícito.

Evitar problemas con tipos primitivos cuando la entrada puede ser nula.

Tratar `BigDecimal` para precisión financiera o científica.

Trabajar con fechas y horas sin introducir errores de zona horaria.

Gestionar conversiones de caracteres, encoding y normalización Unicode.

Devolver tipos compatibles con la firma SQL declarada.

Crear validaciones de entrada antes de ejecutar lógica compleja.

Documentar supuestos de precisión, formatos y límites.

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

Recibir arrays PostgreSQL y convertirlos en estructuras Java manejables.

Procesar colecciones de textos, números, identificadores, estados o códigos.

Devolver arrays cuando el contrato SQL lo requiere.

Gestionar arrays vacíos, valores nulos internos y tamaños inesperados.

Crear resultados tabulares mediante patrones compatibles con PL/Java.

Usar iteradores o result sets cuando se devuelven múltiples filas.

Evitar cargar grandes colecciones completas en memoria sin necesidad.

Comparar procesamiento en Java frente a SQL set-based.

Crear pruebas de límites para colecciones grandes.

Realizar ejercicio de función PL/Java que normaliza y deduplica arrays.

Trabajar con tipos compuestos definidos en PostgreSQL.

Crear funciones que devuelven varias columnas con contrato claro.

Representar registros en Java de forma legible y segura.

Diseñar estructuras de retorno para reporting, validación o APIs internas.

Evitar devolver JSON cuando el resultado natural es relacional.

Documentar nombres, tipos, orden y significado de columnas devueltas.

Tratar casos de nulos, campos opcionales y valores calculados.

Crear tests de estructura y datos esperados.

Comparar tipos compuestos con tablas temporales, vistas o JSONB.

Realizar ejercicio de función que devuelve resultado estructurado.

Procesar JSON almacenado como texto o JSONB desde funciones PL/Java.

Usar librerías Java aprobadas para parsing cuando el entorno lo permite.

Validar claves, tipos, estructuras, arrays anidados y campos obligatorios.

Crear funciones de normalización de payloads procedentes de APIs o integraciones.

Comparar uso de operadores JSONB nativos frente a procesamiento Java.

Evitar procesar grandes volúmenes JSON fila a fila si PostgreSQL puede hacerlo mejor.

Gestionar errores de JSON inválido con mensajes claros.

Diseñar salida relacional o JSON normalizado según el caso.

Documentar esquema esperado y criterios de aceptación.

Realizar ejercicio de validación y transformación JSON con PL/Java.

Comprender cómo PL/Java proporciona una conexión JDBC interna al backend PostgreSQL.

Ejecutar consultas SQL desde métodos Java usando JDBC.

Usar `PreparedStatement` para parametrizar consultas de forma segura.

Leer `ResultSet` y transformar resultados en valores de retorno.

Ejecutar inserts, updates o deletes solo cuando la arquitectura lo justifica.

Evitar concatenación SQL con datos de usuario.

Gestionar excepciones `SQLException` y errores de negocio.

Evitar ejecutar consultas internas por cada fila si puede resolverse con SQL set-based.

Documentar dependencias de tablas, vistas, esquemas y permisos.

Realizar ejercicio de función PL/Java que consulta reglas auxiliares con JDBC.

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

Analizar impacto de errores Java sobre rollback de la transacción.

Gestionar operaciones internas de JDBC sin romper consistencia transaccional.

Evitar commits, rollbacks o patrones propios de aplicaciones externas donde no proceden.

Usar savepoints o patrones equivalentes cuando se necesita recuperación parcial.

Diseñar funciones que fallan de forma predecible y trazable.

Analizar cómo triggers PL/Java afectan a operaciones de inserción, actualización y borrado.

Evitar llamadas lentas dentro de transacciones abiertas.

Documentar comportamiento transaccional de funciones críticas.

Realizar ejercicio de función con error controlado y análisis de rollback.

Crear funciones Java que actúan como triggers PostgreSQL.

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

Acceder a datos de fila antigua, fila nueva, tabla, operación y contexto del trigger.

Modificar valores antes de insertar o actualizar cuando procede.

Rechazar operaciones que incumplen validaciones críticas.

Registrar eventos de auditoría después de cambios relevantes.

Evitar triggers pesados en tablas de alta escritura.

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

Crear pruebas para INSERT, UPDATE, DELETE, rollback y cargas masivas.

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

Diseñar auditoría de cambios con usuario, timestamp, operación, tabla y valores relevantes.

Detectar diferencias entre estado anterior y nuevo.

Validar reglas complejas no cubiertas por constraints simples.

Normalizar datos antes de persistirlos.

Enriquecer registros con información derivada controlada.

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

Diseñar triggers compatibles con cargas batch y procesos de mantenimiento.

Crear mecanismos de bypass controlado para operaciones autorizadas.

Medir impacto de auditoría en rendimiento.

Realizar ejercicio de auditoría avanzada con trigger PL/Java.

Comprender capacidades avanzadas de PL/Java más allá de funciones simples.

Evaluar cuándo tiene sentido crear agregados personalizados.

Diseñar lógica de agregación con estado, entrada, combinación y resultado final.

Revisar creación de tipos u operadores cuando el dominio lo justifica.

Comparar extensibilidad con SQL, C, pgrx o extensiones existentes.

Evitar desarrollar tipos avanzados si solo se necesita una función puntual.

Documentar comportamiento, límites y casos de uso de agregados personalizados.

Medir rendimiento frente a agregados nativos de PostgreSQL.

Preparar pruebas de exactitud y regresión.

Realizar ejercicio conceptual de agregado PL/Java para cálculo especializado.

Revisar dependencias Java incluidas o referenciadas por JARs PL/Java.

Analizar licencias, vulnerabilidades, tamaño, mantenimiento y compatibilidad.

Controlar classpath por esquema para evitar conflictos entre aplicaciones.

Evitar librerías que crean hilos, abren conexiones, escriben ficheros o hacen IO no autorizado.

Definir allowlist de dependencias aprobadas.

Bloquear versiones con Maven y documentar hashes o artefactos usados.

Revisar impacto de dependencias transitivas.

Integrar análisis de vulnerabilidades en CI/CD.

Evitar subir JARs sin trazabilidad de build.

Realizar ejercicio de auditoría de dependencias de un JAR PL/Java.

Comprender el impacto de la evolución de Java sobre el modelo histórico de seguridad.

Revisar qué ocurre cuando PL/Java se ejecuta con Java 24 o superior.

Analizar implicaciones de policy enforcement frente a ejecución sin enforcement.

Definir estrategia corporativa de versión Java soportada.

Evaluar si conviene fijar Java 17 o 21 LTS para estabilidad y soporte.

Documentar configuración JVM y restricciones por entorno.

Probar funciones PL/Java después de actualizar Java.

Evitar cambios de versión de Java sin pruebas de regresión y revisión de seguridad.

Crear plan de actualización con DBA, plataforma y seguridad.

Realizar ejercicio de análisis de impacto de actualización de Java en PL/Java.

Medir coste de funciones PL/Java dentro de consultas SQL reales.

Usar `EXPLAIN` y `EXPLAIN ANALYZE` para detectar impacto de funciones.

Comparar rendimiento frente a SQL nativo, PL/pgSQL, PL/Python, PL/Rust y servicio Java externo.

Evitar llamadas por fila sobre tablas grandes sin benchmark.

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

Optimizar parsing, conversión de tipos, consultas internas y estructuras intermedias.

Evitar carga innecesaria de clases o inicializaciones pesadas.

Medir memoria, CPU, latencia y bloqueos asociados.

Crear benchmarks reproducibles con datos representativos.

Realizar ejercicio de optimización de función PL/Java en consulta intensiva.

Analizar cómo funciones PL/Java interactúan con sesiones concurrentes.

Revisar riesgos de estado estático mutable en clases Java cargadas.

Evitar caches globales sin control, sincronización o invalidación.

Diseñar funciones thread-safe cuando el entorno lo requiere.

Identificar deadlocks por consultas internas o triggers mal diseñados.

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

Evitar operaciones IO o red dentro de transacciones críticas.

Crear pruebas de concurrencia con cargas simultáneas.

Documentar comportamiento esperado bajo carga.

Realizar ejercicio de diagnóstico de bloqueo provocado por trigger PL/Java.

Crear tests unitarios Java para lógica pura antes de empaquetarla en JAR.

Crear tests SQL para funciones PL/Java instaladas en PostgreSQL.

Validar entradas normales, nulas, inválidas, límites y errores esperados.

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

Comparar resultados con implementación de referencia en SQL o Java externo.

Usar contenedores para ejecutar tests en bases limpias.

Automatizar instalación de JAR, classpath y migraciones en tests.

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

Crear fixtures y datasets representativos.

Realizar ejercicio de suite completa de tests Java + SQL.

Versionar código Java, SQLJ descriptors, scripts SQL y migraciones.

Gestionar cambios de firma, tipo de retorno, esquema, permisos y JAR.

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

Instalar, actualizar y retirar JARs con procedimientos reproducibles.

Coordinar `install_jar`, `replace_jar`, `remove_jar` y classpath por esquema.

Preparar rollback cuando una versión de JAR falla.

Evitar reemplazar JARs en producción sin tests y plan de reversión.

Documentar versión de PostgreSQL, Java, PL/Java, Maven y dependencias.

Crear release notes para funciones críticas.

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

Crear imagen Docker con PostgreSQL, PL/Java, JDK y Maven.

Preparar Docker Compose con base, extensión, esquemas, datos y tests.

Compilar JAR en pipeline y desplegarlo en una base temporal.

Ejecutar tests Java y SQL como parte del CI/CD.

Validar classpath, instalación de JAR y funciones expuestas.

Integrar análisis de dependencias y vulnerabilidades.

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

Gestionar secretos sin incrustarlos en código Java ni scripts SQL.

Publicar artefactos JAR, reportes de tests y documentación.

Realizar ejercicio de pipeline completo para PL/Java.

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

Diseñar mensajes útiles para DBA, desarrollo y soporte.

Integrar logs PostgreSQL con sistemas corporativos de observabilidad.

Medir impacto de funciones en consultas lentas y bloqueos.

Crear tablas de auditoría para triggers críticos.

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

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

Crear runbooks para errores de JVM, classpath, JAR, permisos y rendimiento.

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

Realizar ejercicio de diagnóstico operativo de una incidencia PL/Java.

Definir si PL/Java se permite para nuevo desarrollo, mantenimiento o solo sistemas legacy.

Crear catálogo de funciones, triggers, JARs, classpaths, owners y dependencias.

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

Establecer revisión obligatoria por DBA, backend, seguridad y arquitectura.

Crear estándar de naming, empaquetado, documentación, tests y despliegue.

Definir política de dependencias Java aprobadas.

Revisar permisos de `java`, `javau`, esquemas y roles.

Crear ciclo de vida: propuesta, desarrollo, test, aprobación, despliegue, mantenimiento y retirada.

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

Realizar ejercicio de política corporativa de uso de PL/Java.

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

Migrar parsing o validación compleja a PL/Python o PL/Rust cuando encaja mejor.

Mover lógica de negocio extensa a servicios Java externos, jobs o APIs.

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, shadow run, 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/Java a PL/pgSQL o servicio Java externo.

Diagnosticar errores de `CREATE EXTENSION pljava` por sesión, rutas, librerías o configuración.

Resolver fallos de `pljava.libjvm_location` y carga de JVM.

Corregir problemas de `pljava.module_path` y módulos no encontrados.

Investigar errores de `install_jar`, classpath, descriptor SQLJ o clases ausentes.

Corregir tipos de retorno incompatibles entre SQL y Java.

Diagnosticar excepciones Java propagadas a PostgreSQL.

Resolver conflictos de dependencias o versiones de JAR.

Analizar degradaciones por SPI/JDBC repetitivo o triggers pesados.

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

Realizar ejercicio de reparación de entorno PL/Java con fallos provocados.

Diseñar validación de datos maestros con reglas complejas y reutilizables.

Normalizar textos, identificadores, códigos, referencias y formatos heredados.

Procesar estructuras JSON o payloads de integraciones empresariales.

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

Implementar cálculos especializados ya existentes en librerías Java internas.

Apoyar migración de lógica histórica desde bases o aplicaciones Java legacy.

Crear funciones de scoring o clasificación ligera con reglas deterministas.

Integrar lógica cercana al dato sin abrir llamadas de red desde PostgreSQL.

Evaluar cada caso frente a SQL, PL/pgSQL, PL/Python, PL/Rust y servicio externo.

Realizar ejercicio de clasificación de casos viables, dudosos y no recomendables.

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

Preparar entorno reproducible con PostgreSQL, PL/Java, JDK, Maven, Docker y datos de prueba.

Configurar `pljava.libjvm_location`, `pljava.module_path` y `CREATE EXTENSION pljava`.

Crear roles, esquemas, permisos y política mínima para `java` y `javau`.

Crear proyecto Maven con paquetes Java, tests, dependencias y build reproducible.

Implementar función escalar Java para normalización de textos, códigos o identificadores.

Implementar función Java para validación de JSON o estructura semiestructurada.

Implementar función que devuelve resultado estructurado o tabular.

Usar JDBC interno para consultar tabla auxiliar con `PreparedStatement`.

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 robusta de excepciones, mensajes claros y sin exposición de datos sensibles.

Generar JAR con SQLJ deployment descriptor y revisar instrucciones de instalación.

Instalar JAR mediante `sqlj.install_jar` y configurar classpath con `sqlj.set_classpath`.

Crear tests unitarios Java y tests SQL de integración sobre funciones y triggers.

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

Revisar dependencias Java, licencias, vulnerabilidades, classpath y riesgos de seguridad.

Preparar scripts de migración, actualización, rollback y retirada del JAR.

Documentar arquitectura, funciones, triggers, permisos, JARs, classpath, runbook y troubleshooting.

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