Variables en el Data Pipeline de Oracle EPM

¡Hola Chiquis!👋🏻 Oracle EPM Data Pipeline permite diseñar flujos de datos parametrizados.

jul 08, 2025

Las variables son el alma de la flexibilidad: convierten un pipeline estático en uno dinámico. En este post exploraremos qué son, cómo se definen y prácticas para sacarle el máximo provecho.

¿Alguna vez te has sentido como un mago lanzando hechizos, pero con tus procesos de Data Management? Si no es así, prepárate, porque hoy vamos a descubrir la varita mágica que transformará tus pipelines de datos de procesos rutinarios en sinfonías automatizadas y dinámicas: Las Variables en Oracle EPM Data Pipeline.

Olvídate de la repetición manual, de los “copy-paste” infinitos y de las noches sin dormir ajustando scripts. Las variables son el santo grial de la flexibilidad y la eficiencia en el mundo del Data Pipeline.

¿Por qué las Variables son tu Nuevo Mejor Amigo?

Imagina un chef que, en lugar de anotar cada ingrediente y cantidad para cada plato que prepara, simplemente tiene una lista de “salsas”, “especias” y “cantidades”, y las ajusta según el menú del día. Así funcionan las variables en el Data Pipeline. Son marcadores de posición dinámicos que se resuelven en tiempo de ejecución, permitiéndote:

Reutilizar y Escalar: Define un proceso una vez y úsalo para múltiples escenarios, períodos, entidades o lo que se te ocurra, ¡sin duplicar configuraciones!
Automatizar al Máximo: Dile adiós a la intervención manual. Las variables te permiten programar flujos de datos que se adaptan automáticamente a las condiciones cambiantes.
Centralizar el Control: Modifica un valor en un solo lugar y observa cómo se propaga a través de todos tus procesos dependientes. ¡Adiós a los errores por inconsistencia!
Simplificar la Gestión: Un pipeline con variables es más limpio, más fácil de leer y, créeme, mucho más agradecido de mantener.

¿Qué son las variables en Data Pipeline?

Las variables actúan como contenedores de valores que pueden cambiarse sin modificar la estructura del pipeline. Sirven para parametrizar rutas de archivos, credenciales, fechas, entidades, escenarios y más. Al usar variables, un solo flujo puede atender múltiples entornos o ciclos de procesamiento.

Tipos de variables

Las variables en Data Pipeline suelen clasificarse en tres grandes grupos:

El ABC de las Variables en Oracle EPM Data Pipeline

En el universo de EPM, las variables se manifiestan de diversas formas, cada una con su superpoder particular:

Variables de Sistema (System Variables): Son las variables “pre-cargadas” por Oracle, ofreciéndote acceso a información contextual vital. Piensa en ellas como el reloj de tu sistema o el calendario que siempre tienes a mano. Ejemplos Comunes:

$$PERIOD$$: El período actual de ejecución. ¡Esenciales para manejar datos mensuales, trimestrales o anuales!
$$YEAR$$: El año de la ejecución.
$$LAST_DAY_OF_PERIOD$$: La fecha del último día del período. ¡Ideal para filtros de fecha!
$$CURRENT_USER$$: El usuario que inició el proceso.

¿Cuándo usarlas? Para automatizar cargas por período, filtrar datos por fecha, o auditar quién ejecuta qué.

Variables Globales (Global Variables): Variables que puedes definir a nivel de la aplicación o del entorno de Data Management. Una vez definidas, están disponibles para todos los pipelines dentro de ese alcance. Son como las “reglas de la casa” que todos los procesos deben seguir.

¿Dónde se configuran? Generalmente en la sección de “Setup” o “System Settings” de Data Management, bajo la categoría de “Variables”. Ejemplos Típicos:

Rutas de archivos compartidos (ejemplo: $$FILE_SHARE_PATH$$ = "/u01/data/inbox/").
Nombres de servidores de bases de datos.
Umbrales de validación.

¿Cuándo usarlas? Para centralizar configuraciones comunes a múltiples Data Pipelines, facilitando el mantenimiento y la consistencia.

Variables de Pipeline (Pipeline Variables): Estas son las estrellas del espectáculo. Son variables que defines directamente dentro de tu Data Pipeline para almacenar valores específicos de la ejecución. Son temporales y viven solo mientras el pipeline se está ejecutando. Piensa en ellas como las “notas rápidas” que tomas para un proyecto específico.

