Curso de PL/Python

Instalar PostgreSQL en local, contenedor Docker o servidor de laboratorio.

Verificar versión de PostgreSQL, versión de Python enlazada y disponibilidad de PL/Python.

Instalar la extensión `plpython3u` en una base de datos controlada.

Diferenciar instalación a nivel de servidor, base de datos, extensión y permisos de uso.

Configurar un entorno seguro de prácticas sin datos productivos.

Crear roles, esquemas y base de datos de laboratorio para separar código, datos y pruebas.

Preparar scripts reproducibles de inicialización con SQL y Docker Compose.

Validar que las funciones PL/Python se ejecutan correctamente con un primer ejemplo mínimo.

Resolver errores habituales de instalación por paquetes ausentes, librerías no enlazadas o permisos insuficientes.

Realizar ejercicio de creación de entorno PostgreSQL + PL/Python completamente reproducible.

Comprender por qué PL/Python se considera lenguaje untrusted dentro de PostgreSQL.

Analizar qué implica ejecutar Python dentro del proceso del servidor PostgreSQL.

Identificar riesgos: acceso a sistema de archivos, imports no controlados, ejecución de código y consumo de recursos.

Restringir quién puede crear funciones PL/Python en entornos corporativos.

Diseñar un flujo de revisión técnica y de seguridad antes de desplegar funciones.

Evitar que usuarios de aplicación creen o modifiquen funciones PL/Python.

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

Definir políticas sobre imports, librerías externas, acceso a red, ficheros y secretos.

Documentar riesgos aceptados y controles compensatorios.

Realizar ejercicio de revisión de seguridad de una función PL/Python peligrosa.

Crear funciones con `CREATE FUNCTION` usando `LANGUAGE plpython3u`.

Definir parámetros, tipos de retorno, volatilidad, coste, seguridad y esquema.

Usar código Python dentro del cuerpo de una función SQL.

Devolver valores escalares como texto, números, booleanos, fechas y tipos simples.

Acceder a argumentos de la función desde Python.

Gestionar nombres de parámetros y convenciones de estilo.

Diferenciar funciones `IMMUTABLE`, `STABLE` y `VOLATILE` según comportamiento real.

Evitar marcar como inmutable una función que depende de datos externos, tiempo o estado.

Crear documentación mínima para cada función: propósito, parámetros, retorno y ejemplos.

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

Comprender cómo PostgreSQL convierte tipos SQL a objetos Python.

Trabajar con integer, numeric, float, text, boolean, date, timestamp, interval y UUID.

Gestionar `NULL` de PostgreSQL como `None` en Python.

Tratar fechas, zonas horarias, decimales y precisión numérica con cuidado.

Devolver tipos correctos desde Python para evitar errores de casteo.

Validar entradas antes de procesarlas para evitar excepciones inesperadas.

Controlar diferencias entre `numeric` de PostgreSQL y `float` de Python.

Diseñar funciones que no pierdan precisión en cálculos financieros o científicos.

Evitar conversiones implícitas difíciles de depurar.

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

Recibir arrays PostgreSQL como listas Python.

Devolver listas Python como arrays SQL cuando la firma de retorno lo permite.

Trabajar con tipos compuestos, filas y estructuras record.

Crear funciones que devuelven varios campos con `RETURNS TABLE` o tipos compuestos.

Procesar listas de valores, métricas, etiquetas, categorías o resultados agregados.

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

Crear estructuras Python intermedias para componer resultados SQL.

Evitar devolver estructuras no compatibles con el tipo declarado.

Documentar contratos de entrada y salida para funciones complejas.

Realizar ejercicio de función PL/Python que procesa arrays y devuelve registros.

Recibir y procesar valores JSON/JSONB desde PL/Python.

Convertir estructuras JSON a diccionarios y listas Python.

Validar esquemas JSON, claves obligatorias, tipos y valores permitidos.

Normalizar datos semiestructurados antes de insertarlos en tablas relacionales.

Crear funciones que extraen, transforman o enriquecen documentos JSONB.

Devolver JSON desde Python manteniendo serialización correcta.

Comparar cuándo usar operadores JSONB nativos de PostgreSQL y cuándo usar Python.

