Curso de PL/PHP

Revisar el concepto de lenguaje procedural dentro de PostgreSQL.

Comparar SQL functions, PL/pgSQL, PL/Python, PL/Perl, PL/Tcl, PL/Rust, PL/v8, PL/Java y PL/PHP.

Diferenciar lenguajes incluidos en PostgreSQL y lenguajes externos mantenidos por terceros.

Entender cómo PostgreSQL delega ejecución a un handler de lenguaje.

Analizar trusted language, untrusted language y permisos asociados.

Evaluar cuándo una función debe estar dentro de la base de datos y cuándo fuera.

Comparar PL/PHP con lógica en Laravel, Symfony, Slim, jobs PHP, colas, APIs o scripts CLI.

Identificar alternativas de migración según complejidad, criticidad y volumen de uso.

Evitar elegir un lenguaje procedural solo por familiaridad del equipo.

Realizar ejercicio de matriz de decisión entre PL/PHP, PL/pgSQL, backend PHP y alternativas modernas.

Preparar entorno Linux o contenedor para compilar y probar PL/PHP.

Instalar PostgreSQL, headers de desarrollo, PHP, PHP development files, compilador C, make y dependencias.

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

Configurar build de PL/PHP según el código fuente disponible y versión objetivo.

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

Crear base de datos de laboratorio y habilitar el lenguaje PL/PHP cuando el proceso lo permita.

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

Documentar paso a paso la instalación reproducible para DBA y plataforma.

Evitar pruebas sobre servidores productivos o bases con datos reales.

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

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

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

Revisar impacto de cambios en PHP moderno sobre código legacy escrito años atrás.

Identificar funciones que dependen de comportamientos antiguos de PHP.

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

Probar builds contra varias versiones antes de decidir soporte.

Evitar asumir compatibilidad porque una función antigua sigue existiendo en producción.

Documentar versiones exactas, opciones de compilación y limitaciones conocidas.

Preparar estrategia de congelación tecnológica cuando no hay soporte moderno fiable.

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

Comprender los riesgos de ejecutar PHP dentro del proceso o contexto del servidor PostgreSQL.

Analizar permisos de creación, modificación y ejecución de funciones PL/PHP.

Revisar impacto de funciones privilegiadas, owners, grants y esquemas.

Evaluar riesgos de acceso a sistema, ficheros, entorno, funciones PHP sensibles y recursos externos.

Definir política restrictiva para creación de nuevas funciones PL/PHP.

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

Evitar que usuarios de aplicación puedan crear o modificar funciones PL/PHP.

Crear checklist de seguridad para funciones y triggers PL/PHP existentes.

Documentar riesgos aceptados y controles compensatorios.

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

Repasar sintaxis PHP aplicada a funciones de base de datos.

Trabajar con variables, arrays, strings, números, booleanos, null y funciones.

Revisar diferencias entre PHP moderno y PHP legacy que puede aparecer en PL/PHP histórico.

Usar estructuras `if`, `switch`, `foreach`, `while`, funciones auxiliares y manejo de errores.

Gestionar conversiones débiles de tipos típicas de PHP con especial cautela.

Diferenciar `null`, cadena vacía, `false`, cero y valores no definidos.

Evitar código PHP críptico o dependiente de conversiones implícitas.

Crear funciones pequeñas, explícitas y revisables por DBA y seguridad.

Documentar supuestos de entrada, salida, formato y error.

Realizar ejercicio de lectura y saneamiento de código PHP legacy.

Crear funciones PostgreSQL cuyo cuerpo se escribe en PHP.

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

Acceder a argumentos de entrada desde el cuerpo PHP según el mecanismo de PL/PHP disponible.

Devolver valores compatibles con el tipo declarado en PostgreSQL.

Gestionar `NULL`, cadenas vacías, booleanos y conversiones entre PHP y SQL.

Crear funciones pequeñas con una responsabilidad clara.

Evitar funciones largas que mezclan validación, consulta, escritura, logging y reglas de negocio.

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

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

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

Revisar cómo valores PostgreSQL se representan dentro de PHP.

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

Controlar diferencias entre `NULL`, `null`, string vacío, `false` y valores no definidos.

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

Tratar encoding, caracteres especiales, Unicode y normalización de texto.

Devolver tipos coherentes con la firma SQL declarada.

Validar entradas antes de operar con ellas.

Documentar reglas de conversión críticas.

Crear pruebas con tipos límite, nulos y valores ambiguos.

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

Procesar arrays PostgreSQL cuando la conversión hacia PHP lo permite.

Usar arrays PHP indexados y asociativos para representar estructuras intermedias.

Trabajar con records, filas, hashes y resultados compuestos.

Diseñar funciones que devuelven estructuras claras y consultables desde SQL.

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

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

Comparar arrays PHP frente a tipos compuestos, JSONB y tablas relacionales.

Crear tests para entradas complejas y casos extremos.

Documentar estructura esperada de cada array o resultado.

Realizar ejercicio de función PL/PHP que procesa colecciones y devuelve resultado estructurado.

Procesar JSON como texto o estructura PHP cuando el entorno lo permite.

Validar claves obligatorias, tipos, arrays anidados y objetos esperados.

Normalizar payloads procedentes de APIs, formularios, integraciones o aplicaciones PHP.

Crear funciones de extracción y limpieza de campos.

Comparar procesamiento PHP 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 esquema esperado, errores y reglas de transformación.

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

Realizar ejercicio de validación y normalización de JSON con PL/PHP.

Comprender qué es una función set-returning en PostgreSQL.

Diseñar funciones PL/PHP que devuelven varios valores o filas.

Generar resultados tabulares desde arrays, textos, JSON o reglas internas.

Controlar volumen de salida para no penalizar memoria ni latencia.

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

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