¿Cómo se definen y usan? Puedes definirlas en diferentes pasos del pipeline (por ejemplo, en un script de Python o en un mapeo) y luego referenciarlas en pasos posteriores. Ejemplos de Uso:

Contadores: $$ERROR_COUNT$$ = 0.
Flags: $$PROCESS_SUCCESS$$ = "True".
Resultados de Consultas: Cargar el resultado de una consulta SQL en una variable para usarlo como filtro en un paso posterior. Por ejemplo, obtener la entidad “DEFAULT_ENTITY” de una tabla y usarla para el mapeo.
Rutas Dinámicas de Archivos: Construir la ruta completa de un archivo de origen o destino concatenando variables: $$FILE_PATH$$=$$INBOX$$+$$PERIOD$$ + "_data.csv".

¿Cuándo usarlas? Para crear flujos de trabajo altamente dinámicos, donde la lógica de un paso influye en la ejecución de los siguientes.

Cómo Usar Variables en el Pipeline

La magia de las variables se despliega cuando las insertas en los lugares correctos. Aquí algunas ideas:

En Nombres de Archivos (Source/Target File Names): Imagina que tus archivos de origen se llaman Ventas_Enero_2025.csv, Ventas_Febrero_2025.csv, etc.

Configura el nombre del archivo de origen como: Ventas_$$PERIOD$$_$$YEAR$$.csv. ¡Boom! Tu pipeline ahora procesará automáticamente el archivo correcto para cada período.

En Filtros de Datos (Data Filters): ¿Necesitas cargar solo los datos hasta el día de hoy?

En tu filtro de datos, puedes usar algo como: Fecha <= $$LAST_DAY_OF_PERIOD$$.

En Mapeos de Datos (Data Mappings): Si tienes una entidad de “Workforce” que cambia cada mes, puedes obtenerla dinámicamente:

En un script de Jython previo, podrías ejecutar una consulta para obtener la entidad del mes actual y guardarla en una variable de pipeline, y luego usar esa variable en tu mapeo de origen a destino.

En Scripts de Python/Jython (Custom Scripts): Aquí es donde las variables se vuelven herramientas de programación en toda regla. Puedes leer, manipular y escribir valores en variables para controlar el flujo de tu pipeline. Ejemplo:

# Obteniendo el valor del período actual
current_period = fdmContext["PERIOD"]

# Definiendo una nueva variable de pipeline
fdmContext["CUSTOM_MESSAGE"] = "Procesando datos para el período: " + current_period

# Imprimiendo el valor (para propósitos de depuración)
print(fdmContext["CUSTOM_MESSAGE"])

Estas variables luego pueden ser utilizadas en notificaciones, logs o incluso para decidir si un paso posterior debe ejecutarse o no.

Declaración y asignación

En la definición JSON o YAML de un pipeline, los parámetros se agregan en la sección parameters.

{
  "parameters": {
    "inputFile": {
      "type": "string",
      "defaultValue": "/data/ventas.csv"
    },
    "processingDate": {
      "type": "string",
      "defaultValue": "2025-07-08"
    }
  }
}

Cada parámetro recibe type y defaultValue. Al invocar, se pueden sobreescribir estos valores.

Uso de variables en actividades

Dentro de cada actividad, las variables se referencian con la sintaxis ${parameters.nombre}.

{
  "activities": [
    {
      "name": "CargaArchivo",
      "type": "Copy",
      "inputs": ["SalesDataSource"],
      "outputs": ["WorkTable"],
      "typeProperties": {
        "source": {
          "filePath": "${parameters.inputFile}"
        },
        "sink": {
          "databaseTable": "Ventas_${parameters.processingDate}"
        }
      }
    }
  ]
}

De esta forma la ruta del archivo y el nombre de la tabla se adaptan a cada ejecución.

Ejemplo de Flujo completo

A continuación un pipeline simplificado que:

Lee un CSV de ventas.
Limpia datos.
Carga a un cubo de Planning.