Evitar procesar grandes volúmenes JSON fila a fila si SQL nativo puede resolverlo mejor.

Diseñar funciones para validar payloads de APIs almacenados en PostgreSQL.

Realizar ejercicio de validación y normalización de JSONB con PL/Python.

Crear funciones PL/Python que devuelven múltiples filas.

Diferenciar retorno de lista, generador y estructuras compatibles con `SETOF`.

Diseñar funciones tabulares para expandir, transformar o generar datos.

Usar `RETURNS TABLE` para definir outputs claros y mantenibles.

Controlar memoria cuando la función devuelve muchos resultados.

Evitar set-returning functions lentas dentro de consultas masivas.

Integrar funciones set-returning con `SELECT`, joins y CTEs.

Documentar orden, columnas, tipos y comportamiento de retorno.

Comparar alternativas con SQL puro, `jsonb_to_recordset` o funciones nativas.

Realizar ejercicio de expansión de datos semiestructurados en filas relacionales.

Diferenciar funciones y procedimientos en PostgreSQL.

Crear procedimientos con `CREATE PROCEDURE` y `CALL`.

Diseñar procedimientos para tareas administrativas, transformación controlada o procesos internos.

Entender restricciones y posibilidades de gestión transaccional en procedimientos.

Separar procedimientos operativos de funciones usadas en consultas.

Registrar avances, resultados y errores de procesos ejecutados por procedimientos.

Evitar procedimientos opacos que modifican muchos datos sin trazabilidad.

Definir parámetros de entrada, salida y comportamiento esperado.

Crear controles de idempotencia cuando el procedimiento puede relanzarse.

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

Comprender el uso de SPI para ejecutar consultas SQL desde código PL/Python.

Usar `plpy.execute` para consultas internas simples.

Procesar resultados devueltos por una consulta SQL dentro de Python.

Ejecutar instrucciones `SELECT`, `INSERT`, `UPDATE` y `DELETE` de forma controlada.

Parametrizar consultas para evitar SQL dinámico inseguro.

Entender coste y riesgo de ejecutar SQL por cada fila procesada.

Diseñar funciones que combinan lógica Python con consultas internas eficientes.

Evitar bucles Python que ejecutan miles de consultas individuales innecesarias.

Registrar errores cuando una consulta interna falla.

Realizar ejercicio de función PL/Python que consulta y actualiza datos mediante SPI.

Crear planes preparados con `plpy.prepare`.

Ejecutar planes preparados con parámetros para mejorar claridad y rendimiento.

Reutilizar planes en funciones llamadas repetidamente.

Definir tipos de parámetros correctamente.

Evitar concatenar strings SQL con valores de usuario.

Diseñar SQL dinámico solo cuando sea estrictamente necesario.

Aplicar quoting seguro para identificadores cuando se construyen consultas dinámicas.

Medir diferencia entre consultas preparadas y ejecución directa en escenarios repetidos.

Documentar consultas internas críticas dentro de la función.

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

Usar `plpy.notice`, `plpy.warning`, `plpy.error` y mensajes controlados.

Capturar excepciones Python y convertirlas en errores comprensibles para PostgreSQL.

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

Crear mensajes útiles sin exponer datos sensibles.

Diseñar funciones que fallan pronto cuando la entrada no cumple requisitos.

Evitar silenciamiento de errores que deja datos incoherentes.

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

Gestionar errores de SPI, casteo, import, división, nulos y claves ausentes.

Crear estrategia de logging compatible con operación y auditoría.

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

Comprender qué son las subtransacciones en PL/Python.

Usar context managers de subtransacción para aislar operaciones que pueden fallar.

Diseñar procesos donde un fallo parcial no debe abortar todo el trabajo.

Registrar filas rechazadas, errores de validación y resultados parciales.

Evitar abusar de subtransacciones en procesos masivos sin medir impacto.

Diferenciar error recuperable de error que debe abortar la transacción completa.

Crear tablas de auditoría para registrar incidencias por registro.

Diseñar procesos de importación con control de aceptación y rechazo.

Validar consistencia final tras operaciones parciales.

Realizar ejercicio de carga controlada con subtransacciones y registro de errores.

