Está en la página 1de 59

Creación de soluciones Pentaho

1
ÍNDICE

1. CREANDO SOLUCIONES PENTAHO................................................................................................5


CONFIGURACIÓN DE PENTAHO Y DE DESIGN STUDIO...........................................................................................5
Configurar Design Studio para utilizar los ejemplos..........................................................................5
Examinando el repositorio de soluciones............................................................................................6
Verificar que puedes hacer test en Design Studio................................................................................7
TERMINOLOGÍA..............................................................................................................................................9
Términos comunes utilizados en Pentaho............................................................................................9
Términos específicos de la Plataforma BI.........................................................................................10
ARQUITECTURA...........................................................................................................................................12
Secuencias de Acción.........................................................................................................................12
Soluciones y el Repositorio de Soluciones.........................................................................................13
La carpeta system........................................................................................................................................ .13
La solución test................................................................................................................................ ............14
El Contexto de Tiempo de ejecución (The Runtime Context).............................................................14
SECUENCIAS DE ACCIÓN...............................................................................................................................14
Ejemplo del XML de una Secuencia de Acción....................................................................... ....................15
Definiendo Inputs (parámetros de entrada)................................................................................ ..................17
Tipos de datos .............................................................................................................................. ...............18
Resource Types................................................................................................................................ ............18
Actions ..................................................................................................................................................... ...19
Esquema XML....................................................................................................................................... ......20
EJECUCIÓN DE UNA SECUENCIA DE ACCIÓN ....................................................................................................23
Design Studio.....................................................................................................................................23
URL....................................................................................................................................................24
Llamada Web Service ........................................................................................................................24
Llamada Java.....................................................................................................................................25
Action Sequence Recap......................................................................................................................25
INTEGRACIÓN DE PENTAHO REPORTS (JFREEREPORTS)......................................................................................25
Definiciones de informes JFreeReport...............................................................................................26
Creating the Action Sequence............................................................................................................26
JDBC Driver Setup............................................................................................................................27
Verificando la integración de JFreeReport en la Plataforma Pentaho.............................................27
The Report Design Wizard.................................................................................................................28
Creación de una especificación con Design Wizard..........................................................................28
Usando una especificación de Design Wizard...................................................................................29
2. GUÍA DE REFERENCIA DE ACCIONES Y COMPONENTES.....................................................30
LLAMADA A UNA SECUENCIA DE ACCIÓN EXTERNA ..........................................................................................30
Component Name: SubActionComponent.................................................................................... ..........30
Inputs:................................................................................................................................................ .....30
Outputs:.................................................................................................................................... ..............31
CHART ACTION ..........................................................................................................................................31
Component Name: ChartComponent........................................................................................... ...........31
Inputs............................................................................................................................................... .......31
........................................................................................................................................................... ...32
Chart Attributes como un Input........................................................................................................ .....32
Chart Attributes como un Resource................................................................................. .....................33
Chart Attributes en la definición del componente.............................................................. ...................33
Outputs................................................................................................................................... ................34
Ejemplo de Secuencia de Acción............................................................................................... .............35
CONTENT REPOSITORY CLEANER ..................................................................................................................36
Component Name: ContentRepositoryCleaner....................................................................... ................37
Inputs:................................................................................................................................................ .....37
Outputs:.................................................................................................................................... ..............37
EMAIL .......................................................................................................................................................37
Component Name: EmailComponent.................................................................................. ...................37
Inputs:................................................................................................................................................ .....37
Outputs: None...................................................................................................................................... ...37

2
Component Definitions:....................................................................................................................... ...37
HELLO WORLD ..........................................................................................................................................38
Component Name: HelloWorldComponent.......................................................................... ..................38
Inputs:
Message – Texto a mostrar............................................................................................................... .......38
Outputs: Ninguno............................................................................................................. ......................38
HQL ........................................................................................................................................................38
Component Name: HQLLookupRule.................................................................................. ...................38
Component Definitions: None................................................................................................ ................38
Resources:......................................................................................................................... .....................38
Inputs:................................................................................................................................................ .....38
Outputs:.................................................................................................................................... ..............38
JAVASCRIPT ...............................................................................................................................................38
Component Name: JavascriptRule................................................................................................. .........39
Inputs:................................................................................................................................................ .....39
Outputs:.................................................................................................................................... ..............39
JFREE REPORTS ..........................................................................................................................................39
Component Name: JFreeReportComponent........................................................................................... .39
Component Definitions:....................................................................................................................... ...39
Resources:......................................................................................................................... .....................39
Inputs:................................................................................................................................................ .....39
Outputs:.................................................................................................................................... ..............40
KETTLE .....................................................................................................................................................40
Transformación de Kettle...................................................................................................................40
Component Name: KettleComponent....................................................................................... ..............40
Inputs:................................................................................................................................................ .....40
Outputs:.................................................................................................................................... ..............41
Resources:......................................................................................................................... .....................41
Kettle Job...........................................................................................................................................41
Component Name: KettleComponent....................................................................................... ..............41
Inputs:................................................................................................................................................ .....41
Kettle Repository Configuration........................................................................................................41
MDX QUERY ............................................................................................................................................41
Inputs:................................................................................................................................................ .....41
Resources:......................................................................................................................... .....................42
Outputs:.................................................................................................................................... ..............42
MQL .......................................................................................................................................................42
Component Name: MQLRelationshipDataComponent.................................................................... .......43
Component Definitions: None ............................................................................................... ................43
Resources: None.......................................................................................................................... ...........43
Inputs:................................................................................................................................................ .....43
Outputs:.................................................................................................................................... ..............43
PIVOT VIEW ..............................................................................................................................................43
Component Name: PivotViewComponent............................................................................. ................43
Component Definitions:....................................................................................................................... ...43
Outputs:.................................................................................................................................... ..............46
COMPONENTES PREPARADOS – HABILITAR SUBREPORTING Y COMPARTICIÓN DE CONEXIÓN........................................46
Habilitar JFreeReport Subreporting..................................................................................................46
Compartición de conexión.................................................................................................................48
PRINTING....................................................................................................................................................49
Component Name: PrintComponent.......................................................................................... .............49
Inputs:................................................................................................................................................ .....49
Outputs:.................................................................................................................................... ..............49
RESULTSET CROSSTAB .................................................................................................................................49
Component Name: SubActionComponent................................................................................... ..........50
Component Definitions: None ............................................................................................... ................50
Resources: None.......................................................................................................................... ...........50
Inputs:................................................................................................................................................ .....50
Outputs:.................................................................................................................................... ..............51
SCHEDULING ..............................................................................................................................................51
Start Job.............................................................................................................................................51
Component Name: JobSchedulerComponent........................................................................................ ..52
Inputs:................................................................................................................................................ .....52
Suspend Job.......................................................................................................................................52
Component Name: JobSchedulerComponent........................................................................................ ..52
Inputs:................................................................................................................................................ .....52

3
Outputs:.................................................................................................................................... ..............52
Resume Job........................................................................................................................................52
Component Name: JobSchedulerComponent........................................................................................ ..52
Inputs:................................................................................................................................................ .....52
Outputs:.................................................................................................................................... ..............52
Delete Job..........................................................................................................................................53
Component Name: JobSchedulerComponent........................................................................................ ..53
Inputs:................................................................................................................................................ .....53
Outputs:.................................................................................................................................... ..............53
SECURE FILTER (PROMPTING) .......................................................................................................................53
Component Definitions:....................................................................................................................... ...54
Action Inputs:............................................................................................................................ .............54
Action Outputs:................................................................................................................ ......................54
SQL EXECUTE ..........................................................................................................................................54
Component Name: SQLExecute................................................................................................... ..........55
Component Definition:............................................................................................................ ...............55
Outputs:.................................................................................................................................... ..............55
SQL QUERY .............................................................................................................................................55
Component Name: SQLLookupRule........................................................................................... ...........56
Inputs:................................................................................................................................................ .....56
Outputs:.................................................................................................................................... ..............56
SUB ACTION ..............................................................................................................................................57
Component Name: SubActionComponent................................................................................... ..........57
Component Definitions: Ninguna........................................................................................... ................57
Resources: Ninguna..................................................................................................................... ...........57
Inputs:................................................................................................................................................ .....57
Outputs:.................................................................................................................................... ..............57
XMLA ....................................................................................................................................................57
Component Name: XMLALookupRule.......................................................................................... ........57
Component Definitions: Ninguna........................................................................................... ................57
Resources:......................................................................................................................... .....................57
Inputs: (All are required).................................................................................................... ....................57
Outputs:.................................................................................................................................... ..............58
XQUERY ...................................................................................................................................................58
Component Name: XQueryLookupRule.......................................................................................... ......58
Component Definitions: Ninguna........................................................................................... ................58
Resources: Ninguno........................................................................................................................... .....58
Inputs:................................................................................................................................................ .....58
Outputs:.................................................................................................................................... ..............58
3. BIBLIOGRAFÍA....................................................................................................................................59

4
1. Creando soluciones Pentaho

Este documento describe la arquitectura del la plataforma de Business


Intelligence Pentaho y detallar los componentes y herramientas necesarias
para crear soluciones. Especialmente dirigido a personas interesadas en
construir soluciones y crear contenido. También es útil para cualquiera que
necesite desarrollar porciones de la plataforma Pentaho.

Para seguir mejor esta documentación, recomiendo que tengas instalado la


Suite Pentaho BI (Instalación preconfigurada) y Pentaho Design Studio en tu
máquina local. Muchos de los ejemplos utilizados en este documento hacen
referencia a soluciones y datos de ejemplo que vienen con la suite.

Muchos de los ejemplos se ilustran utilizando Pentaho Design Studio, que evita
tener que editar XML en editores, una tarea que no es muy agradable para
algunas personas. Si ya tienes funcionando Pentaho Server y Design Studio
puedes saltarte la primera sección.

Configuración de Pentaho y de Design Studio

La manera más rápida de empezar con la plataforma es descargando e


instalando Pentaho BI Platform Pre-Configured Install (PCI). Para más
información Getting Started with the BI Platform.

Pentaho Design Studio proporciona un entorno gráfico para crear, manejar y


probar tus soluciones. Cuenta con una colección de plantillas, editores y
asistentes para ayudarte.

Muchos de los ejemplos de este documento hacen referencia a Design Studio.


Para más información: Getting Started with Design Studio.

Configurar Design Studio para utilizar los ejemplos

En este punto, has de tener instalado el Design Studio o el plug-in Design


Studio en Eclipse, y tener una instalación de los ejemplos Pentaho. Has de
asegurarte que funcionan los ejemplos de samples/getting-started y probar
uno o dos informes de samples/steel-wheels/reports.

Todo el contenido que se edita existe o está disponible en el sistema de archivos de la


máquina local. Esto incluye carpetas compartidas, nfs, mounts, etc...
Es por esto que recomendamos, para seguir esta guía, tener instalado el BI Server y Design
Studio en la misma máquina.

Si no lo has hecho antes, inicia Design Studio. Si aparece la pantalla de


bienvenida, ciérrala.

5
• Seleccionar File->New->Project.

• Seleccionar Simple en el asistente de nuevo proyecto.

• Presionar el botón Next.

• Poner como nombre del proyecto Pentaho Solutions, Aaunque sirve


cualquier nombre, este documento se referirá al proyecto por ese
nombre.

• Desactivar la casilla Use default.

• Ir al directorio pentaho-solutions. Si estas utilizando la PCI, se


encontrará en /pentaho-demo/pentaho-solutions.

• Seleccionar Finish.

Ahora tenemos un proyecto en Design Studio preparado para editar y probar


los ejemplos.

Examinando el repositorio de soluciones

Ahora has de poder ver tu proyecto en forma de árbol en la parte izquierda del
Design Studio. Si expandes la carpeta de la solución pordrás ver una serie de
archivos los cuales forman tu solución. Abre la carpeta Pentaho
Solutions/samples/getting-started. Haz doble click en el fichero
HelloWorld.xaction fiy se abrirá el editor de Secuencias de Acción.

6
Verificar que puedes hacer test en Design Studio

La pestaña Test situada en la parte inferior se utiliza para generar y testear las
Secuencias de Acción. En este punto, no te preocupes si no sabes qué es una
secuencia de acción, lo explicaremos más adelante. Asegurate de tener
abierto el fichero HelloWorld.xaction y haz click en la pestaña test.

Actualmente, Design Studio utiliza el Pentaho BI Server para ejecutar secuencias de


acción. Cuando presionamos el botón Run, Design Studio envía una solicitud HTTP
al servidor y muestra el resultado en el navegador embedido. Normalmente este navegador
es el navegador por defecto del ordenador.
Es exactamente lo mismo si utilizas tu navegador para navegar por los ejemplos del PCI y
clicas en una secuencia de acción. Es por esto que el Design Studio pregunta si quieres
guardar los cambios de tu secuencia de acción antes de ir a la pestaña test. Y, es por esto
que tu ves una URL al lado del botón Run.