{
  "parameters": {
    "filePath": { "type": "string", "defaultValue": "/data/ventas.csv" },
    "periodo":  { "type": "string", "defaultValue": "202507" },
    "entity":   { "type": "string", "defaultValue": "VE01" }
  },
  "activities": [
    {
      "name": "LeerCSV",
      "type": "Copy",
      "typeProperties": {
        "source": { "filePath": "${parameters.filePath}" },
        "sink":   { "table": "StagingVentas" }
      }
    },
    {
      "name": "LimpiarDatos",
      "type": "DataFlow",
      "typeProperties": {
        "transformations": [
          { "name": "RemoveNulls", "condition": "VentaCantidad != null" }
        ]
      }
    },
    {
      "name": "CargarPlanning",
      "type": "EpmRest",
      "typeProperties": {
        "application": "PlanningApp",
        "planType": "DataLoad",
        "options": {
          "Period": "${parameters.periodo}",
          "Entity": "${parameters.entity}"
        }
      }
    }
  ]
}

Cada actividad usa los parámetros para mantener el pipeline genérico y reusable.

Estrategias Avanzadas para el Gurú del EPM

Variables Encadenadas: Una variable puede depender del valor de otra. Por ejemplo, una variable que define la ruta base y otra que construye la ruta completa del archivo utilizando la primera.
Manejo de Errores con Variables: Define una variable $$PROCESS_STATUS$$ y actualízala a "SUCCESS" o "FAILED" en función del resultado de cada paso. Luego, usa esta variable para enviar notificaciones personalizadas o para detener el proceso.
Variables para la Rendición de Cuentas (Auditing): Usa variables como $$CURRENT_USER$$ o $$LOAD_ID$$ para enriquecer tus logs y trazar la actividad del pipeline.
Variables como Parámetros de Entrada: Para cargas de datos muy específicas, puedes diseñar tus pipelines para que las variables se pasen como parámetros al ejecutar la carga, ofreciendo una flexibilidad asombrosa.

Buenas prácticas

Mantener nombres descriptivos: filePath en vez de fp.
Usar prefijos comunes para variables de entorno vs. usuario.
Centralizar credenciales en un Key Vault y referenciarlas como environment variables.
Documentar cada parámetro con comentarios o en un README asociado.
Validar valores con condiciones previas antes de iniciar el pipeline.

Más allá de las variables

Además de parámetros y user-defined, considera:

Integrar Azure Key Vault para secretos.
Usar variables de sistema para trazabilidad (ID de ejecución, timestamp).
Combinar con metámetros dinámicos en Data Flows para lógica condicional.
Explorar plantillas ARM o Terraform para desplegar pipelines parametrizados en distintas suscripciones.

El Futuro es Variable

Las Variables en Oracle EPM Data Pipeline son más que una simple característica; son una filosofía de diseño. Te empoderan para construir procesos de datos que no solo funcionan, sino que evolucionan y se adaptan. Dejan de ser meros “conductos” y se transforman en sistemas de entrega inteligentes.

Conclusión

Las variables transforman tus Data Pipelines de Oracle EPM en arquitecturas flexibles y mantenibles. Parametrizar tus flujos reduce el riesgo de errores manuales y acelera la puesta en marcha de nuevos escenarios. Aplica estas técnicas para crear pipelines adaptables a cualquier cambio de negocio.

Así que la próxima vez que te enfrentes a un requisito de carga de datos, pregúntate: “¿Cómo puedo hacer que esto sea más dinámico con variables?” La respuesta, te llevará a un nivel completamente nuevo de eficiencia y maestría en Oracle EPM.

¡Gracias por acompañarme en esta aventura tech! 👩🏻‍💻✨

🚀 ¿Te ha inspirado este contenido?
Me encantaría saber tu opinión o leer tus experiencias. 🧡

Si quieres explorar más de lo que estoy creando (proyectos, blogs, contenido tech y novedades en IA/ML), te invito a visitar:

🎯 [Mi Linktree](https://linktr.ee/orlidevs)

Y si prefieres conectar directamente:

🔗 [Conecta conmigo en Linkedin](https://www.linkedin.com/in/orlibetdungonzalez)

📚 [Mi blog personal](my-million-friend-blog.vercel.app)

✨ Code with heart — Create with soul ✨

Referencias:

Imágenes creadas con Gemini (google.com)

#porunmillondeamigos #makeyourselfvisible #creatorcontent #linkedin #developers #opentowork #Oracle #pipeline #EPM #DataPipeline #Cloud

My Million Friend!! 🚀✨

Discusión sobre este post