Crear funciones trigger en PL/Python.

Comprender el diccionario `TD` y sus claves principales.

Acceder a evento, momento, nivel, tabla, esquema, fila antigua y fila nueva.

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

Diferenciar triggers `ROW` y `STATEMENT`.

Modificar `TD["new"]` en triggers `BEFORE` cuando procede.

Devolver `OK`, `SKIP` o `MODIFY` según el comportamiento requerido.

Evitar triggers con lógica pesada que ralentizan operaciones críticas.

Documentar qué tablas dependen de cada trigger y qué efectos produce.

Realizar ejercicio de trigger PL/Python para normalización automática de datos.

Crear triggers para registrar cambios relevantes en tablas críticas.

Validar reglas complejas antes de insertar o actualizar registros.

Enriquecer datos calculando campos derivados o normalizando texto.

Detectar cambios entre `TD["old"]` y `TD["new"]`.

Crear auditoría con usuario, timestamp, operación, tabla, clave y valores relevantes.

Controlar datos sensibles antes de guardarlos en logs de auditoría.

Evitar triggers que hacen llamadas externas o procesos lentos en transacciones de usuario.

Diseñar triggers compatibles con cargas masivas y procesos batch.

Crear interruptores de mantenimiento cuando ciertas cargas autorizadas no deben disparar toda la lógica.

Realizar ejercicio de auditoría y validación avanzada mediante trigger PL/Python.

Usar Python para normalizar textos, códigos, identificadores, nombres y direcciones.

Aplicar expresiones regulares avanzadas dentro de funciones PL/Python.

Limpiar caracteres invisibles, espacios, acentos, formatos inconsistentes y valores duplicados.

Parsear cadenas complejas que serían difíciles de tratar con SQL puro.

Crear funciones de normalización reutilizables para pipelines y restricciones.

Evaluar cuándo conviene usar extensiones nativas de PostgreSQL en lugar de Python.

Diseñar funciones deterministas y testeables para limpieza de datos.

Evitar lógica de parsing no documentada que solo entiende una persona.

Crear informes de calidad antes y después de la normalización.

Realizar ejercicio de limpieza avanzada de campos de clientes, productos o direcciones.

Comprender cómo se importan módulos Python desde PL/Python.

Diferenciar librerías estándar de Python y paquetes externos instalados en el servidor.

Evaluar riesgos de instalar dependencias Python en servidores PostgreSQL.

Usar librerías estándar para fechas, regex, JSON, decimal, math, statistics o hashing.

Definir política corporativa para paquetes externos aprobados.

Evitar dependencias pesadas o no auditadas dentro del proceso de base de datos.

Gestionar versiones de librerías entre entornos de desarrollo, test y producción.

Documentar imports usados por cada función crítica.

Preparar contenedores con dependencias reproducibles cuando se permite su uso.

Realizar ejercicio de función PL/Python con librerías estándar y revisión de dependencias.

Crear funciones de scoring basadas en múltiples variables y reglas ponderadas.

Implementar validaciones complejas que combinan datos relacionales y lógica Python.

Calcular métricas personalizadas para reporting, clasificación o priorización.

Crear funciones para clasificación básica, scoring de riesgo o segmentación.

Documentar fórmulas, pesos, umbrales y criterios de negocio.

Validar resultados con datasets esperados y pruebas de regresión.

Evitar modelos o cálculos opacos sin explicación ni trazabilidad.

Comparar PL/Python con ejecutar scoring desde un servicio externo.

Medir impacto en consultas que llaman la función muchas veces.

Realizar ejercicio de scoring de clientes, incidencias o transacciones.

Usar PL/Python como complemento en bases con PostGIS cuando la lógica espacial requiere Python.

Procesar coordenadas, listas de puntos, rutas y estructuras geométricas.

Integrar funciones Python con consultas PostGIS existentes.

Evitar reimplementar en Python operaciones espaciales que PostGIS resuelve mejor.

Crear validaciones auxiliares sobre geometrías, metadatos o reglas de negocio.

Transformar resultados espaciales en estructuras JSON para APIs o reporting.

Medir coste de procesar geometrías fila a fila.