• Asegúrate que la URL del Pentaho Server URL apunta al BI Server


que está ejecutándose.

• Presionar el botón Test Server. Si todo está bien, aparecerá la página de


inicio de la demo de Pentaho.

• Ahora selecciona el botón Run para envíar la solicitud HTTP al BI Server


para ejecutar la secuencia acción actual. En el navegador enbedido
podremos ver "Hello World. Greetings from the Pentaho BI Platform."

Ahora cambiaremos el mensaje mostrado por esta secuencia de acción y


comprobaremos que funciona.

• Selecciona la pestaña Define Process.

• Seleccionar Hello World en Process Actions.

• Cambiar el texto %quote en la caja de texto Message por algo como - I


did it!.

• Volver a la pestaña Test. Seleccionar Yes para guardar cuando lo pida.

• Si estas utilizando el Pro Pentaho Server...

○ La configuración por defecto de Pro BI Server no ejecuta las


secuencias de acción desde el sistema de archivos, pero si del
repositorio. Necesitaremos decirle al servidor que actualice la base
de datos del sistema de archivos.
○ Ir a la página Admin del servidor Pentaho en nuestro navegador.
○ Seleccionar el icono de Solution Repository.

○ Decir Yes cuando nos pregunte Are you sure you want to do this

• Seleccionar Run.

7
Ahora deberiamos ver el nuevo mensaje - Hello World - I did it!.
El mensaje original dice %quote. Esta notación se utiliza para internacionalizar las
secuencias de acción. Hay unos ficheros en el mismo directorio de la secuencia de
acción llamados HelloWorld_xx.properties los cuales hemos modificado. Cada fichero tiene
las cadenas que se utilizarán para traducir texto de las secuencias de acción al idioma
adecuado. En Design Studio, puedes hacer doble click en el fichero
HelloWorld_en.properties y encontrarás la cadena asignada a quote, cámbiala por I did it!.
Para los textos que empiecen por % el servidor primero buscará un archivo local properties,
recorrerá el árbol de la solución buscando el fichero .properties correcto, y finalmente,
utiliza ese texto.

8
Terminología

Recopilación de los términos más importantes utilizados en este documento.

Términos comunes utilizados en Pentaho

El proyecto open source centrado en servicios, que también


Proyecto proporciona la integración del usuario final de Pentaho y
Pentaho BI capacidades de integración de datos. El proyecto Pentaho BI
Platform Platform incluye seguridad, integración, APIs, programación
(scheduling), y workflow.
También llamado Pentaho module. Un grupo de productos
relacionados con la funcionalidad. Los 6 Pilares del proyecto
Pilar
Pentaho BI son: Informes (Reporting), Análisis, Cuadros de
Pentaho BI
mando (Dashboards), Minería de datos (Data Mining),
Integración de datos y la plataforma BI.
Las aplicaciones, las APIs y los componentes que soportan los
Pentaho BI
informes, análisis, cuadros de mando, etc... del usuario final de
Platform
Pentaho.
Pentaho Suite que incluye todo de Pentaho:Reporting, Analisis,
Open BI Dashboards, Data Mining, Data Integration, y una plataforma
Suite BI.
Es una plataforma BI Pentaho desarrollada en un servidor de
Pre- aplicaciones JBoss pre-instalado y configuardo. Además,
Configured contiene un repositorio de soluciones listo para utilizar, que
Install (PCI) incluye conjuntos de informes y que tiene el objetivo de ser una
demo de iniciación en la plataforma.
Es la aplicación J2EE que corre en un servidor de aplicaciones.
Pentaho BI Este término se utiliza para refereirnos a la porción de la
Server plataforma de servidor sin considerar como o donde está
desarrollado.
XML Metadata Interchange: El XML Metadata Interchange
XMI (XMI) es un estandar OMG para el intercamvio de información
metadata via Extensible Markup Language (XML).
"Pro" es el término legal que se utiliza para describir las
capacidades que no son open source sólo disponibles para
usuarios que pagan. Cuando referencias a una construcción de
Pro software, ahora pentaho usa el término "Subscription
Edition" para describir la construcción. Y las características no
open source adicionales incluidas en la construcción se las
conoce como Pentaho Management Services.
Design Una aplicación individual que contiene un conjunto de plug-ins
Studio de Pentaho utilizados para crear, probar y administrar el
contenido de un proyecto Pentaho. Es un workbench de
Eclipse http://eclipse.org, pre-configurado y personalizado para
Pentaho. Actualmente sólo hay un plug-in:el Editor de
Secuencias de Acción. En muchos casos utiliza el Design

9
Studio para referirse a este plug-in. En futuras versiones se
proporcionaran mas plug-ins y más capacidades. El objetivo es
que sea una Interfaz de Usuario cliente para algo más que
para administración y creación de contenido. Se considera una
herramienta Administrador, Desarrollador o Creador de
contenido. No es una herramienta final típica.
Editor de El plug-in de Eclipse que permite generar Secuencias de
Secuencias Acción (un script que se ejecuta dentro de la Plataforma BI
de Acción Pentaho) .
Se pronuncia "wacker". Web Ad hoc Query and Reporting. A
WAQR
esta herramienta ahora se le llama Adhoc Reporting
Pimper El PME, el Pentaho Metadata Editor
SWAG Scientific Wild Assed Guess
CWM Common Warehouse Metamodel

Términos específicos de la Plataforma BI

Una solución consiste en una colección de documentos


(ficheros) que definen los procesos y actividades que forman
parte de un sistema para implementar una solución a un
problema empresarial. Estos documentos incluyen Secuencias
Solución de Acción, definición de procesos de flujo de trabajo
(workflow), definiciones de informes, imágenes, reglas,
consultas etc. Una solución se representa en el sistema de
ficheros como el primer nivel de la carpeta del Repositorio de
Soluciones.
Carpeta de Se refiere a la carpeta que contiene todas las soluciones
Soluciones disponibles en el servidor BI.
El sitio donde se almacenan y mantienen las soluciones y los
Repositorio
metadatos. Hay dos implementaciones del repositorio de
de
soluciones: el repositorio basado en ficheros y el repositorio
Soluciones
basado en base de datos (DB).
Motor de El software que recupera la definición de una acción desde el
Solución repositorio de soluciones y dirige su ejecución.
La capa de componente en una API que proporciona una
interfaz estandar entre el motor de solución y la aplicación que
ejecuta la lógica de negocio. Un componente puede contener
Componente todo el código requerido para realizar una tarea o puede que
sea una interfaz para otra aplicación o sistema. Los datos y la
sinstrucciones se le pasan al componente a través de la
definición de una acción (Action Definition).
Definición de Una definición XML que especifica los parámetros, recursos y
Acción preferencias necesarios para la ejecución de una tarea con un
(Action solo componente. La Definición de Acción define a qué
Definition) componente hay que llamar, que datos se le pasa y recibe del
componente y cualquier información específica que el
componente necesite. Una definición de Acción no es un

10
documento sinó que forma parte de una Secuencia de Acción.
Un documento XML que define la interacción entre una o más
Definiciones de Acción. Define la tarea completa más pequeña
que puede ejecutar el Motor de Soluciones. Cuando el Motor
Secuencia de de Soluciones ejecuta, realmente se ejecuta una Secuencia de
Acción Acción. La ejecución de la Secuencia de Acción se puede
completar de forma autónoma o se puede ejecutar como parte
de otra Secuencia de Acción. Las Definiciones de Secuencias
de Acción se guardan en el Repositorio de Soluciones.
PMD Pentaho MetaData
PME Pentaho Metadata Editor
WAQR Web Ad hoc Query and Reporting
MQL MetaData Query Language

MDR MetaData Repository

11
Arquitectura

El diagrama de más abajo muestra las relaciones entre los principales componentes del
servidor BI y sus interfaces con el mundo exterior. El corazón del servidor es el Motor
de Soluciones. El Motor de Soluciones es el foco de actividad de la Plataforma Pentaho.
Está entre el mundo exterior – Cliente Web, Servicios, Monitor de Sistema, etc... y la
Capa de Componentes. Las peticiones de trabajo entran al motor de soluciones y son
direccionadas al componente o componentes para la ejecución.

Secuencias de Acción

Una secuencia de acción es un documento XML que define la tarea


completa más pequeña que puede ejecutar el motor de soluciones. Se
ejecuta por un proceso ligero y define el orden de ejecución de uno o más
componentes de la Plataforma Pentaho. Tiene la capacidad de hacer un
loop en un conjunto de datos, llamar a otra secuencia de acción y ejecutar

12
componentes condicionalmente. El documento de la Secuencia de Acción
debe tener la extensión ".xaction".

Soluciones y el Repositorio de Soluciones

Una solución no es un solo documento, es una agrupación lógica de


secuencias de acción y los archivos que necesita. Esa agrupación es
mantenida por el Repositorio de Soluciones. Se puede ver la estructura del
repositorio yendo al directorio the pentaho-solution dentro del directorio de
instalación de la PCI. La ruta por defecto es: /pentaho-demo/pentaho-
solutions. Todas las carpetas en este directorio, a excepción de system, son
carpetas de solución. Las carpetas de solución pueden contener cualquier
número de capetas, estas carpetas pueden contener más carpetas, y así
indefinidamente. Esto también pasa con el Repositorio basado en base de
datos.

En la imagen anterior vemos la carpeta de soluciones, hay 3 soluciones


definidas: admin, samples y test. La carpeta system no es una carpeta de
solución, es donde está la información de configuración del sistema,
preferencias específicas de componenetes y recursos.
La secuencia de acción HelloWorld está en la solución samples dentro de
getting-started y con el nombre HelloWorld.xaction. Este ejemplo ilustra
las tres partes de una dirección que se usan para localizar una Secuencia de
Acción en el Repositorio: nombre de la solución, carpeta y nombre de
Secuencia de Acción. De esta manera se pueden agrupar una serie de
Secuencias de Accion de la manera deseada: por departamento, por rol,
etc...

La carpeta system

Como hemos dicho antes, la carpeta system es especial. Uno de los ficheros
más importantes que contiene es pentaho.xml, que contiene el sistema de
ajustes de configuración para la plataforma Pentaho. Para más información
ver pentaho.xml Reference.
La mayoría de los directorios de system son utilizados por componentes
individuales.

13
Directorio Descripción
Ajustes, ficheros de configuración y plug-ins utilizados por el
BIRT
componente de informes BIRT. (BIRT Reporting component)
Directorio de almacenamiento para el contenido generado por
las secuencias de acción como informes, PDFs, páginas
content
HTML, etc... También es conocido como el repositorio de
contenido.
Se encuentran las plantillas de UI (User Interface) y las
páginas de por defecto o personalizadas para la navegación
custom
de la PCI. Los XSL's que se utilizan para generar la interfaz
de usuario de navegación de la PCI también están aquí.
dtd Contiene las DTD's que utiliza la Plataforma.
Contiene ajustes como la clave de licencia para la integración
google
de Google maps.
hibernate Donde se encuentra el archivo hibernate-jboss-managed.xml.
Fichero de configuración de JasperReports. Los
jasperreports
JasperReports compilados también están aquí.
kettle Contiene el fichero de configuración de Kettle: settings.xml.
logs Logs generados por los componentes.
Lugar donde Mondrian guarda la información de los data
olap
sources.
quartz Contiene los ficheros de propiedades para Quartz.
Directorio de trabajo de Enhydra Shark workflow engine, que
shark
contiene la configuración, logs y repositorio.
simple-jndi Ajustes JNDI para herramientas cliente.
smtp-email Configuración del servidor de correo electrónico.
test-suite Ajustes de configuración para la interfaz de Test Manager.
Ficheros temporales que han de estar disponibles via URL
tmp
para llamar a imágenes o gráficos generados.

La solución test

La solución test contiene secuencias de acción y test de Junit para la


funcionalidad de test de partes del servidor BI.
Para más detalles JUnit testing.

El Contexto de Tiempo de ejecución (The Runtime Context)

Cuando ejecutamos, la solución, la carpeta y el nombre de una secuencia de


acción son pasados al motor de soluciones para la ejecución, entonces
recupera la secuencia de acción del repositorio de soluciones y crea un
entorno de tiempo de ejecución. En este entorno de tiempo de ejecución es
donde se ejecuta paso a paso la secuencia de acción.

14
Secuencias de Acción

El proceso de creación y edición de una secuencia de acción puede legar a ser


tedioso, además que si se hace manualmente es fácil que se den errores. El
editor de secuencias de acción es una herramienta independiente que facilita la
creación y manejo de secuencias de acción utilizando una interfaz gráfica que
no requiere un conocimiento o manipulación del código XML. De todas
maneras para entender el funcionamiento de Pentaho, recomendamos que
pare atención en la explicación de las secuencias de acción. Entonces puedes
ir a Getting Started with Design Studio para aprender más acerca del Pentaho
Design Studio y del editor de secuencias de acción.