Comparar con soluciones SQL set-based o funciones nativas.

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

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

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

Crear funciones PL/PHP utilizadas como triggers PostgreSQL.

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

Acceder a datos de fila anterior y nueva según la API de PL/PHP disponible.

Modificar valores antes de insertar o actualizar cuando procede.

Rechazar operaciones que incumplen reglas críticas.

Diseñar triggers que devuelven el resultado correcto según operación.

Evitar triggers pesados en tablas de alta escritura.

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

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

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

Crear validaciones de datos antes de insertar o actualizar registros.

Normalizar emails, códigos, referencias, identificadores, nombres y estados.

Aplicar reglas deterministas y documentadas sobre datos críticos.

Crear triggers de auditoría para registrar cambios relevantes.

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

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

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

Diseñar reglas que no bloquean procesos legítimos por exceso de rigidez.

Crear pruebas de regresión para cada regla crítica.

Realizar ejercicio de auditoría y validación avanzada sobre tabla crítica.

Comprender cuándo una función PL/PHP necesita consultar la base desde dentro.

Revisar capacidades de acceso interno a base ofrecidas por PL/PHP.

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

Insertar o actualizar registros desde funciones solo cuando la arquitectura lo justifica.

Evitar concatenar SQL con valores de usuario sin control.

Parametrizar o sanear consultas siempre que la API disponible lo permita.

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

Evitar ejecutar una consulta interna por cada fila sin medir impacto.

Documentar dependencias de esquema, tablas, vistas y permisos.

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

Identificar riesgos de SQL injection dentro de funciones PL/PHP.

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

Priorizar consultas parametrizadas o allowlists frente a concatenación de strings.

Escapar valores de forma controlada cuando no existe alternativa mejor.

Revisar funciones legacy con SQL dinámico inseguro.

Evitar que argumentos de usuario definan tablas, columnas o cláusulas sin allowlist.

Crear pruebas con comillas, caracteres especiales, nulos y payloads maliciosos.

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

Preparar checklist de seguridad para revisión de SPI y SQL dinámico.

Realizar ejercicio de corrección de función vulnerable a inyección SQL.

Diseñar manejo de errores claro dentro de funciones PL/PHP.

Diferenciar errores de validación, conversión, SQL, permisos y programación.

Crear mensajes útiles para DBA, desarrollo y soporte.

Evitar silenciamiento de errores que deja datos incoherentes.

Evitar exponer datos sensibles en mensajes de error.

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

Definir cuándo abortar operación y cuándo devolver resultado controlado.

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

Probar entradas inválidas, tipos incorrectos y casos límite.

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

Comprender que una función PL/PHP 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.

Revisar deadlocks provocados por triggers o consultas internas.

Evitar dependencias de estado global PHP dentro del contexto de ejecución.

Probar funciones con sesiones concurrentes y cargas simultáneas.

Diseñar triggers ligeros y predecibles.

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/PHP.

Revisar si el entorno PL/PHP permite usar funciones o extensiones PHP específicas.

Diferenciar PHP core, extensiones cargadas, librerías externas y código corporativo.

Analizar riesgos de dependencias antiguas, vulnerables o no mantenidas.

Evitar dependencias pesadas dentro del proceso de base de datos.

Controlar rutas de carga, configuración PHP, permisos y entorno.

Crear allowlist de extensiones PHP permitidas en laboratorio o producción.

Documentar dependencias usadas por cada 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 dependencias PHP en un entorno PL/PHP.

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

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

Comparar SQL nativo, PL/pgSQL, PL/PHP y lógica PHP externa.

Evitar funciones llamadas por fila sobre tablas grandes sin benchmark.

Revisar volatilidad, coste declarado y efecto sobre el optimizador.

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

Detectar cuellos de botella: conversiones, parsing, SQL interno, triggers y errores repetidos.

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/PHP lenta.

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

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

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

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

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

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

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

Documentar cobertura mínima de reglas críticas.

Crear fixtures y datasets representativos.

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

Organizar funciones PL/PHP en scripts SQL versionados.

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

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

Crear migraciones reversibles cuando el cambio lo permite.

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

Evitar editar funciones directamente en producción sin trazabilidad.

Documentar versión de PostgreSQL, PHP, PL/PHP, sistema operativo y dependencias.

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/PHP a nueva versión.

Crear contenedor PostgreSQL preparado para compilar o ejecutar PL/PHP.

Instalar PHP, 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 aplicar migraciones.

Separar configuración de desarrollo, test 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/PHP.

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 PHP, 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/PHP.

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

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

Analizar dependencias con vistas, funciones, triggers, jobs y aplicaciones PHP 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, DBA y responsables de aplicación.

Priorizar quick wins frente a migraciones complejas.

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

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

Migrar validaciones complejas a PL/Python, PL/Rust o PL/v8 cuando aporta valor.

Mover lógica de negocio extensa a servicios PHP, jobs, colas, APIs o procesos externos.

Sustituir triggers por constraints, generated columns, reglas SQL o pipelines 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/PHP a PL/pgSQL o servicio PHP externo.

Definir si se permite nuevo desarrollo PL/PHP 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/PHP 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 más soportadas.

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

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

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

Analizar parsing de texto donde PHP 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 PHP complejas dentro del servidor PostgreSQL.

Identificar casos donde PL/Rust, PL/Python, PL/v8 o backend PHP externo 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/PHP y triggers legacy.

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

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

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

Ejecutar pruebas iniciales para verificar comportamiento actual.

Analizar seguridad de lenguaje, permisos, funciones privilegiadas y dependencias PHP.

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, PL/v8 o servicio externo.

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

Rediseñar una función compleja hacia servicio PHP 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/PHP en la organización.

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