Diseñar funciones seguras para cálculo auxiliar, no para sustituir motor espacial.

Documentar SRID, unidades, tolerancias y supuestos geométricos.

Realizar ejercicio de apoyo Python sobre datos geoespaciales almacenados en PostgreSQL.

Analizar por qué llamar APIs externas desde PL/Python suele ser arriesgado.

Identificar problemas de latencia, bloqueo, transacciones abiertas, timeouts y disponibilidad.

Evaluar alternativas: backend, workers, colas, LISTEN/NOTIFY, jobs externos o ETL.

Diseñar casos excepcionales donde una llamada externa podría estar justificada.

Aplicar timeouts estrictos, control de errores y circuit breaker externo cuando procede.

Evitar almacenar credenciales o tokens dentro de funciones PL/Python.

Crear patrón de outbox para desacoplar base de datos y servicios externos.

Documentar decisiones de arquitectura cuando una integración sale de PostgreSQL.

Revisar implicaciones de seguridad y auditoría.

Realizar ejercicio de rediseño de una función peligrosa hacia patrón asíncrono.

Medir coste de funciones PL/Python dentro de consultas SQL.

Comprender impacto de ejecutar Python por fila en tablas grandes.

Usar `EXPLAIN` y `EXPLAIN ANALYZE` para detectar problemas de ejecución.

Comparar rendimiento entre SQL nativo, PL/pgSQL y PL/Python.

Evitar funciones PL/Python en predicados críticos sin entender impacto en índices.

Marcar volatilidad, coste y paralelismo de forma realista.

Reducir trabajo repetido con consultas previas, joins o procesamiento por lotes.

Evitar imports costosos o inicializaciones repetidas dentro de funciones llamadas masivamente.

Medir latencia, CPU, memoria y bloqueos asociados.

Realizar ejercicio de optimización de una consulta que usa funciones PL/Python.

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

Analizar riesgos de mantener transacciones abiertas mientras se ejecuta lógica Python lenta.

Evitar operaciones bloqueantes en triggers o funciones llamadas por procesos críticos.

Gestionar concurrencia cuando varias sesiones ejecutan funciones sobre las mismas tablas.

Diseñar actualizaciones internas con orden estable para reducir deadlocks.

Identificar bloqueos causados por triggers de auditoría, validación o enriquecimiento.

Crear pruebas de concurrencia para funciones críticas.

Evitar dependencias de estado global Python en ejecuciones concurrentes.

Documentar comportamiento transaccional de procedimientos y funciones.

Realizar ejercicio de análisis de bloqueo producido por trigger PL/Python.

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

Probar casos normales, nulos, límites, errores, arrays, JSONB y tipos compuestos.

Crear datasets de prueba reproducibles.

Validar triggers con operaciones INSERT, UPDATE, DELETE y escenarios de rollback.

Usar pgTAP, pytest, contenedores o scripts SQL según el entorno del equipo.

Comparar resultados esperados frente a outputs reales en CI/CD.

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

Crear tests de seguridad para permisos y uso de roles.

Medir cobertura funcional de reglas críticas.

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

Organizar funciones PL/Python en archivos SQL versionados.

Integrar cambios con herramientas de migración como Flyway, Liquibase, Sqitch o migraciones propias.

Separar esquemas de código, datos, auditoría y pruebas.

Crear scripts idempotentes cuando el flujo de despliegue lo requiere.

Gestionar cambios de firma, tipos de retorno y dependencias entre funciones.

Preparar rollback cuando una función nueva falla en producción.

Documentar releases de funciones, triggers y extensiones.

Evitar editar funciones manualmente en producción sin trazabilidad.

Integrar despliegue con revisión de DBA y seguridad.

Realizar ejercicio de migración controlada de funciones PL/Python entre versiones.

Crear imagen Docker de PostgreSQL con PL/Python habilitado.

Instalar dependencias Python autorizadas dentro del contenedor de laboratorio.

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

Ejecutar tests automáticos en pipeline CI/CD.

Validar que la extensión y dependencias existen antes de aplicar migraciones.

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

Gestionar secretos mediante variables y mecanismos seguros del pipeline.

Evitar pipelines que dependen de un servidor compartido no reproducible.