Esta sección explica el XML que forma una secuencia de acción.


En la mayoría de casos Design Studio será suficiente para crear Secuencias de
Acción. Hay veces, que necesitas trabajar con el código XML. Algunes
ejemplos de cuando puede ser que necesites modificar directamente el código
XML:
• Normalmente hay un lapsus de tiempo desde el que se añade una nueva
funcionalidad a la Plataforma hasta que está disponible para Design
Studio.
• Es posible que tengas que trabajar en torno a un error en Design Studio.
• A veces, para una característica rara o caso especial el Design Studio
puede ser más confuso que editar el código XML.
• Componentes personalizados creados por ti, puede que no tengan
correspondencia en el UI
• Copiar y pegar piezas de una secuencia de acción a otra.
• Si estas desarrollando tus propios componentes necesitas enterder XML.
Aunque tengas que editar directamente XML, puedes hacerlo en el Design
Studio. Simplemente haz click en la pestaña XML Source. Cuando salgas de la
pestaña de XML, la secuencia de acción se chequeará para saber si es una
secuencia de acción válida o no.
Los componentes personalizados que Design Studio no entiende, se pueden
visualizar y editar en el panel Process Actions de la pestaña Define Process.
Estos componentes se mostrarán en una UI genérica que dejará editar inputs,
outputs y resources y tiene una caja de texto para editar el componente XML.

Ejemplo del XML de una Secuencia de Acción

Este es un listado de la Secuencia de Acción Example1.xaction


Documento.Example1.xaction

<action-sequence>
<name>Example1.xaction</name>

<!-- some header nodes deleted -->

<inputs>
<region type="string">
<default-value>Central</default-value>

15
<sources>
<request>REGION</request>
<session>aRegion</session>
</sources>
</region>

<from type="string">
<default-value>joepentaho@pentaho.org</default-value>
</from>

<subject type="string">
<default-value>Pentaho Example1</default-value>
</subject>

<message-plain type="string">
<default-value>
This is an email from the Pentaho BI Platform -
Example1
</default-value>
</message-plain>
</inputs>

<outputs/>

<resources/>

<actions>
<action-definition>
<action-inputs>
<region type="string"/>
</action-inputs>

<action-outputs>
<rule_result type="string"/>
</action-outputs>

<component-name>JavascriptRule</component-name>
<component-definition>
<script>
<![CDATA[
if ( "Central".equals( region ) ) {
rule_result = "joe@pentaho.org";
}
else {
rule_result = "suzy@pentaho.org";
}
]]>
</script>
</component-definition>
</action-definition>

<action-definition>
<action-inputs>
<to type="string" mapping="rule_result"/>
<from type="string"/>
<subject type="string"/>
<message-plain type="string"/>
</action-inputs>
<component-name>EmailComponent</component-name>
<component-definition/>
</action-definition>

16
</actions>
</action-sequence>

En este ejemplo, la Secuencia de Acción tiene 4 inputs: region, from,


subject and message-plain. Para region, el tipo es String; tiene el valor por
defecto Central y puede proceder de una o dos fuentes: request y session.
Cuando el Runtime Context resuelve el input region primero mira en la
request (lo más probable es que sea una http request), si no lo encuentra en
la request mira en la session (lo más probable es que sea una http session) .
Si no está disponible en la session, utiliza el valor por defecto. El orden en el
que buscará el input es el mismo orden del documento XML. El valor por
defecto siempre se utiliza como último recurso.
Los otros inputs solo especifican un valor por defecto. Este es análogo a
darle a un parámetro un valor constante. Ya que el output de esta secuencia
de acción es un email, no tendrá parámetros de salida.
Hay dos nodos definición de acción para esta secuencia. El primero define
una regla JavaScript y requiere un parámetro region; creará un nuevo
parámetro llamado rule_result. Este nuevo parámetro estará disponible
para otros nodos definición de acción en esta secuencia.
Sin entrar muy en detalle de la regla JavaScript, el script definido en el
component-definition será ejecutado y guardará el resultado en rule_result.
Cuando se complete el primer <action-definition>, se ejecutará el segundo.
Define una interacción con el componente Email. El componente Email
necesita 4 inputs: to, from, subject and message-plain. Te habrás fijado
que los action-inputs: from, subject and message-plain se especifican en
la cabecera de la secuencia de acción. El Runtime Context cogerá los
valores de allí y los enviará al componente Email de la misma manera que lo
hizo el componente JavaScript con region. El origen del atributo to no está
directamente definido, sinó que se define indirectamente con el atributo
mapping. Este atributo le dice al RuntimeContext que utilice el valor del
rule_result que fue generado por la regla JavaScript.

Definiendo Inputs (parámetros de entrada)

Hay tres tipos de parámetros que los documentos de secuencias de acción


entienden: inputs, outputs y resources. Inputs y outputs son variables de un
tipo de dato específico como string o property-map (ver valid data types.)
Resources son similiares a los inputs excepto que especifican un mime-type y
una ruta. A los resources no se les puede especificar un valor por defecto.
Generalmente los resources representan gran cantidad de datos como
definiciones de informes o imágenes (ver valid resource types.)
Los parámetros pueden proceder de 4 fuentes: runtime, request, session,
global y default.
• Los parámetros Runtime estan almacenados en el Runtime Context.
Recuerda, el Runtime Context guarda los inputs y outputs de
instancias anteriores y los hace disponibles para futuras ejecuciones
en la misma instancia de tiempo de ejecución.

17
• Los parámetros Request son los pares nombre-valor especificados
en una URL.
• Los parámetros Session son variables almacenadas en la sesion de
usuario y pueden contener valores únicos para cada usuario.
• Los parámetros Global son similares a los de session excepto en
que los global tienen los mismos valores para todos los usuarios.
• Los valores por defecto son especificacdos en el documento de la
Secuencia de Acción y se utilizan como último recurso.

Los parámetros Session y Global se pueden utilizar para proporcionar un


filtro seguro de datos en la Secuencia de Acción. Un parámetro session se
inicializa ejecutando una secuencia de acción cuando el usuario está en el
sistema. La Secuencia de Acción puede ser configurada para ejecutar una
consulta con el nombre del usuario en el Where. El resultado se guarda en
la sesion de usuario y está disponible para las siguientes secuencias de
Acción. Los parámetros Global se inicializan cuando se inicia el sistema y
están disponibles para todos los usuarios. Ver Using System Actions to
Control Data Access para más información sobre como utilizar los filtros.
Éste es un ejemplo de una sección inputs de una Secuencia de Acción:
<inputs>
<region type="string">
<sources>
<request>REGION</request>
<runtime>aRegion</runtime>
</sources>
<default-value>Central</default-value>
</region>
</inputs>

Éste ejemplo indica que la Secuencia de Acción requiere un parámetro


llamado region (distingue entre Mayúsculas/Minúsculas) El Runtime Context
mira primero si hay un parámetro llamado REGION en la request. Si la
Secuencia de Acción fue lanzada desde una URL, y había especificado un
parámetro REGION=xxx, entonces el valor xxx sería substituido por el input
region. Si no encuentra el parámetro en la request, mirará en sus propios
datos de tiempo de ejecución si hay un parámetro llamado aRegion. Si
tampoco lo encuentra, entonces utilizará el valor Central. Si no indicamos un
valor por defecto la secuencia de acción lanzará un error.
Hay dos parámetros implícitos: instance-id y solution-id, que siempre
están disponibles y no necesitan ser especificados en los inputs o outputs.

Tipos de datos

Los tipos de datos soportados actualmente por la Plataforma Pentaho son los
siguientes:
• content — Es una gran cantidad de datos generador en un
componente.
• long — Un Long Object de Java.
• property-map — Un property map de Java Strings.
• property-map-list — Una lista de property maps de Java Strings.

18
• string — La estandar Java String.
• string-list — Una lista de objetos Java String.

Resource Types

Los siguientes tipos de recursos son soportados por la Plataforma Pentaho:


• file — Una ruta absoluta en el sistema de archivos.
• solution-file — Un fichero en el sistema de ficheros ruta relativa al
actual documento de Secuencia de Acción.
• url — Una URL.

Actions

El documento de Secuencia de Acción es la definición, el Runtime Context


proporciona un entorno de ejecución y los componentes son la lógica de
negocio. Un Componente realiza una sola función, un grupo de funciones
relacionadas o es un puente entre la Plataforma Pentaho y una aplicación
externa. El componente JFree Reports es un ejemplo de puente al motor de
informes JFree Reports.

Hay dos funciones principales que un componente realiza: validar y ejecutar.


Validar se encarga de verificar que los inputs son válidos y todos los recursos
requeridos para poder ejecutarse están disponibles. Ejecutar realiza la acción.

El nodo action-definition en el documento de Secuencia de Acción define como


debe funcionar el componente. Es el lugar para definir inputs, outputs y
cualquier otro metadato o ajustes que el componente necesita cuando se
ejecuta. El nombre del componente se define en el nodo component-name. El
nombre es el nombre de una clase de Java que se carga dinámicamente en
tiempo de ejecución.

➢ Action-inputs

Los action-inputs y action-resources definen los parámetros que se le


pasan al componente. Algunos componentes tienen inputs que han de
estar disponibles o ocurrirá un error en tiempo de ejecución, aunque
algunos son opcionales. Por ejemplo, el componente Email requiere
un to pero el cc es opcional. Hay diferentes maneras de proveer un
input: pasado como parámetro con el mismo nombre al componente,
mapeado a un nombre diferente, darle un valor constante o en
algunos casos pedirle al usuario que lo introduzca. Por defecto el
componente email debe tener un elemento input como este:
<action-inputs>
<to type="string" />
. . .
</action-inputs>

➢ Action Input Mapping

19
¿Qué pasa si un componente requiere un input llamado x y yo le quiero
pasar un parámetro llamado y? Se puede mapear cualquier action-
input a un nombre diferente usando el atributo mapping. En nuestro
ejemplo del componente Email, suponemos que tenemos una regla
JavaScript que ejecuta una consulta y devuelve una dirección de
correo electrónico en un output-parameter llamado EMAIL. También
vamos a suponer que quiero utilizar ese parámetro para el parámetro
to del componente Email. El fragmento XML se parecerá a este:
<action-inputs>
<to type="string" mapping="EMAIL"/>
. . .
</action-inputs>

➢ Constant Values as Inputs

Si un componente requiere un parámetro input y no lo encuentra en el


action-inputs, automáticamente buscará un nodo XML con el mismo
nombre en la sección component-definition. Si encuentra uno, utilizará
su valor. El trozo de XML se parecerá a éste:
<action-inputs>
</action-inputs>

<component-definition>
<to>joe.pentaho@pentaho.org</to>
</component-definition>

➢ Replaceable Parameters

Todos los componentes tienen la capacidad de utilizar un mecanismo


de plantilla para reemplazar texto usando los parámetros input. Eso
significa que un valor constante puede ser modificado utilizando el
valor de un action-input. Hmmm parece que no queda muy claro,
veamos un ejemplo:
<action-inputs>
<EMAIL type="string"/>
. . .
</action-inputs>

<component-definition>
<to>{EMAIL}@pentaho.org</to>
</component-definition>

El texto que está entre llaves {} es reemplazado por un parámetro input


con el mismo nombre. En nuestro ejemplo, si el valor del action-input
EMAIL es joe.pentaho entonces el valor del parámetro to pasado al
componente email debería ser joe.pentaho@pentaho.org.

Esquema XML

20
Actualmente no es un esquema, pero explica el XML para Secuencias de
Acción y los requerimientos de nodos.
Los nodos XML marcados como REQUIRED solo son requeridos si su nodo
padre está siendo usado. Los atributos que aparecen entre corchetes [ ] son
opcionales.
• <action-sequence> REQUIRED – Nodo raíz del documento de
Secuencia de Acción
• <name> NOT REQUIRED – El nombre de la secuencia de
acción, debe coincidir con el nombre del documento.
• <version> NOT USED – Versión del documento.
• <title> NOT REQUIRED – Nombre “amigable” del documento.
Solo se usa para ser mostrado.
• <logging-level> NOT REQUIRED – Indica el nivel de logging
de la Secuencia de Acción. Los valores válidos son: TRACE,
DEBUG, INFO, WARN, ERROR y FATAL. Si no hay nivel de
logging se utiliza ERROR.
• <documentation> NOT REQUIRED – Contiene los nodos
descriptivos utilizados para generar documentación.
• <author> - NOT REQUIRED – Autor de la Secuencia de
Acción.
• <description> - NOT REQUIRED – Descripción corta
(1-3 lineas) de la secuencia de acción. Esta descripción
es utilizada por el componente de navegación de la
solución para generar su visualización.
• <help> - NOT REQUIRED – Descripción larga de la
secuencia de acción incluyendo las instrucciones de uso
para el usuario final.
• <result-type> - NOT REQUIRED – Tipo de output que
generará la secuencia de acción. Es utilizado por el
componente de navegación de la solución para generar
su visualización. Las secuencias de acción sin un result-
type no serán mostradas por el componente de
navegación. Los valores válidos son: Report, Process,
Rule, View y None.
• <icon> - NOT REQUIRED – Icono para representarlo.la
ruta a la imagen es relativa al directorio donde se
encuentra el documento de la secuencia de acción. Por
ejemplo: Example1_image.png
• <inputs> - NOT REQUIRED – Colección de parámetros de
entrada.
• <param-name type="data-type" > - NOT REQUIRED –
param-name es el nombre un parámetro que la
secuencia de acción espera en tiempo de ejecución. El
atributo type especifica el tipo de dato del parámetro.
The type attribute specifies the data type of this
parameter. Mirar más abajo para saber los tipos de
datos válidos.
• <default-value> - NOT REQUIRED – Valor por defecto
del parámetro. Se utilizará en última instancia.