Publicar artefactos SQL, reportes de tests y documentación técnica.

Realizar ejercicio de pipeline CI/CD para funciones PL/Python.

Diseñar logs útiles para funciones críticas sin saturar el servidor.

Usar mensajes PostgreSQL y tablas de auditoría con criterio.

Registrar errores de negocio, errores técnicos, tiempos de ejecución y registros rechazados.

Medir uso de funciones, frecuencia de error y consultas más costosas.

Integrar logs PostgreSQL con observabilidad corporativa cuando procede.

Crear métricas de calidad de datos generadas por funciones PL/Python.

Evitar logging de datos personales o sensibles sin necesidad.

Diseñar trazabilidad entre aplicación, usuario, transacción y función ejecutada.

Crear runbooks para investigar fallos de funciones y triggers.

Realizar ejercicio de observabilidad sobre proceso PL/Python con auditoría.

Crear estándar corporativo para funciones PL/Python.

Definir cuándo se permite PL/Python y cuándo debe usarse SQL, PL/pgSQL o backend externo.

Establecer plantilla de documentación para función, parámetros, retorno, seguridad y pruebas.

Crear checklist de revisión para imports, SPI, errores, permisos, rendimiento y transacciones.

Definir owners de funciones, triggers y procedimientos.

Clasificar funciones por criticidad y datos tratados.

Crear catálogo de funciones PL/Python con dependencias y estado de mantenimiento.

Revisar periódicamente funciones no usadas, peligrosas o con bajo rendimiento.

Evitar proliferación de lógica Python sin arquitectura ni owner.

Realizar ejercicio de definición de estándar PL/Python para equipo de datos.

Diagnosticar errores de extensión no instalada o lenguaje no disponible.

Resolver problemas de permisos al crear funciones PL/Python.

Detectar errores por tipos de retorno incompatibles.

Corregir problemas de `None`, `NULL`, arrays vacíos y estructuras JSON inesperadas.

Investigar imports fallidos por dependencias no instaladas en el servidor.

Depurar funciones que funcionan en Python externo pero fallan dentro de PostgreSQL.

Identificar triggers que se ejecutan demasiadas veces o en momentos incorrectos.

Resolver problemas de rendimiento por bucles, SPI repetitivo o procesamiento fila a fila.

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

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

Diseñar validación avanzada de datos maestros antes de inserción.

Crear normalización de campos complejos para CRM, ERP, reporting o integración.

Implementar scoring interno de registros con reglas de negocio documentadas.

Procesar JSONB procedente de APIs, formularios o eventos.

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

Generar datos derivados para procesos analíticos o reporting técnico.

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

Crear funciones auxiliares para algoritmos internos que SQL expresa con dificultad.

Evaluar cada caso frente a alternativas externas más seguras o escalables.

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

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

Crear entorno Docker reproducible con PostgreSQL, PL/Python, esquemas, datos de prueba y scripts de inicialización.

Instalar y habilitar `plpython3u` en una base de datos de laboratorio.

Crear roles, permisos y esquema dedicado para funciones PL/Python.

Diseñar tablas de negocio, tabla de auditoría, tabla de errores y dataset de pruebas.

Implementar funciones escalares para normalización de texto, códigos, identificadores o direcciones.

Implementar función sobre JSONB para validar payloads y extraer campos estructurados.

Implementar función set-returning para transformar datos semiestructurados en filas relacionales.

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

Crear plan preparado con parámetros para una operación repetida.

Implementar trigger `BEFORE` para validar y modificar datos antes de insertarlos.

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

Añadir gestión de errores, mensajes útiles y registro de incidencias por registro.

Usar subtransacciones cuando el caso requiera recuperación parcial.

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

Medir rendimiento con `EXPLAIN ANALYZE` y optimizar las funciones más costosas.

Preparar scripts de migración versionados para desplegar funciones y triggers.

Integrar ejecución de tests en pipeline CI/CD o script automatizado local.

Documentar seguridad, permisos, dependencias, riesgos, runbook y criterios de mantenimiento.

Presentar la solución final defendiendo arquitectura, seguridad, rendimiento, trazabilidad y valor para negocio.