21
• <sources> - NOT REQUIRED – Lista de proveedores
de parámetros en el orden en que deben ser examinado
para obtener un parámetro. Los valores válidos son
request, session y runtime. Nota: si un param-name se
introduce pero no se especifican default-value y sources
sucederá un error de validación.
• <outputs> - NOT REQUIRED – Colección de parámetros de
salida.
• <param-name type="data-type" > - NOT REQUIRED –
param-name es el nombre de un parámetro que se
establecerá cuando todas las all action-definitions se
hayan ejecutado. El atributo type especifica el tipo de
dato del parámetro. Ver abajo los tipos de datos válidos.
• <logging-level> NOT REQUIRED - Indica el nivel de logging
de la Secuencia de Acción. Los valores válidos son: TRACE,
DEBUG, INFO, WARN, ERROR y FATAL. Si no hay nivel de
logging se utiliza ERROR.
• <resources> - NOT REQUIRED – Colección de parámetros
resource.
• <resource-name > - NOT REQUIRED – resource-name
es el nombre de un recurso que se espera usar en la
secuencia de acción. El atributo type especifica el tipo
de dato del parámetro. Ver abajo los tipos de datos
válidos.
• <resource-type> - REQUIRED – El nombre del tipo de
recurso. Los valores válidos son: solution-file, file y url.
• <location> - REQUIRED – La ruta del recurso. Para un
resource-type de "solution-file", la ruta es relativa al
primer nivel de la solución actual. Si el resource-type es
"file" es una ruta absoluta. Para resource-type "url" es
una URL.
• <mime-type> - NOT REQUIRED – Da una pista sobre el
tipo de mime del recurso.
<*actions [loop-on="parameter-name"] > -
REQUIRED – El nodo actions contiene nodos
"action-definition" y opcionalmente más nodos
"actions". El atributo loop-on es opcional. Cuando
se utiliza, los nodos dentro de "actions" se
ejecutarán múltiples veces. Es necesario
especificar un parámetro que sea de tipo lista
(string-list o property-map-list) y el grupo de nodos
que serán ejecutados para cada elemento de la
lista. Un parámetro input será generado con el
mismo nombre que el atributo loop-on pero tendrá
el valor de un elemento de la lista. Por ejemplo: su
un atributo loop-on llamado "department" es un
string-list con nombres de departamentos, entonces
un parámetro llamado department estará disponible
y contendrá un nombre diferente de departamento
para cada iteración.

22
• <actions [loop-on="parameter-name"] > - NOT REQUIRED –
Una iteración a un solo nivel no es muy divertido, los nodos
actions pueden estar anidados en otros nodos actions al nivel
deseado.
• <action-definition> - REQUIRED (Almenos 1) – Define una
llamada a un componente para la ejecución de una tarea.
• <action-inputs> - NOT REQUIRED – Colección de parámetros
de entrada.
• <input-name type="data-type" mapping="param"> -
NOT REQUIRED - input-name es el nombre de un
parámetro que la secuencia de acción espera tener
disponible cuando se ejecuta. El atributo type especifica
el tipo de dato de este parámetro, ver 3 - Data Types
para más información sobre los tipos de datos válidos.El
atributo mapping permite a este input estar mapeado a
un input o a un output previo con un nombre diferente.
• <action-outputs> - NOT REQUIRED – Colección de
parámetros action-output.
• <output-name type="data-type" > - NOT REQUIRED –
output-name es el nombre de un parámetro que
contendrá un valor cuando se haya finalizado la
ejecución. El atributo type especifica el tipo de dato del
parámetro.
• <component-name> - REQUIRED – El nombre de la
clase de Java que ejecuta la definición de acción.
• <component-definition> - REQUIRED – La definición
XML específica del componente. Este nodo puede estar
vacío pero debe existir o se lanzará un error de
validación.

23
Ejecución de una Secuencia de Acción

Hay diferentes maneras de ejecutar una solución: via Design Studio, URL,
Código Java o una llamada Web Service.

Design Studio

Haciendo click en la pestaña test del editor HelloWorld.xaction. Al principio


de la página, hay un campo titulado "Pentaho Server URL”. Si tu servidor
pentaho esta corriendo, entra la URL que debe ser
http://localhost:8080/pentaho si es la PCI. Hacer click en el botón "Test
Server" y verificas que estas trabajando con los ejemplos. Hacer click en
"Run" para ejecutar la secuencia de acción HelloWorld. Deberás ver el
mensaje "Hello World. Greetings from the Pentaho BI Platform.", en el caso
que no lo veas, asegúrate que el servidor está corriendo y que escribiste la
URL correcta. Verifica que puedes ejecutar los ejemplos desde tu
navegador. Si algo más falla, puedes mirar en el foro seguro que te podrán
ayudar o encontrarás información de otras personas a las que también les
ha pasado en www.pentaho.org.

URL

Los ejemplos que vienen con la instalación preconfigurada (PCI) son


lanzadas mediante URL usando el servlet ViewAction
(org.pentaho.ui.servlet.ViewAction). La siguiente URL lanzará la secuencia
de acción HelloWorld:
http://localhost:8080/pentaho/ViewAction?&solution=samples&path=getting-
started&action=HelloWorld.xaction
El resultado devuelto depende de la secuencia de acción, puedes obtener
un informe, un mensaje de texto o solo "Action Successful." Se pueden
entrar los siguientes parámetros en la URL:
• solution, path, action* - La ruta del documento de secuencia de
acción a cargar.
• instance_id* - El identificador de instancia de Runtime Context
previos.
• debug* - poner a "true" para obtener la información de
depuración escrita en el log.

Llamada Web Service

En el grupo "Settings and Services" de los ejemplos está Web Service


Example. También es una llamada por URL, esta vez al servlet
ServiceAction (org.pentaho.ui.servlet.HttpWebService). La siguiente URL
lanzará la secuencia de acción HelloWorld:
http://localhost:8080/pentaho/ServiceAction?solution=samples&path=getting-
started&action=HelloWorld.xaction
En este caso, el resultado devuelto es una respuesta XML SOAP. Los
siguientes parámetros se pueden poner en la URL:

24
• solution, path, action* - La ruta del documento de secuencia de
acción a cargar.
• instance_id* - Identificación de instancia de un Runtime
Context previo.
• debug* - poner a "true" para obtener información de depuración
escrita en el log.

Llamada Java

Una secuencia de acción puede ser ejecutada directamente de una


aplicación Java. Un ejemplo de como hacerlo: abre el fichero
"org.pentaho.test.RuntimeTest.java" y busca en el JUnit test la HelloWorld.
Esta clase (código) se puede encontrar en el repositorio público de Pentaho
en svn://source.pentaho.org/svnroot.

Action Sequence Recap

Los inputs, outputs y recursos de la cabecera de la secuencia de acción


defina un contrato entre la secuencia de acción y el mundo exterior.La
secuencia necesita los inputs y recursos especificados y devolverá los
outputs especificados.
La action-definition define un contrato entre cada componente y la secuencia
de acción. Los action-inputs y action-resources definen los parámetros que
necesita un componente para poder ejecutarse. Los action-outputs definen
qué parámetros estarán disponibles después de haberse completado la
ejecución. El Output de un componente puede utilizarse como input de otro
componente. El atributo mapping de la action-inputs permite que los outputs
de un componente tengan diferentes nombres para poder utilizarse como
input de otro componente.
La especificación de las relaciones input/output y sus tipos de datos
permiten al sistema validar una secuencia de acción sin ejecutar los
componentes. Una solución completa puede ser validada y cerrada para
prevenir la modificación de los documentos de secuencia de acción y
eliminar errores "locked down" to prevent modification of the Action
Sequence documents and eliminate errors debidos a “enlaces rotos” entre
esos documentos.

25
Integración de Pentaho Reports (JFreeReports)

Para más documentación sobre el uso de JFreeReport con ver


Reporting:Report Design Wizard

Definiciones de informes JFreeReport

Las definiciones de un informe JFreeReport son documentos XML con la típica


extensión .xml extension, aunque no es necesario. El Pentaho
JFreeReportComponent (org.pentaho.plugin.jfree.JFReeReportComponent)
utiliza definiciones de informes junto con tus datos para obtener un conjunto de
formatos de salida que son HTML, PDF, CSV, XLS y RTF.

JFreeReport obtiene sus datos de una Java TableModel. Desde que el


JFreeReport opera contra una definición y un TableModel no hay manera de
parametrizar el JFreeReport por él mismo. Esto se hace en la action-sequence
y en la consulta.

Utilizando el Pentaho Report Design Wizard puedes crear una definición de


JfreeReport y una secuencia de acción básica. En el caso más simple crea un
informe con una plantilla <Blank> y una consulta SQL contra tu base de datos.

La imagen de anterior muestra una consulta SQL parametrizada dentro del


Report Design Wizard. La columna 'REGION' es lo que usaremos para
nuestro parámetro. El nombre del parámetro también es 'REGION' pero no
es necesario que sea así. El asistente actualmente no tiene la capacidad de
pedir al usuario el valor de los parámetro, así que el valor por defecto será
'Eastern'. El parámetro entero se especifica de la siguiente manera en la
consulta: {REGION=Eastern}.
Cuando se previsualiza el informe en el Report Design Wizard el valor del
parámetro REGION es reemplazado por el valor por defecto (Eastern).
Cuando el informe es publicado en la plataforma Pentaho el parámetro
REGION es iniciado en el action-sequence y se le pedirá al usuario que
entre un valor.

Creating the Action Sequence

Una vez nos hemos asegurado que el informe funciona en Report Design
Wizard podemos estar seguros que también funcionará en la Plataforma
Pentaho. La razón de que pase esto es que el Report Design Wizard ejecuta el
informe en una version independiente embedida de la Plataforma Pentaho. No
hay necesidad de crear una action-sequence una vez haya sido generado
automáticamente por el asistente. De todos modos, deberías tener una

26
definición de JFreeReport creada “a mano” o por otra herramienta. Un ejemplo
de secuencia de acción que genera un informe Jfree usando parámetros es el
archivo
pentaho_demo/pentaho_solutions/samples/bursting/BurstActionSequence.xacti
on. Seleccionar la pestaña Define Process y seleccionar la acción JFree Report
en el árbol de acciones de proceso (Process actions).

JDBC Driver Setup

Si utilizas un driver para una base de datos diferente a Hypersonic necesitarás


configurar el JBoss PCI para usar ese driver.

Verificando la integración de JFreeReport en la Plataforma Pentaho

En este punto el informe debería estar preparado para utilizar. At this point the
report should be plugged in and ready for use. Abre el navegador en tu PCI
(normalmente http://localhost:8080). Navega hasta el informe que acabas de
crear en el grupo Reporting Examples.

Se le pedirá al usuario que introduzca un valor para el parámetro REGION.

27
Una vez introducido el valor del parámetro se generará el informe y
dependiendo del output-type de la action-sequence lo verás en el formato
deseado. La imagen anterior muestra una informe en formato HTML.

The Report Design Wizard

El Pentaho Report Design Wizard proporciona una creación rápida y fácil de


informes Jfree utilizando un simple proceso paso-a-paso, que permite editar y
dar formato al informe. Ésta es la manera más fácil para desarrollar
rápidamente informes Jfree. El asistente está disponible tanto en la aplicación
independiente como en un editor en el Pentaho Design Studio. Para una
descripción detallada sobre como usar el asistente leer el documento Report
Design Wizard User's Guide.

Creación de una especificación con Design Wizard

Seleccionar el icono del Pentaho Design Studio y elegir "New JFree Report
Wizard File". Entonces seleccionar el botón Container Browse, y escoger la
carpeta "reporting" en el PCI y apretar OK. Ahora has de darle a tu nueva
secuencia de datos un nombre y ya estás preparado para diseñar tu informe. Si
no lo has hecho nunca puedes mirar un ejemplo de cómo hacerlo en el
documento Report Design Wizard User's Guide. Cuando el diseño esté
completo asegurate de guardarlo.

28
Usando una especificación de Design Wizard

Una vez diseñado el informe es hora de integrarlo en una secuencia de acción


que permitirá ejecutarlo como parte de la solución instalada. Utilizando elmismo
proceso descrito anteriormente, crear una secuencia de acción vacía en el
directorio "reporting" de tu solución. Asignarle un título, icono y breve
descripción para ayudarte a encontrarla cuando la probemos. Seleccionar la
pestaña de definición de proceso y con el botón derecho del ratón hacer click
en el area Process Actions y seleccionar Add->Report->JFree Report.
Seleccionar el link que pone Browse en el lado derecho de la página. En el
cuadro de diálogo para escoger el archivo seleccionar el tipo de archivo Report
Wizard Spec (*.xreportspec) y abrir la especificación de asistente que creaste
antes. Guarda la nueva secuencia de acción, y ya está, así de simple.

En el navegador ir a los ejemplos de informes en la PCI. Deberías ver una


nueva entrada para la nueva secuencia de acción que hemos creado antes.

29
2. Guía de referencia de Acciones y Componentes

Cada acción en la secuencia de acciones es reponsable de describir un tipo


particular de tarea para que sea ejecutada por el Motor de Soluciones. Por
ejemplo una acción de consulta SQL describe una consulta, la conexión JNDI o
JDBC y el nombre del output que utilizará para guardar el resultado. Detrás de
cada acción hay un componente que ejecuta la acción. Para el servidor los
componentes no son más que clases Java. De la misma manera que el motor
de soluciones procesa cada acción en una secuencia de acción, también
ejecuta el componente que ejecuta ese tipo de acción. En muchos casos hay
una correspondencia uno-a-uno entre el tipo de acción y el componente que
ejecuta la acción, por ejemplo el SQLLookupRule es un componente que solo
procesa acciones de consulta SQL. Pero no siempre pasa, por ejemplo el
UtilityComponent puede ejecutar múltiples tipos de acciones.

Igual que la misma secuencia de acciones, cada acción tiene también una lista
de inputs y outputs. Los parámetros inputs le dicen al componente cómo
realizar la acción. Cada acción en la Plataforma Pentaho tiene unos inputs
específicos que han de ser especificados correctamente. Aunque también tiene
inputs y definiciones opcionales.

Los outputs dicen qué parámetros estarán disponibles en el runtime context


cuando haya finalizado la ejecución. Otras/os acciones/componentes que se
ejecuten después pueden utilizar esos outputs como parámetros de entrada
(inputs). Esta sección explica muchas de las acciones disponibles con sus
inputs y outputs.

Llamada a una Secuencia de Acción externa

Esta acción se utiliza para llamar a otras secuencias de acción de la misma


manera que la programación "GoSub". Las SubAcciones se ejecutan
sincronizadamente.

Component Name: SubActionComponent

Inputs:
REQUIRED
solution – La solución que contiene la secuencia de acción.
path – Ruta de la secuencia de acción dentro de la solución.
action – El nombre del .xaction llamado (debe incluir la extensión .xaction).
OPTIONAL
action-url-component – Especifica la url de la acción para ponerla en el
“ViewAction?”.
session-proxy – Nombre del campo input para utilizarlo como el nombre para
la nueva sesión en la sub acción.
Cualquier nombre de input de la .xaction desde la que se llama que se quiera
pasar a la .xaction que es llamada. La secuencia de acción que se llama
accede a los inputs a través del request (request inputs).

30
Outputs:
Cualquier output de la secuencia de acción desde la que se hace la llamada
que se necesite en la secuencia de acción que se llama.

Chart Action

Actualmente la plataforma Pentaho utiliza como motor de gráficos JfreeChart.

Component Name: ChartComponent

El ChartComponent es un componente BI que puede crear graficos incluyendo:

• Gráficos de barras

• Gráficos de linea

• Gráficos de barras y lineas combinadas

• Gráficos de pastel

• Gráficos multi-pastel (conocidos como pie grids)

• Gráficos de área

• Gráficos de burbuja.

Para utilizar correctamente este componente deberías mirar Chart Reference.

Inputs
REQUIRED INPUTS
chart-data
El conjunto de datos que quieres representar en el gráfico. A menudo, es el
resultado de una acción SQLLookupRule, pero puede provenir de diferentes
acciones.
chart-attributes
Éste componente espera bastantes propiedades de gráficos para generar el
gráfico y mostrar los datos de manera apropiada. Hay bastantes maneras de
definir los atributos de gráficos en una secuencia de acción. Puedes
especificar las propiedades en un input, como un resource, o en-linea en la
sección de definición del componente de la secuencia de acción.

31
El componente de gráficos y Design Studio

Aunque puedes acceder al componente de gráficos mediante la interfaz gráfica


de Design Studio,éste aún no proporciona una interfaz cómoda para definir
todas las propiedades. Se está trabajando en ello (¡también puedes contribuir!),
pero por ahora, has de utilizar la pestaña XML para editar y añadir
propiedades.

Chart Attributes como un Input


Puedes especificar las propiedades del gráfico como un parámetro input tipo
String. La única cosa a tener en cuenta es que las propiedades han de
representarse en formato de string de XML, dentro de una secciónCDATA.
El atributo debe llamarse chart-attributes.
Este es un ejemplo de especificación de las propiedades de gráficos como
un input.
<inputs>
<attributes type="string">
<sources>
<request>attributes</request>
</sources>
<default-value>

<![CDATA[

<chart-attributes>
<chart-type>BarChart</chart-type>
<border-visible>false</border-visible>
<is-clickable>false</is-clickable>
<include-legend>true</include-legend>

... more chart attributes here ...

</chart-attributes>

]]>

</default-value>
</attributes>
</inputs>

...

<action-definition>
<component-name>ChartComponent</component-name>
<action-type>Bar Chart</action-type>
<action-inputs>
<chart-data type="result-set" mapping="query_result"/>
*<chart-attributes type="string" mapping="attributes"/>*
</action-inputs>

...

32
Chart Attributes como un Resource
También puedes poner los chart-attribute en un fichero XML, y entonces
hacer referencia a él en tu secuencia de acción como un resource.
El nombre utilizado para hacer referencia debe ser must be chart-
attributes. Haz click aquí para ver un ejemplo de un fichero que contiene
un chart-attribute válido.
La secuencia de acción sería más o menos así:
<resources>
<chart_resource>
<solution-file>
<location>testchart.xml</location>
<mime-type>text/xml</mime-type>
</solution-file>
</chart_resource>
</resources>

<actions>

...

<action-definition>
<component-name>ChartComponent</component-name>
<action-type>Bar Chart</action-type>
...
<action-resources>
<chart-attributes type="resource" mapping="chart_resource"/>
</action-resources>

...

Chart Attributes en la definición del componente


Por defecto, el Design Studio pondrá el nodo XML chart-attributes en la
definición del componente. Esta manera es correcta, pero puede ser
problemática si lo que quieres es añadir o cambiar dinámicamente una
propiedad del gráfico en el proceso de tu secuencia de acción. Esta es la
razón de por qué se añadió la capacidad de definir las propiedades de las
dos maneras anteriores.
Ejemplo:
<action-definition>
<component-name>ChartComponent</component-name>
<action-type>Bar Line Chart</action-type>

...

<component-definition>
<chart-attributes>
<chart-type>BarLineChart</chart-type>
<border-visible>true</border-visible>
<include-legend>false</include-legend>
<is-3D>false</is-3D>
<markers-visible>false</markers-visible>

... more chart attributes here ...

</chart-attributes>

33
</component-definition>
</action-definition>

OPTIONAL INPUTS
Las siguientes propiedades son opcionales y se pueden especificar como
inputs o en la component-definition. Muchas de esas propiedades
duplican propiedades que puedes especificar en la definición del gráfico
(chart-attributes string o fichero). Cuando esas propiedades diplicadas son
inputs o definidas en la component-definition, sobreescriben cualquier
propiedad idéntica que exista en el chart-attributes. La jerarquía natural de
esas propiedades permite establecer o sobreescribir dinamicamente un
valor, pero también tiene un valor por defecto en el chart-attributes.
by-row
Indica los datos del gráfico que serán agregados a lo largo de las
dimensiones de la fila. Por defecto vale false.
title
Establece el título del gráfico.
width
Anchura del gráfico.
height
Altura del gráfico.
url-template
Plantilla de URL para utilizar un drill point en el gráfico.
paramName
Parámetro reemplazable por la URL. Normalmente el valor de la categoría
del drill point, si es aplicable.
series-name
Parámetro reemplazable por la URL. Normalmente, el nombre de la seria del
drill point; también se le hace referencia como ParamName2 en alguna
documentación.

Outputs
El ChartComponent puede devolver el gráfico y su mapa de imagen (si las
URL de los drill son definidas mediante URLTemplate). Éstos son los outputs
que puedes especificar y el resultado para cada uno:
• CHART_OUTPUT (<chart-output type="content"/>)
• Guarda el gráfico en el repositorio de contenidos para ser
utilizado en una acción o proceso, o mostrarlo si el destino de
salida es response y el nombre es content.
• CHART_FILE_NAME_OUTPUT (<chart-filename type="string"/>)
• Devuelve el nombre del fichero del gráfico, incluyendo la
extensión del fichero (sin la ruta) como un String.
• HTML_MAPPING_OUTPUT (<chart-mapping type="string"/>)
• Devuelve el nombre del fichero en el que se ha guardado el
mapa, incluyendo la extensión del archivo (sin la ruta) como un
String.

34
• HTML_MAPPING_HTML (<chart-map-html type="string"/>)
• Devuelve el mapa HTML de imagen del gráfico como una
String.
• BASE_URL_OUTPUT (<base-url type="string"/>)
• Devuelve la URL base de la aplicación web (es decir,
http://localhost:8080/pentaho) como una String.
• HTML_IMG_TAG (<image-tag type="string"/>)
• Devuelve un fragmento HTML que incluye el mapa de imagen,
la etiqueta de imagen (<IMG />) de la imagen del gráfico con
los atributos src, width, height y usemap definidos.

Ejemplo de Secuencia de Acción


La siguiente secuencia de acción utiliza el outpur de un SQL lookup rule
( una fuente de datos relacional) como el input para un ChartComponent.
Ver Chart Properties Reference para más información sobre las propiedades
de los gráficos.
Ejemplo Chart.xaction
<action-sequence>
<name>Chart.xaction</name>
<title>Default Title</title>
<version>1</version>
<logging-level>DEBUG</logging-level>
<documentation>
<author>William E. Seyler</author>
<description>Default Description</description>
<icon>JFree-quadrant-budget-hsql.png</icon>
<help>Help</help>
<result-type>rule</result-type>
</documentation>
<inputs>
<chart-type type="string">
<default-value>.png</default-value>
<sources>
<request>type</request>
</sources>
</chart-type>
</inputs>
<actions>
<action-definition>
<action-outputs>
<result-set type="list" />
</action-outputs>
<component-name>SQLLookupRule</component-name>
<action-type>rule</action-type>
<component-definition>
<source>sql</source>
<live>true</live>
<jndi>SampleData</jndi>
<query>
<![CDATA[select QUADRANT_ACTUALS.REGION,
QUADRANT_ACTUALS.DEPARTMENT,
QUADRANT_ACTUALS.POSITIONTITLE, QUADRANT_ACTUALS.ACTUAL,
QUADRANT_ACTUALS.BUDGET
from QUADRANT_ACTUALS order by
QUADRANT_ACTUALS.REGION,QUADRANT_ACTUALS.DEPARTMENT]]>
</query>
</component-definition>

35
</action-definition>
<action-definition>
<action-inputs>
<output-type type="string" mapping="chart-type" />
<result-output type="file" />
<chart-data type="list" mapping="result-set" />
</action-inputs>
<action-outputs>
<chart-output type="string" />
<base-url type="string" />
</action-outputs>
<component-name>ChartComponent</component-name>
<action-type>report</action-type>
<component-definition>
<by-row>false</by-row>
<chart-attributes>
<chart-type>PieChart</chart-type>
<title>Actual vs Budget by Region</title>
<title-position>TOP</title-position>
<title-font>
<font-family>Serif</font-family>
<size>36</size>
<is-bold>false</is-bold>
<is-italic>false</is-italic>
</title-font>
<range-title>US Dollars</range-title>
<chart-background type="color">#FFFFFF</chart-background>
<plot-background type="color">#FF0000</plot-background>
<orientation>Horizontal</orientation>
<height>400</height>
<width>800</width>
<is-3D>true</is-3D>
<is-stacked>false</is-stacked>
<category-label-rotation>90</category-label-rotation>
<border-visible>false</border-visible>
<border-paint>#3399FF</border-paint>
<include-legend>true</include-legend>
</chart-attributes>
</component-definition>
</action-definition>
</actions>
</action-sequence>

Content Repository Cleaner

Esta acción borra ítmes que no se necesitan del repositorio de contenido. Sólo
necesita un input, un número que representa por cuando tiempo se permite que
permanezca un ítem en el repositorio de contenido. Es decir, si el valor es 90
se borrarán los elementos que haga más de 90 días que están en el repositorio
de contenido.

36
Component Name: ContentRepositoryCleaner

Inputs:
REQUIRED
Expiration Days – Número de dias que puede permanecer un elemento en
el repositorio de contenido.

Outputs:
Deleted Items – Número de elementos eliminados del repositorio de
contenido.

Email

This action sends text or HTML based emails that may contain attachments. If
the data type of the to parameter is property-map, then the map is assumed to
contain the name value pairs for to, subject and from. The parameter attach
should contain the name of a parameter of type content that contains the
attachment. attach-name is the file name that the attachment will appear to
have when opened by the email client.

Component Name: EmailComponent

Inputs:
REQUIRED
To – Direcciones de email destino.
Subject – Asunto del correo.
Text Message – Cuerpo del mensaje en texto plano.
HTML Message – Cuerpo del mensaje en HTML.
OPTIONAL
From – Dirección de correo del remitente. Si no se especifica se utilizará el
valor del fichero "email_config.xml".
CC – Direcciones de correo a las que enviar una copia.
BCC - The email address of blind carbon copy recipient.
Attachment Name – Nombre del fichero adjunto.
Attachment – Fichero adjunto.

Outputs: None

Component Definitions:
attachment-ref – define un adjunto para incluirlo en el correo.

37
Hello World

Esta acción simplemente devuelve el texto especializado al navegador cliente.

Component Name: HelloWorldComponent

Inputs:
Message – Texto a mostrar.

Outputs: Ninguno.

HQL

Éste componente permite hacer una consulta a cualquier base de datos


Hibernate mapeada utilizando sintaxis HQL.

Component Name: HQLLookupRule

Component Definitions: None

Resources:
hibernateConfig – Referencia a un fichero de configuración hibernate.

Inputs:
ClassNames – Lista de los nombres de las clases java que estan mapeadas
a una base de datos hibernate.
prepared_component – Nombre de un componente preparado que
contiene una conexión hibernate (necesario si no se utiliza el input query)
query – Consulta de una base de datos hibernate utilizando sintaxis HQL
(necesario si no se utiliza un input prepared_component)

Outputs:
Query-result – del tipo "result-set" Mapeado a un IPentahoResultSet

JavaScript

Esta acción ejecuta un Javascript. El componente JavascriptRule puede tenr


uno o más outputs.
El componente también define una librería de elementos en su definición. Cada
fichero de librería especificado debe existir en la solución. Entonces puedes
crear una librería de código javascript e incluirla en tiempo de ejecución.

38
Component Name: JavascriptRule

Inputs:
REQUIRED
Javascript – El Javascript a ejecutar.
Imported Javascript – Cualquier fichero de la solución que contienen
funciones Javascript referenciado por este Javascript.

Outputs:
Cualquier variable del JavaScript. Cualquier resultado de salida que no
tenga un valor asignado en el JavaScript se le asignará un valor null.

JFree Reports

Esta acción genera informes JFree utilizando las definiciones JFree o una
especificación Report Wizard.

Component Name: JFreeReportComponent

Component Definitions:
report_configuration_parameters – contiene un grupo de propiedades de
configuración para el informe, definidas como <name>value</name>.

Resources:
Report-jar – referencia a un fichero jar que contiene la definición del
informe y/o la implementación de la fuente de datos.
Report-definition – referencia a una definición jfreereport.

Inputs:
Data – También acepta "default", especifica la principal fuente de datos para
el jfreereport. También se pueden definir fuentes de datos para los
subinformes, los nombres deben coincidir con la fuente de datos utilizada en
la consulta del subinforme.
Class-location - utilizada en junto a report-jar, especifica la ubicación de la
clase de la fuente de datos.
config_parameters - specifies especifica un mapa o resultset utilizado para
llenar las propiedades de configuración del informe.
Report-definition - referencia dinámicamente a una definición se jfreereport.
Resource-name - especifica el nombre del recurso del que cargar la
definición del jfreereport.
Report-location - usado junto con report-jar, especifica la ubicación de la
definición del informe.
Res-url – input opcional que especifica la url base.
Printer-name - si se especifica, se utiliza el componente printer jfree para
generar el informe.
Output-type – tipo de salida generada por jfreereport. Las opciones válidas
son html, pdf, csv, xml, rtf, xls, swing-preview
yield-rate - si se especifica, llama a Thread.yield en el intervalo indicado.

39
create_private_report - si vale true, clona el objeto informe para garantizar
un único uso
report-priority – especifica la prioridad de hilo cuando se genera el
jfreereport. Las opciones son normal, lower, y lowest
Inputs específicos de Html:
content-handler – Especifica el contenido del handler
Inputs específicos de Excel:
workbook – define el nombre del libro utilizado para genrar el fichero xls.
Inputs específicos de Swing Preview:
report-controler – una referencia al controlador de informe.
Parent-dialog – referencia al cuadro de diálogo padre.
Modal – true si el cuadro de diálogo ha de ser modal.
Progress-bar – true si se muestra la barra de progreso.
Progress-dialog – true si se muestra el cuadro de diálogo progreso.

Outputs:
Report-output – el nombre por defecto del informe generado.
Cualquier otro output definido será utilizado en lugar del anterior como un
nombre.

Kettle

Las acciones Kettle permiten la ejecución de operaciones ETL (Extracción,


Transformación y Carga) en una secuencia de acción utilizanto la herramienta
ETL open source Kettle. Las operaciones soportadas incluyen la ejecución de
transformación de Kettle y jobs de Kettle. Para más información ir a
http://kettle.pentaho.org.

Transformación de Kettle

Ejecuta una transformación de Kettle y guarda los datos obtenidos en un


output result set.

Component Name: KettleComponent

Inputs:
REQUIRED
Transformation Step – El paso en la transformación del que obtener los
datos.
OPTIONAL
Transformation Inputs – Permite la inclusión de inputs a la transformación
en Kettle.
Directory – especifica el repositorio Kettle, usado conjuntamente con el
input "transformation"

40
Outputs:
Output Name – El nombre del result set que contendrá los datos una vez
realizada la transformación.

Resources:
REQUIRED
Transformation File – Fichero de transformación de Kettle que se
ejecutará.

Kettle Job

Ejecuta un Job de Kettle.

Component Name: KettleComponent

Inputs:
OPTIONAL
Job Inputs – Permite la inclusión de inputs en el job de Kettle.
Directory – indica si se carga del repositorio de Kettle, se usa junto con el
input "job"
Resources:
REQUIRED
Job File – Fichero del job de Kettle a ejecutar.

Kettle Repository Configuration

Para configurar el repositorio de kettle, hay que modificar el fichero pentaho-


solutions/system/kettle/settings.xml:
repository.type – fichero o rdbms
repository.name – nombre del repositorio
repository.userid – nombre de usuario para acceder al repositorio
repository.password – contraseña para acceder al repositorio

MDX Query

Proporciona el poder hacer una consulta a bases de datos multidimensionales


utilizando la estructura de consulta MDX.

Inputs:
REQUIRED
connection – cadena de conexión JDBC para la fuente de datos. Si
necesitas conectarte a otra fuente de datos que no sea hypersonic debes
proporcionar los drivers JDBC, mirar mdx-connection-sring más abajo para
saber cómo hacerlo. Se deben especifiar este nodo o mdx-connection-
sring.

41
Nota especial: Para compartir una conexión Mondrian con el componente
PivotViewComponent (JPivot), hay que especificarla en un formato concreto:
java:comp/env/jdbc/DATASOURCE_NAME.
O
mdx-connection-sring – Se puede utilizar por encima de todas las
propiedades de conexión, de hecho “machacará” las propiedades. Esta
cadena es una lista de nombres de propiedades separadas por “;”. Éste es
un ejemplo para una conexión basada en el mdx-connection-string:
mondrian; Jdbc=jdbc:odbc:MondrianFoodMart; Catalog=/WEB-
INF/FoodMart.xml. Cuando se utiliza este formato elnombre de usuario y
contraseña se le puede pasar como parte de la cadena de conexión del jdbc,
dependiendo del driver utilizado. Los nombres de los drivers también se
pueden pasar en esta cadena. Para más información sobre este tipo de
conexión consultar la documentación de Mondrian. Hay que especificar o
esta cadena o el JDBC Connection.
User-id – ID del usuario JDBC. Si se utiliza otro datasource diferente a
hypersonic puede que no se evalúe correctamente y probablemente
necesitaras la mdx-connection-sring para indicar el nombre de usuario y
contraseña.
password – Contraseña del JDBC. Si se utiliza otro datasource diferente a
hypersonic puede que no se evalúe correctamente y probablemente
necesitaras la mdx-connection-sring para indicar el nombre de usuario y
contraseña.
Query – String con la consulta MDX que define el conjunto de datos. Para
más información consultar la documentación de Mondrian o visita:
http://www.informit.com/articles/article.asp?p=29418&seqNum=3&rl=1

Resources:
REQUIRED
Catalog – Ruta del catálogo ROLAP. Si el catálogo empieza con HTTP
entonces la ruta se evalúa como una URL absoluta y el sistema intentará
cargar el catálogo directamente. Si no empieza con HTTP se asume que la
ruta es la raíz de la solución, se construirá una URL y se pasará al motor de
fuentes de datos (Mondrian). Se debe especificar este nodo o el MDX
Connection.

Outputs:

Se debe especificar un nombre de output. Es el nombre del result set que es


una implementación de IPentahoResultset.

MQL

Este componente invalida la consulta SQL Query para generar consultas


específicas de Metadatos.

42
Component Name: MQLRelationshipDataComponent

Component Definitions: None

Resources: None

Inputs:
ver SQL Query

Outputs:
ver SQL Query

Pivot View

This component returns an interactive pivot view screen to the browser based
upon input settings and a Mondrian MDX query.

Component Name: PivotViewComponent

Component Definitions:
Mode – (Required) modo de ejecución. El único valor soportado de
momento es "execute".
model – (Required) URI del modelo Mondrian aplicable.
options – (Optional) Lista de botones y elementos decorativos para mostrar
en la barra de herramientas. Los elementos son "cube-nav", "mdx-edit",
"sort-conf", "spacer", "level-style", "hide-spans", "properties", "non-empty",
"swap-axes", "drill-member", "drill-position", "drill-replace", "drill-thru", "chart",
"chart-conf", "print-conf", "print-pdf", y "excel". Si no se define entonces
TODOS los botones mencionados antes se utilizarán.
connection – (Necesario si el jndi no está definido) cadena de conexión
jdbc para la base de datos.
mdx – (Required) consulta mdx del cubo.
query – (Necesario si el query-name no está definido) Consulta MDX query.
query-name – (Necesario si no está definido query) nombre de la consulta
MDX.
jndi – (Necesario si no está definido connection) Nombre de la conexión jndi
para la base de datos.
title – (Required) Título de la vista de análisis (es el título que aparece en la
ventana)
url – (Required) Url del output... muy a menudo será un
<response>redirect</response> para el navegador.
viewer – (Required) "Pivot" es el único valor soportado (Utiliza el Pivot.jsp).
showgrid – (Optional) Muestra la the cross-tab grid (por defecto es true)

43
charttype – (Optional) Entero que determina el tipo de gráfico a mostrar.
1=de barras verticales, 2=de barras verticales 3D, 3=de barras horizontales,
4=de barras horizontales 3D, 5=de barras verticales apiladas, 6=de barras
verticales apiladas 3D, 7=de barras horizontales apiladas, 8=de barras
horizontales apiladas 3D, 9=de linea vertical, 10=de linea horizontal, 11=de
área vertical, 12=de área horizontal, 13=de área vertical apilada, 14=de área
horizontal apilada, 15=gráfico de pastel por columna, 16=gráfico de pastel
por fila. Por defecto vale 1.
chartlocation – (Optional) Cadena que determina la posición relativa a la
cross tab grid del gráfico. Las cadenas válidas son "top", "bottom", "left", y
"right".
chartwidth – (Optional) Entero que determina la anchura en pixels del
gráfico. Por defecto vale 500.
chartheight – (Optional) Entero que determina la altura en pixels del gráfico.
Por defecto vale 300.
chartdrillthroughenabled – (Optional) booleano (true/false) que determina
si la vista pivot permite el drill. Por defecto vale "true".
charttitle – (Optional) Título del gáfico. Por defecto sin título.
charttitlefontfamily – (Optional) Fuente para el título del gráfico. Los
valores posibles son "sansserif", "serif", y "monospaced". Por defecto es
"sansserif"
charttitlefontstyle – (Optional) Entero que representa el estilo del título. Los
valores válidos son 0=normal, 1=negrita, 2=itálica, 3 = negrita + itálica. Por
defecto es 1.
charttitlefontsize – (Optional) Entero que representa el tamaño de la fuente
del título del gráfico. Los valores permitidos son enteros entre 8 y 32. Por
defecto es 18.
charthorizaxislabel – (Optional) Cadena para la etiqueta del eje horizontal.
Por defecto no hay etiqueta.
chartvertaxislabel – (Optional) Cadena para la etiqueta del eje vertical. Por
defecto no hay etiqueta.
chartaxislabelfontfamily – (Optional) Fuente de los ejes. Los valores
permitidos son "sansserif", "serif", y "monospaced". Por defecto es
"sansserif"
chartaxislabelfontstyle – (Optional) Entero que representa el estilo de las
etiquetas de los ejes del gráfico. Los valores válidos son 0=normal,
1=negrita, 2=itálica, 3 = negrita + itálica. Por defecto vale 0.
chartaxislabelfontsize – (Optional) Tamaño de la letra de las etiquetas de
los ejes del gráfico. Los valores permitidos son enteros entre 8 y 32. Por
defecto es 12.
chartaxistickfontfamily – (Optional) Fuente para las etiquetas de los ejes
del gráfico. Los valores permitidos son "sansserif", "serif", y "monospaced".
Por defecto es "sansserif".

44
chartaxistickfontstyle – (Optional) Estilo de las etiquetas tick de los ejes.
Los valores válidos son 0=normal, 1=negrita, 2=itálica, 3 = negrita + itálica.
Por defecto vale 0.
chartaxistickfontsize – (Optional) Tamaño de la letra de las etiquetas tick
de los ejes del gráfico. Los valores permitidos son enteros entre 8 y 32. Por
defecto es 12.
chartaxisticklabelrotation – (Optional) Entero que representa los grados de
rotación de las etiquetas tick de los ejes del gráfico. Los valores válidos son
0, 30, 45, y 90. Por defecto es 30.
chartshowlegend – (Optional) Booleano (true/false) dice si se muestra la
leyenda o no. Por defecto es "true".
chartlegendlocation – (Optional) Entero que representa la ubicación de la
leyenda. Los valores válidos son 1=top, 2=left, 3=bottom, 4=right. Por
defecto vale 3.
chartlegendfontfamily – (Optional) Fuente de la leyenda. Los valores
válidos son "sansserif", "serif", y "monospaced". Por defecto es "sansserif".
chartlegendfontstyle – (Optional) Entero que representa el estilo de la
leyenda. Los valores posibles son 0=normal, 1=negrita, 2=itálica, 3 = negrita
+ itálica. Por defecto es 0.
chartlegendfontsize – (Optional) Tamaño de la fuente de la leyenda. Los
valores válidos son enteros entre 8 y 32. Por defecto es 10.
chartshowslicer – (Optional) Booleano (true/false) que indica si ha de
mostrarse el slicer. Por defecto es "true".
chartslicerlocation – (Optional) Entero que representa la posición relativa
al marco del gráfico del slicer. Los valores válidos son 1=top, 2=left,
3=bottom, 4=right. Por defecto es 1. No tiene efecto si el chartshowslicer es
false.
chartsliceralignment – (Optional) Entero que representa la alineación del
slicer. Los valores válidos son 1=Izquierda, 2=Derecha, 3=Centro. Por
defecto es 3. No tiene efecto si chartshowslicer es false.
chartslicerfontfamily – (Optional) Fuente utilizada por el slicer. Los valores
válidos son "sansserif", "serif", y "monospaced". Por defecto es "sansserif".
chartslicerfontstyle – (Optional) Entero que representa el estilo del slicer.
Los valores posibles son 0=normal, 1=negrita, 2=itálica, 3 = negrita + itálica.
Por defecto es 0.
chartslicerfontsize – (Optional) Tamaño de la fuente del slicer. Los valores
válidos son enteros entre 8 y 32. Por defecto es 12.
chartbackgroundr – (Optional) Entero que representa el componente rojo
del fondo del gráfico. Los valores válidos están entre 0 y 255. Por defecto es
255.
chartbackgroundg – (Optional) Entero que representa el componente verde
del fondo del gráfico. Los valores válidos están entre 0 y 255.Por defecto es
255.

45
chartbackgroundb – (Optional) Entero que representa el componente azul
del fondo del gráfico. Los valores válidos están entre 0 y 255. Por defecto es
255.
role – (Optional) Rol utilizado para la consulta mondrian.
cube – (Optional) Nombre de un cubo. Solo es necesario si el esquema
contiene más de un cubo.

Outputs:

Output definido por el usuario. El output del componente Pivot View es pasado
a través del visor Pivot.jsp.

Componentes preparados – Habilitar subreporting y


compartición de conexión

La mayoría de los componentes data source soportan una nueva característica


llamada "prepared_component". Ésta funcionalidad permite a los data source
ser ejecutados por otros componentes y compartir sus conexiones.

Los componentes Data Source que lo implementan son:

• SQLLookupRule
• MDXLookupRule
• HQLLookupRule
• XQueryLookupRule
Notar también que el componente SQLExecute puede utilizar un
prepared_component como un input de una acción para compartición de
conexiones.

Habilitar JFreeReport Subreporting

Para definir un output de un componente con el nombre


"prepared_component", un componente datasource entra en estado preparado
vs. el estado de ejecución estandar. El componente inicializa su conexión y
crea la consulta, pero espera a que otro component ejecute la sentencia
preparada. Un ejemplo de esto es un subinforme en JFreeReport. JFreeReport
ejecutará la sentencia preparada para cada elemento en su result set primario.
Notar que actualmente solo el componente JFreeReport utiliza el
prepared_component para una ejecución poserior. A continuación se muestra
un ejemplo de secuencia de acción que utiliza la funcinalidad
prepared_component en un subinforme.

<action-definition>
<component-name>SQLLookupRule</component-name>
<action-type>SQL Query For Report Data</action-type>
<action-inputs>
<max_rows type="string"/>
</action-inputs>

46
<action-outputs>
<prepared_component type="prepared-component"
mapping="main_query"/>
</action-outputs>
<component-definition>
<jndi>SampleData</jndi>
<query><![CDATA[select DISTINCT POSITIONTITLE from
QUADRANT_ACTUALS order by POSITIONTITLE]]></query>
<max_rows>3</max_rows>
</component-definition>
</action-definition>

<action-definition>
<component-name>SQLLookupRule</component-name>
<action-type>SQL Query For Report Data</action-type>
<action-inputs>
<prepared_component type="prepared-component"
mapping="main_query"/>
</action-inputs>
<action-outputs>
<prepared_component type="prepared-component"
mapping="subreport_query"/>
</action-outputs>
<component-definition>
<jndi>SampleData</jndi>
<query><![CDATA[select DISTINCT DEPARTMENT from
QUADRANT_ACTUALS WHERE POSITIONTITLE = {PREPARELATER:POSITIONTITLE}
order by DEPARTMENT]]></query>
<dept>Finance</dept>
</component-definition>
</action-definition>

<action-definition>
<component-name>JFreeReportComponent</component-name>
<action-type>Create Report Using Query Results</action-type>
<action-inputs>
<default mapping="main_query"/>
<subreport_query mapping="subreport_query"/>
<output-type type="string"/>
</action-inputs>
<action-resources>
<report-definition type="resource"/>
</action-resources>
<component-definition/>
</action-definition>

Abrir el archivo pentaho-solutions/test/reporting/jfreereport-subreport-


ipreparedcomponent-test.xaction para ver el ejemplo completo.

La nueva sintaxis incluye el elemento plantilla "PREPARELATER" en la


subconsulta anterior. El campo "POSITIONTITLE" se resuelve cuando se
ejecuta la consulta en el JFreeReportComponent. En este ejemplo, la
subconsulta se ejecuta para cada registro de la consulta principal.Esta relación
se define en el fichero xml JFreeReport. Notar también que el segunto
SQLLookupRule coge el primero first SQLLookupRule como un input de acción.
Éste es otro beneficio para usar el Prepared Component, ahora los
componentes pueden compartir sus conexiones.

47
En el JFreeReportComponent, los únicos cambios que necesita para soportar
subinformes es incluir el lookup rules adicional como un input de acción. El
nombre del input de acción debe coincidir con el indicado en el fichero xml
JFreeReport

Compartición de conexión

Un ventaja adicional del prepared_component feature es la capacidad de


compartir conexiones a través de componentes. Por ejemplo, si dos
SQLLookupRules necesitan compartir una conexión, lo pueden hacer utilizando
la funcionalidad del prepared_component functionality. En este ejemplo, el
primer SQLLookupRule crea una conexión disponible usando el action output
prepared_component, y luego los dos siguientes componentes SQL utilizan el
prepared_component como input para compartir una conexión:

<!-- first create a connection -->

<action-definition>
<component-name>SQLLookupRule</component-name>
<action-type>Get Connection</action-type>
<action-inputs/>
<action-outputs>
<prepared_component mapping="connObj"/>
</action-outputs>
<component-definition>
<jndi>SampleDataAdmin</jndi>
</component-definition>
</action-definition>

<!-- second, create temporary table w/ connection and add data


-->

<action-definition>
<action-inputs>
<prepared_component mapping="connObj"/>
</action-inputs>
<action-outputs/>
<component-name>SQLExecute</component-name>
<action-type>Create a temp table</action-type>
<component-definition>
<continue_on_exception>true</continue_on_exception>
<query><![CDATA[
drop table tmptbl;
create temp table tmptbl(val int) ON COMMIT PRESERVE
ROWS;
insert into tmptbl values (1)
]]></query>
</component-definition>
</action-definition>

<!-- third, extract inserted data from temporary table -->

<action-definition>
<component-name>SQLLookupRule</component-name>
<action-type>Check for Data</action-type>
<action-inputs>
<prepared_component mapping="connObj"/>
</action-inputs>
<action-outputs>

48
<query-result mapping="a_result"/>
</action-outputs>
<component-definition>
<query>SELECT * FROM tmptbl</query>
</component-definition>
</action-definition>

Printing

Imprime los informes y contenidos a una impresora del sistema del equipo que
contiene el motor solución. El contenido a imprimir se puede especifica de una
de las dos maneras siguientes:

1. Especificar el fichero como un recurso printFile o como ajuste de un


componente.

2. Disponer de una acción previa en la secuencia de salida de contenido al


parámetro report-output.

Actualmente, los org.pentaho.plugin.jfreereport.JFreeComponent,


org.pentaho.plugin.eclipsebirt.BIRTComponent, y
org.pentaho.plugin.jasperreports.JasperComponent tienen la capacidad de
generar contenido de informe como report-output. Si no se especifican datos
para imprimir, la secuencia de acción fallará.

Component Name: PrintComponent

Inputs:
OPTIONAL
printFile – cadena con el fichero, si no se especifica se utilizará el
parámetro report-output.
printerName – Nombre de la impresora, si no se especifica se usará la
impresora por defecto.
copies – Número de copias

Outputs:
last-printer-selected – última impresora seleccionada. Si no se especifica
en el action-outputs y action-inputs no contendrá nada.

Resultset Crosstab

Éste método coge una columna de datos y la convierte en varias basadas en


los valores de la columna. La columna measure (medida) se distribuye
entonces entre las nuevas columnas. Las celdas en que no hay datos se llenan
con nulls. Esta versión del método tiene dos parámetros adicionales: la
columna This version of the method also takes two additional parameters – la
columna para clasificar las nuevas columnas, y un formateador para esa
columna.

49
Ejemplo:
Resultset inicial:
Month Vender Rank Counts
Jan A-A-A 2 92
Jan Acme 3 200
Jan Ajax 4 163
Feb Acme 3 27
Feb Ajax 4 102
Mar Donn 1 427
Mar A-A-A 2 301
Mar Acme 3 82

Con los siguientes parámetrosWith the following parmeters


<pivot_column>1</pivot_column>
<measures_column>3</measures_column>
<sort_by_column>2</sort_by_column>
<sort_format_type>Decimal</sort_format_type>
<sort_format_string>###,###.##</sort_format_string>

se convertiría en:
Month Donn A-A-A Acme Ajax
Jan null 92 200 163
Feb null null 27 102
Mar 427 301 82 null

Component Name: SubActionComponent

Component Definitions: None

Resources: None

Inputs:
result_set – (Required) Los datos a transformar(ha de ser un
IPentahoResultSet).
pivot_column – (Required) Valor entero de la columna en al que realizar el
pivot.
measures_column – (Required) Valor entero de la columna de medidas
para distribuir en las columnas creadas.
format_type – (Optional) Indica que el "format_string", si es de tipo decimal
o date. Los valores válidos son “decimal” y “date”. Por defecto no tiene
formato.
format_string – (Necesario si está definido format_type) Cadena que
contiene una cadena válida java.text.DecimalFormat o
java.text.SimpleDateFormat para formatear la salida de medida.

50
ordered_maps – (Optional) Booleano (true/false) que si vale true, ordenará
las nuevas columnas alfabéticamente por el nombre. Si vale false, las
columnas se crearán en el orden en que aparecen en las filas.
sort_by_col – (Optional) Entero que indica la columna que se utilizará para
ordenar las columnas creadas. Por defecto sin orden.
sort_format_type – (Optional) Indica si el “format_string” es de tipo decimal
o date. Éste formateador se utiliza para trasformar la columna que se utiliza
para la ordenación a string. Los valores válidos son "decimal" y "date".
sort_format_string – (Necesario si se define sort_format_type) String que
contiene una cadena válida java.text.DecimalFormat o
java.text.SimpleDateFormat para transformar la columna que se utiliza para
la ordenación a string.
unique_row_identifier_column – (Optional) Entero que indica la columna
que contiene filas únicas.
non_ordered – (Optional) Booleano (true/false) que si es true se hará la
transformación como si no estuviera definido el
unique_row_identifier_column is not defined. Por defecto es false.

Outputs:

Nombre de output arbitratio que será mapeado al IPentahoResultset.

Scheduling

La plataforma BI Pentaho actualmente utiliza Quartz como planificador. La


aplicación es un singleton que es JDBC persistido. Puede recuperarse de
fallos. Los fallos planificados se manejan de acuerdo a una serie de reglas
predefinidas.

El acceso al planificador es a través de


org.pentaho.plugin.quartz.JobSchedulerComponent implementando una
secuencia de acción. Se pueden encontrar ejemplos en test/scheduler/.
Actualmente hay cuatro acciones diferentes disponibles: "startJob",
"suspendJob", "resumeJob", y "deleteJob".

Start Job

Crea un job y un trigger y entonces los registra para ejecutarlos con el


planificador. En el caso de un "Simple Trigger", empieza la ejecución del job
cuando la condición del trigger se cumple y se produce en el intervalo de
repetición definido hata que el número de cliclos se han producido. En el
caso de "Cron Trigger" el inicio del job se produce de acuerdo a las reglas
enunciadas en la expresión cron (ver más abajo). El job es un documento
de solución que se ejecutará. Ésto permite la planificación para cualquier
otra solución existente como impresión o email. Cuando hay un fallo como
fallo en la red eléctrica, caída del sistema, etc... después de reiniciar el

51
planificador se aplicarán las reglas en caso de fallo a cualquier trigger que
haya fallado. Los valores "jobName", "triggerType" ( y los inputs asociados),
"solution", "path", y "action" han de definirse en el documento de la solución.

Component Name: JobSchedulerComponent

Inputs:
REQUIRED
solution – Nombre de la solución a la que pertenece la xaction.
path – Ruta de la solución.
action – El nombre de la xaction a planificar.
jobname – Nombre arbitrario del job para ésta planificación.
triggertype – Los valores válidos son "simple" y "cron". Cada uno de estos
valores requiere información adicional. Ver Triggers
OPTIONAL
misfirePolicy – Ver Misfires

Suspend Job

Pone en pausa un job. La manera de poner en ejecución de nuevo el job es


con un resume job.

Component Name: JobSchedulerComponent

Inputs:
REQUIRED
jobName – Nombre del job a suspender.

Outputs:
Ninguno

Resume Job

Pone en ejecución un job pausado. Una vez reanudado el job, se aplicarán


las reglas de fallos que corresponda.

Component Name: JobSchedulerComponent

Inputs:
REQUIRED
jobName – Nombre del job a reanudar.

Outputs:
Ninguno

52
Delete Job

Borra un job específico. El job es borrado inmediatamente. De todos modos


si un job se está ejecutando en un hilo planificado continuará ejecutándose
aunque no se planificarán más instancias del job. El único input para esta
acción es un "jobName".

Component Name: JobSchedulerComponent

Inputs:
REQUIRED
jobName – Nombre del job a borrar.

Outputs:
Ninguno

Secure Filter (Prompting)

El componente secure filter tiene dos funciones relacionadas pero separadas.


Te permite personalizar el prompting por defecto creado por el runtime context
y puede verificar que solo se devuelven selecciones correctas.

En el ejemplo, el Secure Filter Component buscará un parámetro llamado


DEPARTMENT, si no existe, generará un cuadro de diálogo (prompting) en el
que pedirá el valor y lo añadirá en la columna "Display" del parámetro
DEPARTMENT_FILTER.

Cuando el usuario selecciona un valor, y DEPARTMENT es pasada a la


Secuencia de Acción y eventualmente al componenteSecure Filter, verificará
que el valor devuelto exista en la columna"Dept".

Si el valor de DEPARTMENT es válido, la ejecución de la Secuencia de Acción


continuará en el siguiente componente.

<action-definition>
<component-name>SecureFilterComponent</component-name>
<action-inputs>
<DEPARTMENT type="string"/>
<DEPARTMENT_FILTER type="result-set"/>
</action-inputs>
<action-outputs/>
<component-definition>
<selections>

<DEPARTMENT optional="false" style="select" prompt-if-one-


value="true">
<filter value-col-name="Dept" display-col-name="Display">
DEPARTMENT_FILTER
</filter>
<title>Select the Department</title>
</DEPARTMENT>

53
</selections>
<xsl>CustomReportParameters.xsl</xsl>
<target>Report_Window</target>
</component-definition>
</action-definition>

El atributo optional especifica si el parámetro es necesario o no. Si es


necesario, el usuario debe darle un valor antes de continuar.
El atributo style define el estilo del control que se le mostrará al usuario.

El atribut title define el texto que se mostrará.

Component Definitions:
• selections – Nombres de los elementos hijo que son utilizados como
selection names
• optional attribute – si es true, la selección es opcional
• style attribute – define el estilo, las selecciones válidas son
text-box, radio, select, list, list-multi, check-multi, check-multi-
scroll, check-multi-scroll-2-column, check-multi-scroll-3-column,
y check-multi-scroll-4-column
• prompt-if-one-value attribute – true si es encesario un único
valor
• title – contiene el título de esta selección
• filter attribute – si vale "none", no se necesita el elemento filter
• filter – define el parámetro input a usar en el filtro
• value-col-name attribute – especifica el valor del input
• display-col-name attribute – especifica el valor que se
muestra

Action Inputs:

Se deben especificar los inputs para cada selección y su data source, com está
definido en la sección de selecciones de la definición del componente.

Action Outputs:

No hay outputs para SecureFilterComponent.

SQL Execute

Ejecuta una consulta SQL contra un JDBC o un JNDI. El resultado de la


ejecución es un resutset que contiene el número de filas afectadas y el estado,
como se detalla más abajo. La consulta puede contener referencias a
parámetros escribiéndolos entre llaves {}. Por ejemplo: update myTable set
column = 'newvalue' where department = '{dept}' reemplazaría {dept} por el
valor del parámetro llamado "dept".

54
Component Name: SQLExecute

Component Definition:
REQUIRED
JNDI Name – Nombre de la conexión JNDI.
o la siguiente información JDBC
JDBC Driver – El driver JDBC a utilizar para la conexión.
JDBC Connection String – Cadena de conexión identificando la ubicación
del data source.
JDCB User Name – Nombre de usuario para la conexión.
JDBC Password – Contraseña para la conexión.
Query Definition – La sentencia update, create, alter o drop que quieras
ejecutar. Éste componente ejecutará más de una sentencia en una definición
de consulta (query definition).
OPTIONAL
force single statement (true\false) – si es true, y hay más de una sentecia
en la definición de la query, será enviada al servidor como una sola
sentencia. Ésto pasará si la query tiene un “;” en su texto. Ésta es una
condición legítima di hay una sentencia con un where que tiene un “;”.
Por ejemplo: UPDATE sometable SET somecolumn='val1;val2' WHERE
somecolumn='val3;val4'
multi-statement separator (single character value) – Por defecto es “;".
Permite cambiar el separador de sentencias cuando hay más de una.
continue on exception (true\false) – si es true, continúa ejecutando las
siguientes sentencias después de que se haya lanzado una excepción. Ésto
es útil cuando una base de datos lanza una excepción en una sentencia
DROP TABLE porque la tabla no existe.

Outputs:
Result Set Name – El nombre del parámetro donde se guardará el resultado
de la query. El resultado será un resultset que tendrá dos columnas: La
primera para el número de filas afectadas y la segunda para el estado de la
ejecución de la query, “succes” o “failed”. Si se ejecutan independientemente
más de una sentencia entonces habrá tantas filas en el resultset como
queries ejecutadas. Por ejemplo, si defines tres sentencias update en la
query, entonces habrá tres filas en el resultset, una para cada sentencia.

SQL Query

Ejecuta una consulta SQL contra un JDBC o un JNDI. Los resultados de la


query estarán disponibles como un output de la acción. Puede contener
referencias a parámetros encerrándolos entre llaves “{}”. Por ejemplo select *
from myTable where department = '{dept}' reemplazará {dept} por el valor del
parámetro "dept".

55
Component Name: SQLLookupRule

Inputs:
REQUIRED
JNDI Name – Nombre de la conexión JNDI.
o un objeto SQL Prepared Component
Prepared Component – Un SQLLookupRule previo que ha definido un
prepared component como el output. Compartirá su conexión con el actual
SQLLookupRule
o la siguiente información JDBC
JDBC Driver – El driver JDBC driver a utilizar para la conexión.
JDBC Connection String – Cadena de conexión para identificar la
ubicación el data source.
JDCB User Name – Nombre de usuario para la conexión.
JDBC Password – Contraseña Password to use when connecting to the
data source.
OPTIONAL
Keep Connection Open – Si es seleccionado el resultado de la query se
obtiene de la fuente de datos si es necesario, por lo contrario es traído de la
fuente de datos y guardado en la memoria caché, esto es recomendable con
grandes conjuntos de datos. Nunca usar esta opción si se guarda el
resultset en la sesión.
SQL Query – Es obligatorio si no hay definido un prepared component.This
is required if no prepared component object is defined para utilizar la
funcionalidad de la sentencia preparada SQL
Usar {PREPARE:<paramname>} en la query sql, donde <paramname> es un
parámetro intput al SQLLookupRule. Éste parámetro This parameter es
resuelto durante la ejecución del SQLLookupRule.
Usar {PREPARELATER:<paramname>} en la query cuando se define como
un prepared component. El <paramname> y el valor son proporcionados por
el componente que se está ejecutando.

Outputs:
Result Set Name – El nombre del parámetro en el que se guardan los
resultados de la query.
o
Prepared Component – El nombre del parámetro donde se guarda el objeto
prepared component, el cual puede usarso para conexiones compartidas y
que más tarde procesarán otros componentes.

56
Sub Action

Éste componente permite utilizar funciones como una subrutina. Una acción
puede crear una subacción (o una serie de subacciones) para crear contenido
que es devuelto.

Component Name: SubActionComponent

Component Definitions: Ninguna

Resources: Ninguna

Inputs:
Solution – (Required) La solución que contiene la xaction a ejecutar.
path – (Required) Lugar dentro de la solución donde está la xaction a
ejecutar.
action – (Required) La xaction a ejecutar.
session-proxy – (Optional) Contiene un nombre de sesión. Ésto puede
ocasionar que la subacción se procese en una sesión diferente (de forma
asíncrona).
query – query XMLA a ejecutar.

Outputs:

Cada output necesita un nombre específico al que tenga la acción tenga


acceso al resultado de la subacción.

XMLA

This component allows communication with an XMLA server using the XML for
Analysis specification (XMLA Specification ) for more information on the
protocol and how it deals with OLAP data. The XMLALookupRule takes
connetion information, a catalog schema, and a query. It then executes the
query against the XMLA server and returns a result-set in the form of an
instance of IPentahoResultSet.

Component Name: XMLALookupRule

Component Definitions: Ninguna

Resources:

Inputs: (All are required)


Uri – cadena de conexión JDBC a un servidor XMLA.
user-id – Nombre de usuario para la autenticación en el servidor.
password – Contraseña del servidor.

57
catalog – URI que apunta a un catálogo OLAP.
query – Query XMLA a ejecutar.

Outputs:
query-result del tipo "result-set" mapeado a un IPentahoResultSet

XQuery

Éste documento utiliza XQuery para crear un IPentahoResultset a partir de un


documento origen.

Component Name: XQueryLookupRule

Component Definitions: Ninguna

Resources: Ninguno

Inputs:
document – documento sml origen
prepared_component – Nombre de un prepared component que contiene
una conexión hibernate (obligatorio si no se utiliza el input query)
query – Query de la base de datos mapeada utilizando la sintaxis XQuery
(obligatorio si no se usa el input prepared_component)

Outputs:
query-result del tipo "result-set" mapeado a un IPentahoResultSet

58
3. Bibliografía

● Punto 1: He extraído la información del documento


Creating_Pentaho_Solutions-1.5.4.pdf disponible desde
http://sourceforge.net/project/downloading.php?group_id=140317&use_
mirror=kent&filename=Creating_Pentaho_Solutions-1.5.4.pdf&45307702

● Punto 2: extraido de la wiki oficial de Pentaho en el apartado de BI


Server Documentation
(http://wiki.pentaho.com/display/PentahoDoc/Creating+Pentaho+Solution
s).

59