q v Enterprise Modulo i i

copyright © 1996-2005 QlikTech International PJB/2005-04-01

Desarrollo de Script QV Enterprise

Noviembre 2005

QV Versión 7.0 Español

QlikView Enterprise Script

copyright © 1996-2005 QlikTech International Page 2

Copyright © 1994-2005 Qlik®Tech International AB, Suecia. Las leyes internacionales de la Propiedad Intelectual prohíben copiar, fotocopiar, reproducir, traducir o convertir, en parte o en su totalidad, por cualquier medio electrónico o formato electrónicamente legible, tanto la documentación como el software, sin la previa autorización por escrito de QlikTech International AB, a excepción del modo definido en la licencia de software. Qlik®View es una marca comercial registrada de QlikTech International AB. En los Estados Unidos de América y Canadá, Qlik®View es una marca comercial registrada de Qlik®Tech, Inc. Microsoft, MS-DOS, Windows, Windows NT, Windows 95, Windows 98, Windows ME, Windows 2000, Windows XP, SQL Server, FoxPro, Excel, Access, ActiveX, el logotipo de Internet Explorer y MS Query son marcas registradas de Microsoft Corporation. IBM, AS/400 y PowerPC son marcas registradas de International Business Machines Corporation. Borland, Paradox y dBASE son marcas registradas de Borland International. ORACLE y SQL*Net son marcas registradas de Oracle Corporation. Apple, TimeType, Macintosh, PowerMacintosh y MacOS son marcas registradas de Apple Computer, Inc. Documento original en inglés: Abril 2005



Indice 1. INTRODUCCIÓN ......................................................................................................................... 6

1.1. ACERCA DE ESTE CURSO ........................................................................................................... 6 1.2. ARCHIVOS DE DATOS EMPLEADOS EN EL CURSO........................................................................ 7 1.3. INSTALACIÓN ............................................................................................................................ 7 1.4. GUARDAR ARCHIVOS ................................................................................................................ 7 1.5. FORMATO DE TEXTO DEL MATERIAL DE CURSO......................................................................... 8

2. EL PLAN DE PROYECTO BI QLIK WHOLESALE TRADE (QWT)................................... 9 2.1. INTRODUCCIÓN AL PLAN DE PROYECTO..................................................................................... 9 2.2. PLAN DE PROYECTO: VISIÓN GENERAL ..................................................................................... 9

3. UNA BREVE INTRODUCCIÓN A LAS ESTRUCTURAS DE DATOS............................... 11 3.1. ACERCA DE LAS ESTRUCTURAS DE DATOS............................................................................... 11 3.2. BASES DE DATOS RELACIONALES ............................................................................................ 11 3.3. OTRAS ESTRUCTURAS DE DATOS............................................................................................. 11

4. ESTRUCTURAS DE DATOS QLIKVIEW .............................................................................. 12 4.1. COMPARACIÓN ENTRE ESTRUCTURAS DE DATOS Y ESTRUCTURAS DE DATOS QLIKVIEW ........ 12 4.2. ESTRUCTURAS DE DATOS EN QLIKVIEW ................................................................................. 13

5. CARGAR DATOS EN QLIKVIEW .......................................................................................... 14 5.1. EDICIÓN DE SCRIPT ................................................................................................................. 14

Barra de Herramientas del Editor de Script ............................................................................ 15 Comandos de menú del Editor de Script .................................................................................. 16 Panel de Herramientas del Editor de Script ............................................................................ 17

5.2. SINTAXIS................................................................................................................................. 20 5.3. CONNECT ................................................................................................................................ 20 5.4. SELECT.................................................................................................................................... 22 5.5. LOAD ...................................................................................................................................... 23 5.6. RENOMBRAR UN CAMPO.......................................................................................................... 24

6. ARCHIVOS FUENTE................................................................................................................. 26 6.1. LA BASE DE DATOS DE LOS PEDIDOS........................................................................................ 26 6.2. CREACIÓN DE UNA CONEXIÓN ODBC..................................................................................... 27

7. CREACIÓN DEL SCRIPT......................................................................................................... 30 7.1. GENERACIÓN DE SCRIPT.......................................................................................................... 30 7.2. GENERACIÓN DE SCRIPT – PASO A PASO .................................................................................. 30 7.3. SU PRIMER SCRIPT BÁSICO....................................................................................................... 36 7.4. EJECUCIÓN DEL SCRIPT ........................................................................................................... 38

8. ESTRUCTURA DE LOS DATOS CARGADOS...................................................................... 39 8.1. CAMPOS DE SISTEMA............................................................................................................... 39

8.1.1. La pestaña sistema ......................................................................................................... 39 8.1.2. Utilización de los campos de sistema............................................................................. 40



8.2. EL VISOR DE TABLAS............................................................................................................... 40 8.3. LA TABLA DE SISTEMA ............................................................................................................ 41 8.4. PROPIEDADES DE DOCUMENTO: LA PÁGINA TABLAS .............................................................. 43

9. AÑADIR DATOS DE TEXTO ................................................................................................... 44 9.1. EMPLEADOS ............................................................................................................................ 44 9.2. OFICINAS ................................................................................................................................ 44 9.3. PROVEEDORES ........................................................................................................................ 45 9.4. GENERACIÓN DE SCRIPT MEDIANTE EL ASISTENTE DE ARCHIVO.............................................. 45 9.5. REFERENCIAS CIRCULARES ..................................................................................................... 48 9.6. CAUSAS DE LAS REFERENCIAS CIRCULARES ............................................................................ 49 9.7. RENOMBRAR CAMPOS PARA EVITAR LAS REFERENCIAS CIRCULARES ...................................... 51 9.8. TABLAS PARCIALMENTE DESCONECTADAS ............................................................................. 52

10. EJERCICIOS............................................................................................................................. 54

11. CREACIÓN DE DATOS EN QLIKVIEW.............................................................................. 55 11.1. CARGA RESIDENTE................................................................................................................ 55 11.2. TABLAS DE CLAVE SINTÉTICA ............................................................................................... 56 11.3. CÓMO ELIMINAR UNA TABLA DE CLAVE SINTÉTICA............................................................... 57 11.4. AVANZADO – CÓMO VALERSE DE ORDERS (PEDIDOS) PARA DETERMINAR SALES PERSON (VENDEDOR).................................................................................................................................. 58

12. CÓMO CARGAR UN ARCHIVO DIF ................................................................................... 60 12.1. ARCHIVOS DE TEXTO EN FORMATO DE INTERCAMBIO DE DATOS.......................................... 60

13. CAMPOS CLAVE ..................................................................................................................... 63 13.1. UN EJEMPLO DE PROBLEMA QUE PUEDE SURGIR .................................................................... 63 13.2. ¿EN QUÉ ME AFECTA ESTO?................................................................................................... 63 13.3. CÓMO RESOLVER EL PROBLEMA DE LOS CAMPOS CLAVE....................................................... 64 13.4. ¿EL GRÁFICO MUESTRA REALMENTE LO QUE DESEO MOSTRAR?............................................ 64

14. EJERCICIOS............................................................................................................................. 66

15. CAMPOS DE DIMENSIÓN DE TIEMPO ADICIONALES................................................. 67 15.1. TABLAS INLINE ..................................................................................................................... 67 15.2. AUTOGENERAR TABLAS ........................................................................................................ 68 15.3. TABLAS MAPPING O TABLAS DE CORRESPONDENCIAS .......................................................... 69 15.4. MES EN CURSO ACTUALIZADO .............................................................................................. 70

16. TABLA CRUZADA Y CARGA GENÉRICA......................................................................... 72 16.1. TABLA CRUZADA.................................................................................................................. 72 16.2. GENERIC LOAD (CARGA GENÉRICA)..................................................................................... 76

17. INCLUDE................................................................................................................................... 78

18. ARCHIVOS DE DATOS QLIKVIEW: ARCHIVOS QVD................................................... 80 18.1. EL FORMATO DE ARCHIVO QVD ........................................................................................... 80 18.2. ¿PARA QUÉ SIRVEN LOS ARCHIVOS QVD? ............................................................................ 80 18.3. CREACIÓN DE ARCHIVOS QVD ............................................................................................. 81



18.4. CREACIÓN MANUAL DESDE EL SCRIPT ................................................................................... 82 18.5. CREACIÓN AUTOMÁTICA DE UN ARCHIVO QVD EN EL SCRIPT .............................................. 84 18.6. FUNCIONES DE SCRIPT DE ARCHIVOS QVD ........................................................................... 85

19. EJERCICIOS............................................................................................................................. 87

20. SCRIPT AVANZADO – 1ª PARTE ......................................................................................... 88 20.1. UNIR DATOS PROCEDENTES DE MÚLTIPLES TABLAS .............................................................. 88 20.2. AGREGAR DATOS .................................................................................................................. 90 20.3. CÓMO CALCULAR LOS DATOS ENTRE REGISTROS .................................................................. 91 20.4. UTILIZACIÓN DE LAS VARIABLES EN EL SCRIPT ..................................................................... 92

21. EJERCICIOS............................................................................................................................. 95

22. SCRIPT AVANZADO – 2ª PARTE ......................................................................................... 97 22.1. CONCATENACIÓN.................................................................................................................. 97

Concatenación automática....................................................................................................... 97 Concatenación forzada ............................................................................................................ 97 Impedir la concatenación......................................................................................................... 98 Ejemplo .................................................................................................................................... 98

23. SEGURIDAD ........................................................................................................................... 101 23.1. CONTROL DE ACCESSO ........................................................................................................ 101 23.2. NIVELES DE ACCESO ........................................................................................................... 101 23.3. LA BASE DE DATOS DE CONTROL DE ACCESO ...................................................................... 101 23.4. RESTRICCIONES DE ACCESO HEREDADAS ............................................................................ 103 23.5. SECCIÓN DE ACCESO EN EL SCRIPT ...................................................................................... 103

Script Oculto .......................................................................................................................... 103 Adición de la Sección de Acceso ............................................................................................ 104

23.6. CONTROL DE ACCESO PARA CIERTOS COMANDOS................................................................ 106 23.7. MÁS CONTROL DE ACCESO.................................................................................................. 106

Otras consideraciones de líneas de comando desatendidas................................................... 108 23.8. RESTRICCIONES DE ACCESO EN VALORES DE CAMPO SELECCIONADOS................................ 108

Sentencias de control de script............................................................................................... 109 Limitación del valor de campo en la sección de acceso......................................................... 111

24. EJERCICIOS........................................................................................................................... 114

25. DEPURACIÓN ........................................................................................................................ 115 25.1. EL ARCHIVO DE REGISTRO DE EJECUCIÓN DE SCRIPT ........................................................... 117 25.2. INFORMES DE ERRORES EN QLIKVIEW ................................................................................ 118 25.3. MATERIALES DE REFERENCIA QLIKVIEW............................................................................ 119

26. APÉNDICE 1: TIPOS DE DATOS EN QLIKVIEW ........................................................... 121 26.1. ALMACENAMIENTO DE DATOS EN QLIKVIEW...................................................................... 121 26.2. DATOS QUE CONTIENEN INFORMACIÓN SOBRE TIPOS DE DATOS .......................................... 121 26.3. DATOS SIN INFORMACIÓN SOBRE EL TIPO DE DATOS ........................................................... 122 26.4. FECHAS Y HORAS ................................................................................................................ 124

27. APÉNDICE 2: EL SCRIPT FINAL....................................................................................... 126



1. Introducción

1.1. Acerca de este curso El presente curso se ha diseñado con el propósito de introducir a los desarrolladores de aplicaciones QlikView en las técnicas fundamentales de creación y mantenimiento de scripts de carga QlikView, utilizando QlikView Enterprise. En este curso se aprende a integrar datos procedentes de muy diversas fuentes en un documento QlikView, a fin de poder presentar la información de una manera completa y fácil de comprender por cualquier persona de la organización. Este curso da respuesta a las siguientes preguntas:

• ¿Cómo interpretar un plan de proyecto reflejado en un documento

QlikView? • ¿Cómo acceder a las fuentes de datos e integrarlos con otros datos

empleando QlikView? • ¿Cuáles son las técnicas de desarrollo de estructuras de datos en

QlikView? • ¿Qué herramientas hay disponibles para ver la estructura de datos en

un documento QlikView? • ¿Por qué y de qué manera creo datos a través del script de carga de

QlikView? • ¿Qué tipo de estándares debería emplear para hacer mi aplicación

QlikView eficaz, fácil de comprender y mantener? • ¿Cómo hago para que mi aplicación QlikView sea segura? • ¿Qué hacer cuando me surjan dudas? • ¿Qué hacer cuando surge un problema? El material del curso se ha diseñado siguiendo un enfoque modular. Su instructor puede preferir dar el material de una forma más personalizada para acercarse así a las necesidades particulares de cada alumno. En otras palabras, su formación específica puede hacer ver la necesidad de incluir otros temas, o eliminar parte de los que aquí se incluyen. Al igual que sucede con cualquier otro producto, para convertirse en un desarrollador avanzado, necesitará trabajar con casos reales. Este curso trata de emular un escenario corporativo real trabajando con un enfoque de diseño de proyectos factibles, que posibilite al alumno el acceso a una experiencia de tipo práctico, en la creación de un documento QlikView a partir de la descripción de los requisitos de un proyecto que se propone a modo de muestra. Puede que también le sea de utilidad volver sobre este material en un futuro. El material del curso está diseñado de tal forma que se pueda utilizar con o sin la presencia de un instructor.



1.2. Archivos de datos empleados en el curso El material del curso incluye los archivos de datos necesarios para crear los documentos que utilizará durante el curso. Aquí tiene una breve descripción de los archivo de datos que se incluyen y cómo se instalan.

QWT - Base de datos en Access EmpOff - Archivo Excel Employees_New - Archivo Excel Suppliers - Archivo DIF Email - Archivo de texto Budget - Archivo Excel

SalesSecurity - Archivo de texto SalesInitials - Archivo de texto Access02 - Archivo de texto

1.3. Instalación Hallará estos archivos en el CD del curso, o por otros medios que su instructor le facilite. Cuando ejecute el programa de instalación, los archivos se instalarán en el directorio: C:\QlikView\ QlikView Training\ QVCourse_EnterpriseScript a menos que especifique un directorio distinto. Tras la instalación, encontrará un documento con el nombre QVE_Script_Course_Solution.qvw en la carpeta QVCourse_EnterpriseScript. Este documento contiene las soluciones a los ejercicios que se le irán planteando durante el curso.

1.4. Guardar archivos Cuando cree un documento de su propiedad durante el curso, podrá guardarlo en la carpeta QVCourse_EnterpriseScript. Cualquier archivo nuevo de datos que cree durante el curso puede guardarse en la carpeta QVCourse_EnterpriseScript \Files\Datasources donde también encontrará otras fuentes de datos en las que se basa el documento final.



1.5. Formato de texto del material de curso Los extractos de script se representan con el siguiente estilo y tamaño de letra: SQL SELECT CustomerID,

Las palabras clave en el script se escriben del siguiente modo: Load

Los comandos, menús y botones se representan así: Editor de Script

Los nombres de hojas, cuadros de lista, campos y expresiones, etc. se representan con el siguiente estilo y tamaño de letra: Salesperson

Los nombres de archivo aparecen del siguiente modo:

QVCourse_EntScr.qvw



2. El plan de proyecto BI Qlik Wholesale Trade (QWT)

2.1. Introducción al plan de proyecto El plan de proyecto de Inteligencia de Negocio (o Business Intelligence, BI) QWT ha sido incluido en el presente curso a modo de ejemplo de un plan de proyecto que podría recibir en su entorno de trabajo. No se trata de un plan completamente configurado, con sus cuadros de planificación del tiempo y asignación de responsabilidades, etc. Está más bien diseñado para proporcionarle un objetivo general que cumplir durante el curso. Utilizaremos este plan de proyecto como una guía para desarrollar el script de carga necesario para la creación del documento QlikView. Haremos referencia constante al documento del plan de proyecto durante el curso, así que puede que desee mantenerlo abierto en su PC para un acceso más rápido al mismo. Encontrará el plan de proyecto, entre los materiales del curso, con el siguiente nombre: QWT BI Project Plan.doc.

2.2. Plan de Proyecto: Visión general Si abre el documento con el plan de proyecto BI QWT, verá que contiene las siguientes secciones:

Mediciones clave: aquí hallará algunas de las expresiones que se utilizarán en el documento QlikView. Algunos de estos cálculos se emplearán en el script de carga, mientras que otros se utilizarán en los objetos de hoja (gráficos, cuadros de texto, etc.) incluidos en el diseño de la interfaz de usuario

Indicadores Clave de Rendimiento (ICRs): esta sección contiene los indicadores de rendimiento de alto nivel que pueden presentarse desde una perspectiva de cuadro de mando en el documento QlikView.

Dimensiones clave: esta sección incluye una lista con las dimensiones clave que se emplearán a lo largo de la aplicación.

Tendencias: proporciona un listado de los campos de dimensión de tiempo más relevantes, que se irán solicitando para análisis de históricos.

Filtros clave de selección: incluye una lista de los campos requeridos en el documento QlikView para selección y filtrado de los datos.

Seguridad: contiene los requisitos de seguridad de acceso del documento QlikView.



Descripciones de los datos de origen: suministra la ubicación y las descripciones a nivel de campo para cada una de las fuentes de datos.

Cada una de estas secciones puede incluir una o más Reglas de Negocio para ayudar al desarrollador a comprender y crear la funcionalidad más adecuada y las características más útiles para el usuario de este documento QlikView.



3. Una breve introducción a las estructuras de datos

3.1. Acerca de las estructuras de datos Para facilitarle las cosas, si no ha trabajado anteriormente gran cosa con bases de datos, le ofrecemos una breve introducción a los conceptos básicos en cuanto a estructuras y bases de datos. Esta introducción le ayudará a crear documentos QlikView basados en sus propios datos. Si ya está familiarizado con este tipo de términos puede saltarse este capítulo.

3.2. Bases de datos relacionales Los datos a menudo se guardan en bases de datos relacionales. Bases de datos relacionales son, por ejemplo, Microsoft SQL Server, Microsoft Access, Oracle, DB2, Sybase, Informix, y Teradata. Una base de datos relacional se fundamenta en una serie de reglas. Una de tales reglas consiste en representar la información de la base de datos mediante valores contenidos en tablas, los cuales a su vez constituyen la base de datos. Otra regla supone que la base de datos debe ser capaz de manejar al menos un lenguaje estructurado. Un ejemplo de lenguaje estructurado lo encontramos en el Structured Query Language (SQL), que se emplea para definir y manipular los datos.

3.3. Otras estructuras de datos Otro formato muy común de fuentes de datos para QlikView es el constituido por los archivos de texto delimitados por caracteres. Los archivos de texto han de tener una estructura específica para que QlikView sea capaz de interpretarlos correctamente, sin una manipulación adicional del script de carga. La primera línea de este tipo de archivos de texto suele ser, aunque no siempre, un nombre de archivo o etiqueta. Las líneas subsuguientes contienen datos que pertenecen a los diversos campos. Los campos en el archivo están delimitados, o separados, por caracteres, normalmente comas, tabuladores, o un punto y coma. Un archivo de texto estándar, por lo tanto, equivale a una tabla completa, con filas y columnas.



4. Estructuras de datos QlikView

4.1. Comparación entre estructuras de datos y estructuras de datos QlikView

Figura 1. Estructura de tabla

En este ejemplo observamos una estructura de datos tomada de la base de datos de Access con la que estaremos trabajando durante el curso. La figura muestra seis tablas que tienen definidas unas relaciones – o lo que es lo mismo, están asociadas – mediante campos (clave) comunes. Descubriremos a lo largo del curso que, a diferencia de las bases de datos convencionales, QlikView no permite la definición explícita de relaciones entre tabla. QlikView define de forma automática relaciones de tabla – o asociaciones – mediante campos denominados de manera similar. En este ejemplo, los campos clave se han denominado todos de idéntica manera en sus respectivas tablas. Por supuesto, esto no es así siempre en una base de datos, así que explicaremos durante el curso cómo crear las asociaciones apropiadas entre tablas en QlikView. Aprenderemos también cómo evitar asociaciones indebidas entre tablas en QlikView basándonos en campos con nombres similares. Se verá también así mismo cómo asociar otros datos, que no tienen por qué estar necesariamente en un formato de base de datos (por ejemplo archivos de texto).



El campo CustomerID enlaza las tablas Customers y Orders. Si sigue las flechas podrá ver qué campos enlazan la estructura total. Si dos registros de tablas diferentes tienen el mismo valor en alguno de los campos comunes, quedarán asociadas. La asociación en QlikView es esencialmente la misma que en outer join de SQL.

4.2. Estructuras de datos en QlikView Cada columna de una tabla de datos, que es cargada en QlikView, se convierte en un campo de la base de datos asociativa de QlikView (también conocida como base de datos AQL). Los campos que aparecen en más de una tabla y que tienen idénticas etiquetas quedarán asociados. Cada campo puede presentarse en forma de cuadro de lista en el documento QlikView. Ciertos campos no se muestran; su única función es enlazar diferentes tablas. Cuando hace una selección en un cuadro de lista, QlikView busca las conexiones lógicas por toda la base de datos asociativa. Como resultado de dicha búsqueda se identifican los valores asociados a sus selecciones.



5. Cargar datos en QlikView Para poder cargar datos en QlikView, es necesario crear instrucciones para el manejo y recuperación de la información. Estas instrucciones es lo que compone y se conoce como el script de carga. El script puede detallar instrucciones sobre la forma en que QlikView debe interpretar los diferentes conjuntos de datos. QlikView puede cargar e interpretar los siguientes tipos de datos de entrada: • Cualquier tipo de archivo de texto separado por caracteres, por

ejemplo archivos separados por comas.

• El resultado de una consulta a una base de datos, realizada por SQL mediante conexión OLE DB/ODBC.

• Archivos QlikView creados con anterioridad (archivos binarios).

• Archivos de datos QlikView (archivos qvd).

• Archivos Excel en código BIFF estándar.

• Archivos de formato fijo.

• Archivos dif (formato de exportación común desde AS/400).

• Tablas HTML.

• Tablas XML.

5.1. Edición de Script Ahora examinaremos el diálogo Editor de Script, que puede utilizarse para generar, introducir y editar sentencias de script de carga QlikView. 1. Comience por crear un nuevo documento seleccionando el comando

Nuevo del menú Archivo o empleando la barra de herramientas. 2. Elija Editor de Script en el menú o en la barra de herramientas.

El diálogo que tiene más abajo le aparecerá en pantalla. Como podrá observar, hay numerosos comandos en forma de comandos de menú, botones de la barra de herramientas y botones de diálogo. Aunque la ventana de edición ocupa la mayor parte del cuadro de diálogo.

CONSEJO: Para una descripción completa de todos los diálogos y opciones de configuración actualmente disponibles en el Editor de Script, por favor acuda al documento ReferenceManual.pdf. Este documento de referencia se instalará sin problema durante la fase de instalación habitual de QlikView.



Figura 2. Cuadro de diálogo Editor de Script

Barra de Herramientas del Editor de Script La barra de herramientas contiene los siguientes controles:

Ejecutar Script

Ejecuta el script, cierra el diálogo Editor de Script y abre la página Propiedades de Hoja: Campos.

Depurar Inicia la ejecución de script en el Depurador. El depurador busca errores en el script. Cada sentencia de script puede ser monitorizada y los valores de las variables examinados a la vez que se ejecuta el script.

Guardar todo el Documento Guarda el documento activo en un archivo. Los datos, el script y el formato de diseño son guardados.

Imprimir Pestaña

Le permite imprimir los contenidos de la pestaña actualmente activa.

Cortar Corta el texto de script seleccionado y lo almacena en el Portapapeles.



Copiar

Copia el texto de script seleccionado.

Pegar Pega el texto de script almacenado en el Portapapeles.

Buscar

Busca en el script la cadena de texto especificada en la pestaña actual únicamente.

Añadir nueva pestaña Añade una nueva pestaña en el script. El script es ejecutado

pestaña a pestaña, de izquierda a derecha.

Visor de Tablas Muestra el visor gráfico de tablas de los datos actuales. También hay disponibles muchos comandos de utilidad en los cinco

menús superiores:

Comandos de menú del Editor de Script El menú ARCHIVO contiene una opción para guardar el documento sin tener que cerrar el Editor de Script. Aquí hallará también la opción para exportar el script como un archivo de script específico (extensión de archivo .qvs) o como una copia impresa. El menú EDITAR tiene todos los comandos necesarios para editar los contenidos del panel de edición de texto. Además de los comandos hbaituales de selección, copiado, corte e inserción de texto, hallará las funciones Insertar Archivo que se emplea para insertar un archivo de script, así como Buscar/Reemplazar que le permite buscar cadenas de texto específicas. Muchas de estas opciones se pueden ejecutar mediante combinaciones de teclas (teclas de método abreviado), por ej. si pulsa Ctrl+A se seleccionará todo el texto. El menú PESTAÑA contiene los comandos necesarios para hacer posible la gestión de las pestañas en el script. El menú CONFIGURACIÓN incluye el comando Configurar, que abre el diálogo Preferencias de Usuario: Editor donde puede fijar el tipo de letra y el color de letra de los diversos tipos de texto del script.



Los comandos del menú AYUDA abren los archivos de la ayuda de QlikView. (Para más información sobre el cuadro de diálogo Editor de Script, puede acudir a la Ayuda en este mismo momento.)

El gráfico Statements (Sentencias) muestra un cuadro para cada sentencia de la pestaña de script activa. El cuadro señala las características más importantes y proporciona una manera más sencilla de navegación por el script.

Panel de Herramientas del Editor de Script El Panel de Herramientas tiene tres pestañas-página con funciones para generación de script: Datos, Funciones y Configuraciones.

La página Datos

La página Datos contiene los comandos básicos para la carga de datos en QlikView. Los comandos del grupo Base de Datos se utilizan para crear una conexión y seleccionar campos de una fuente de datos. Si está utilizando una DBMS comercial, puede emplear ODBC o OLE DB como interfaz entre QlikView y la base de datos. OLE DB: Marque esta alternativa para acceder a las bases de datos mediante OLE DB. ODBC Marque esta alternativa si desea acceder a las bases de datos mediante ODBC. Use el botón Conectar… para abrir el diálogo Propiedades de Enlace de Datos, seleccionar una fuente de datos OLE DB o ODBC y generar la sentencia de enlace adecuada en el script de carga. Use el botón Seleccionar… para abrir el diálogo Crear Sentencia Select para especificar campos y tablas desde la fuente de datos escogida y generar la sentencia select adecuada en el script de carga.



Las opciones del grupo Datos desde Archivos se emplean para generar las sentencias de script de Carga necesarias para leer los datos desde los archivos. Marque la casilla de verificación Rutas Relativas para emplear rutas relativas en lugar de rutas abolutas para sentencias generadas en el script. Marque la casilla de verificación FTP para disponer de un diálogo que le permita seleccionar archivos desde un servidor ftp cuando elija Ficheros Planos, Archivos QlikView, o Incluir sentencias de script. Marque la casilla de verificación Asistente para hacer uso del asistente de archivos de tabla cuando haga clic en Abrir del cuadro de diálogo Abrir Archivos Locales. Pulse el botón Ficheros Planos… para abrir el diálogo Abrir Archivos Locales con un listado de los diversos formatos de archivo de texto, incluidos datos de Excel y datos QlikView (archivos .qvd). Si selecciona uno o varios archivos y pulsa Aceptar generará una o más sentencias de carga basándose en las opciones seleccionadas en el asistente. Haga clic en el botón Archivo QlikView… para abrir el cuadro de diálogo Abrir Archivo QlikView con una lista de los archivos QlikView (*.qvw). Si selecciona un archivo y pulsa Aceptar generará una sentencia binaria. Sólo se permite una sentencia binaria en un script de carga QlikView, y ésta debe ser la primera sentencia del script de carga. Haga clic en el botón Archivos Web… para abrir el cuadro de diálogo Asistente para Tablas: Fuente e introducir una URL como fuente de su tabla de datos. Los comandos del grupo Datos Inline se utilizan para generar las sentencias de script que generarán datos inline en el script. Haga clic en el botón Asistente Inline… para abrir el diálogo Asistente para Datos Inline que le ayudará en la creación de una sentencia Cargar Inline empleando un contrl del tipo de hoja de cálculo. Haga clic en el botón Acceso de Usuario… para abrir el diálogo Asistente de Tablas Restricción de Acceso que le ayudará en la creación de una sentencia especial Cargar Inline para emplearla en una sección de acceso (seguridad).

La página Funciones



La página Funciones se puede utilizar como ayuda para generar funciones QlikView que se emplearán en las sentencias de script. El cuadro desplegable Categoría de Función contiene un listado con las categorías de funciones. Seleccione una categoría de la lista para ver las correspondientes funciones en la lista Nombre de Función que encontrará un poco más abajo. El desplegable Nombre de Función lista las funciones de script estándar en QlikView. Esta lista se puede filtrar (o limitar) seleccionando previamente una categoría de la lista Categoría de Función. Haga clic en el botón Pegar una vez que haya seleccionado el nombre de función que necesite. La función se introducirá en el script, en la posición actual del cursor.

Página Configuración

La página Configuración se puede utilizar para seleccionar ciertos privilegios y opciones en el script de carga. Utilice el grupo Privilegios de Script para fijar el comando ejecutar y el calificador en modo de escritura en sentencias select. Si su script contiene estos elementos y no ha activadoo estos parámetros, las respectivas sentencias fallarán. Tras haber habilitado el uso de una o de ambas funciones, al usuario se le pedirá que apruebe el script la primera vez que éste se ejecuta en un ordenador. Dicha comprobación se puede ignorar mediante la conmutación de la línea de comando /nosecurity o mediante una opción de la página Seguridad en Preferencias de Usuario. Utilice el grupo Configuración para habilitar o deshabilitar el parámetro Encriptar Credenciales de Conexión de Usuario y controlar así si el nombre de usuario de la base de datos y la contraseña están cifrados en sentencias connect.

Consejo: No es necesario que las sentencias de script de carga se creen y almacenen en el documento QlikView, pero debe haber una referencia a las mismas si se almacenan en un archivo externo. Esto se realiza con la función Incluir disponible en el editor de script.



5.2. Sintaxis En esta sección, analizaremos las sentencias de script más comunes (connect, select, load) para identificar y cargar datos en QlikView. Cada una de ellas puede generarse mediante el uso de asistentes. Practicaremos esto en las próximas secciones, pero antes vamos a considerar diversos ejemplos de tales sentencias, cómo y dónde pueden utilizarse en un script de carga QlikView. También analizaremos algunas de las opciones disponibles para renombrar un campo, que es un tema de gran importancia cuando trabajamos con QlikView. Para detalles más completos y actualizados acerca de la sintaxis de sentencias de script, siempre le remitiremos a los Manuales de Referencia de QlikView, o al subsistema de Ayuda. Todas las sentencias de script del presente curso se describen con detalle en el Libro I del Manual de Referencia de QlikView 7.

5.3. Connect La sentencia connect se emplea para establecer una conexión con una base de datos mediante una interfaz ODBC o OLE DB. Una vez establecida dicha conexión, ésta se utiliza entre tanto no se defina una nueva sentencia connect. Se pueden definir múltiples sentencias connect en un mismo script de carga QlikView, pero sólo puede haber una conexión abierta a la vez. Si la sentencia connect es generada por el asistente suministrado, cualquier ID de usuario y contraseña se encriptarán con sintaxis xuserid is / xpassword is, siempre y cuando se haya seleccionado Encriptar Credenciales de Conexión de Usuario en la página General del diálogo Preferencias de Usuario. Si introduce la sentencia connect manualmente, deberá utilizar la sintaxis no encriptada userid is / password is para proporcionar ID de usuario y contraseña. La encriptación total sólo es posible actualmente para sentencias ODBC connect. Algunas partes de la cadena OLEDB connect no pueden encriptarse. El delimitador codepage is se puede emplear si experimenta problemas con los caracteres nacionales en determinados drivers ODBC/OLE DB. Si en modo de escritura está especificado en access_info (info de acceso) la conexión se abrirá en modo de lectura-escritura. En todos los demás casos la conexión se abrirá en modo de lectura únicamente. El uso de en modo de escritura debe hallarse habilitado en la sección Configuración, del diálogo Editor de Script. Si se sitúa ODBC antes de connect, se empleará la interfaz ODBC, si no, utilizará OLE DB.



Ejemplos de connect: ODBC connect to [SQLDATA;database=SQL1] (UserId is sa, Password is admin); ODBC CONNECT TO [MS Access Database;DBQ=data\sampledata.mdb]; ODBC connect to [COSQL01;DATABASE=SALESDATA;Trusted_Connection=Yes]; La fuente de datos especificada por esta sentencia es utilizada por todas las sentencias select subsiguientes, hasta que se encuentren con una nueva sentencia connect.



5.4. Select La sentencia SQL select se utiliza para identificar campos y tablas que han de cargarse desde la conexión actual a la base de datos. Se puede utilizar cualquier sentencia select que sea válida, pero tenga en cuenta que los drivers ODBC pueden imponer ciertas limitaciones de sintaxis a una conexión de base de datos en particular. Asimismo, las sentencias select no pueden hacer uso de la funcionalidad QlikView dentro de la sentencia. Los nombres de campo y de tabla deben ir delimitados por comillas o corchetes si contienen espacios o caracteres especiales. Cuando QlikView genere automáticamente el script, el signo de entrecomillado empleado es el preferido por el driver ODBC especificado en la definición de fuente de datos de la sentencia connect. Además, se pueden concatenar varias sentencias select en una, mediante el empleo de un operador union: sentenciaselect union sentenciaselect La sentencia select es interpretada por el driver ODBC, así que se pueden producir desviaciones de la seintaxis SQL general, dependiendo de las capacidades de los drivers ODBC. Por ejemplo:

as en ciertas ocasiones no se acepta, por ej. aliasname debe ir inmediatamente tras fieldname.

as es a veces de uso obligatorio, cuando se emplee un aliasname. distinct, as, where, group by, order by, o union no reciben

soporte en algunas ocasiones. El driver ODBC a veces no acepta ciertos tipos de comillas.

Ejemplos de select: SQL SELECT * FROM FACILITIES; SQL SELECT DISTINCT I.AddressID, Name, Address, PostalCode FROM [Invoice] I, [Address] A WHERE I.InvoiceType is not null and I.InvoiceDate >= '2001-01-01' and I.AddressID = A.AddressID;



5.5. Load La sentencia Load puede cargar datos según diversos métodos:

Cargar directamente desde un archivo de texto, Excel, qvd, xml, etc. Cargar desde otra sentencia select o load subsiguiente. Dicha

sentencia select o load debe ir inmediatamente a continuación de esta sentencia load.

Cargar desde una tabla previamente cargada (residente) Cargar directamente desde datos en el script de carga por medio de

una Carga Inline. Cargar desde datos generados.

Todas las funciones de script de QlikView están disponibles para su uso en una sentencia load. Los nombres de campo y de tabla deben ir delimitados por comillas o corchetes cuando contengan espacios o caracteres especiales. Ejemplos de load: Load * from 'c:\userfiles\data2.txt' (ansi, txt, delimiter is '\t', embedded labels); Load A, B, if(C>0,'+','-') as X, weekday(D) as Y; Select A,B,C,D from Table1; Load A, B, A*B+D as E Resident tab1; Load * Inline [CatID, Category 0,Regular 1,Occasional 2,Permanent]; Load RecNo() as A, rand() as B Autogenerate(10000);



5.6. Renombrar un campo Se pueden renombrar uno o más campos en el script de carga. También es posible nombrar campos que no tengan nombre en la fuente de datos. Existen diversas maneras de hacer esto en el script:

Renombrar empleando as en una sentencia load, lo cual implica que otorgará un nuevo nombre a un campo específico de esa sentencia específica. Si está utilizando el Asistente de Archivos de Tabla para crear una sentencia load, puede hacer clic en cualquier nombre de campo, en el área de Etiqueta, e introducir un nuevo nombre. La sentencia load generada incluirá la sintaxis as automáticamente.

Renombrar empleando alias, lo cual implica que dará nuevo nombre a todas las ocurrencias de aquellos campos que tengan sus nombres especificados en el script.

Renombrar uno o más campos existentes empleando la sentencia Rename Field. Esta sentencia puede utilizar, de modo opcional, una tabla de mapeo (o indicación de las correspondencias), que almacene datos de conversión del nombre antiguo (oldname) al nuevo (newname). Más adelante en este mismo curso se analizan las tablas de correspondencias (o mapeadas) con más detalle.

Ejemplo de as: Load

Capital as Capital city, Cntry as Country, Pop as Population

from Country.csv (ansi, txt… La sintaxis de una sentencia alias es: Alias <fieldname> as <new fieldname>, <fieldname> as <new fieldname>,… Ejemplo de alias: Alias ProdId as ProductID, Mon as Month, Cname as Customer; La sintaxis de una sentencia rename field es: rename field[s] (using mapname | oldname to newname {, oldname to newname} ) donde mapname es el nombre de una tabla con un mapa de correspondencias cargada anteriormente, que contenga uno o más pares de nombres de campo, tanto antiguos como nuevos.



oldname es el nombre antiguo de campo y newname es el nuevo nombre de campo. Nota: Tanto rename field como rename fields son formas admitidas, sin diferencia alguna en el efecto final que producen. Ejemplo rename field : Rename field XAZ0007 to Sales; FieldMap: Mapping select oldnames, newnames from datadict; Rename fields using FieldMap;



6. Archivos fuente En una primera parte del curso, cargaremos datos de tres fuentes diferentes, de acuerdo al plan de proyecto inicial. Los datos principales provendrán de una base de datos en Access, denominada QWT. Para estos datos, añadiremos tablas desde hojas de cálculo en Excel y desde un archivo de texto en formato DIF, que se ha extraido de un sistema AS/400.

Figura 3. Archivos fuente

Las fuentes de datos están lógicamente conectadas entre sí por campos comunes (también denominados campos clave). En el caso de las tablas que contienen información sobre empleados y pedidos de la empresa, tenemos los campos comunes de EmployeeID y EmpID. No obstante, hay que renombrar uno de los campos, para que QlikView pueda asociar dichos campos en nuestra aplicación. También tenemos SupplierID que es un campo común en la base de datos QWT y la tabla que contiene información sobre los proveedores (DIF). También podrá observar que existen campos con nombres parecidos en las tablas y que no queremos asociar. Estos campos habrán de ser remombrados también, a fin de evitar un asociación indeseada por parte de QlikView.

6.1. La base de datos de los pedidos Según nuestro plan de proyecto y como se puede observar en la figura 3, la base de datos QWT.mdb contiene las tablas Customers, Suppliers, Products, Categories, Orders, y Order Details. Vamos a cargar cada



una de estas tablas, pero primero necesitamos crear una conexión ODBC a la base de datos.

6.2. Creación de una conexión ODBC Para obtener acceso a la base de datos desde QlikView, es necesaria una conexión ODBC a la fuente de datos. Ésta se crea a través de Panel de Control … Herramientas Administrativas … Fuentes de Datos (ODBC) en Windows. A continuación se detallan unos pantallazos para guiarse por los diferentes pasos que habrá de seguir.

Consejo: También se puede definir una fuente de datos a través del diálogo Conectar en el Editor de Script de QlikView. 1. Ejecute el Pograma Administrador de ODBC mediante el Panel de

Control a fin de abrir el cuadro de diálogo ODBC – Administrador de Fuentes de Datos.

Figura 4. ODBC – Administración de las fuentes de datos 2. Determine si precisa definir una fuente de datos a nivel de Usuario

o a nivel de Sistema. Una fuente de datos de Usuario sólo estará disponible para el usuario actual de esta máquina. Una fuente de datos de Sistema estará disponible para cualquier usuario de esta máquina. Para nuestro curso en concreto, añadiremos una fuente de datos de Sistema. Para ello, haga clic en la pestaña Sistema DSN del cuadro de diálogo.



3. Añada una fuente de datos de sistema pulsando el botón Añadir... A continuación deberá elegir un driver adecuado para acceder a la fuente de datos. Puede contemplar diversos drivers en la figura que se muestra a continuación. Si está utilizando una base de datos comercial, pero no tiene sus drivers instalados, los encontrará seguramente en los discos de instalación de la base de datos. Si los discos de instalación no se hallan disponibles o los drivers están pasados de fecha, o no sirven por cualquier otra razón, contacte con su proveedor habitual o bien búsquelos por Internet.

Figura 5. Selección del driver 4. Seleccione Microsoft Access Driver (*.mdb) y pulse Finalizar. 5. Pulse Seleccionar. 6. Navegue hasta hallar la carpeta en la que se almacena la base de

datos QWT (FuentesdeDatos), y seleccione QWT.mdb. Pulse Aceptar.



Figura 6. Selección de la fuente de datos 7. Introduzca un título adecuado para su fuente de datos. Se

recomienda rellenar los campos Nombre de la Fuente de Datos y Descripción según se detalla en la figura a continuación. Tenga en cuenta que la ubicación de su base de datos puede encontrarse en otra unidad.

Figura 7. Dar nombre a la base de datos 8. Pulse Aceptar para aceptar los cambios y cerrar el diálogo.

Ahora ya debería poder acceder a la fuente de datos sin problema desde QlikView. Si por alguna razón la conexión a la fuente de datos se rompiera, utilice el botón Repair (Reparar) del cuadro de diálogo que contempla en la figura anterior a este párrafo para reestablecer la conexión.



7. Creación del script El script que crearemos en este curso carga datos desde una base de datos en Access. Se cargarán los campos de una serie de tablas mediante sentencias select. La sintaxis empleada es SQL estándar.

7.1. Generación de script La ventaja de utilizar el editor de script de QlikView reside en que muchas de las sentencias de script se generan de forma automática seleccionando los campos que se desea cargar en los asistentes de archivo. A veces es necesario realizar algunos cambios manualmente, por ej. a la hora de asignar nuevos nombres de campo. El editor de script también puede señalar algunos errores obvios, mediante una codificación de color, por ej. unos paréntesis no simétricos en una función.

7.2. Generación de script – paso a paso 1. Inicie QlikView Enterprise, si es que no se encuentra ya activo. 2. Seleccione Nuevo en el menú Archivo o en el correspondiente botón

de la barra de herramientas, para crear un documento nuevo.

3. Seleccione Propiedades de Documento en el menú Configuración y abra la pestaña General del cuadro de diálogo. Asegúrese de que Generar Archivo log esté activo. Esto generará un archivo de registro de ejecución de script cada vez que se ejecuta el script de carga. También puede habilitar la opción Preferencias de Usuario en la pestaña Diseño para que Utilizar Siempre Archivos de Log para Nuevos Documentos de modo que esta opción esté siempre disponible para usted de forma automática en el futuro.

4. Seleccione Guardar en el menú Archivo o pulse el botón

correspondiente de la barra de herramientas para guardar un documento. Navegue hasta encontrar el directorio del curso y guarde su archivo con un nombre apropiado en Archivos.

Consejo: Normalmente es recomendable guardar un documento nuevo antes de editar el script, para que se puedan generar las rutas relativas correctas. Esto normalmente es necesario para mejorar la portabilidad del documento QlikView.



5. Seleccione Editor de Script en el menú Archivo o en la barra de herramientas.

Ahora ha creado un nuevo archivo de script y, como podrá observar, ya contiene algunas líneas de script. Éstas son las variables de formato, las cuales son generadas automáticamente por QlikView. Las variables se basan en los parámetros de su sistema operativo en cuanto a fecha, hora, etc. 6. Marque la casilla de verificación Rutas Relativas, si es que no se

encuentra ya marcada. Esto generará rutas relativas para carga de Datos desde Archivos desde la ubicación guardada del documento QlikView en nuestras sentencias de script. Esto no será aplicable a nuestra sentencia connect (ver abajo), pero será útil más tarde, cuando leamos archivos de texto.

7. Seleccione ODBC y haga clic en Conectar para abrir el cuadro de diálogo Conectar a una Fuente de Datos.

Figura 8. Seleccionar la fuente de datos

8. Seleccione EnterpriseScript y pulse Aceptar. Debería ver ahora la

siguiente sentencia añadida a su script (con una ruta absoluta). ODBC CONNECT TO [EnterpriseScript;DBQ=Datasources\QWT.mdb]; La ruta generada en la sentencia connect es en realidad la ruta absoluta. Sin embargo, es recomendable que cambie la ruta a una relativa, como se muestra arriba. Le resultará mucho más fácil mover archivos de un PC a otro si emplea rutas relativas.



9. A continuación añadiremos datos de la tabla Customers (Clientes). Antes de generar la sentencia select, añadiremos un comentario para documentar el script a medida que lo vamos creando.

QlikView admite tres tipos de comentarios diferentes:

REM precediendo a una sentencia, comenta dicha sentencia hasta el final;

// este símbolo comenta todo el texto que le sigue en una única línea.

/* … */ comenta todo el texto que haya entre los delimitadores.

Consejo: Asegúrese de no emplear el comentario // para una función Include, dado que eso sólo comentará la línea inicial del archivo Include.

Figura 9. Adición de comentarios en el script de carga

Puede añadir libremente cualquier comentario que desee. La sugerencia que se indica en la figura anterior emplea texto del documento del plan de proyecto, es la descripción de los datos de la tabla Customers. (Fue necesario retocar un poco el formato para alinear las columnas de la tabla Record Layout).



Figura 9. Selección de todos los campos de la tabla Customers

10. Pulse SELECT en el diálogo Editor de Script, y seleccione la tabla

Customers en Tablas de la Base de Datos. 11. Seleccione todos los campos de la tabla marcándolos con el ratón.

También puede seleccionar * para marcar los archivos, pero en ese caso los nombres de los campos no se registrarán en el script, lo cual acarreará trabajo más adelante. En el marco que hay bajo los nombres de tabla y campos puede previsualizar el script que se generará automáticamente.

12. Pulse OK. Las tablas y campos seleccionados se incluirán ahora en

el script. La sentencia select habrá de tener más o menos el siguiente aspecto:

Customers: SQL SELECT Address, City, CompanyName, ContactName, Country, CustomerID, Fax, Phone, PostalCode, StateProvince FROM Customers;

13. Añada el nombre de tabla Customers: inmediatamente antes de

SQL SELECT a fin de otorgar el nombre adecuado a esta tabla



lógica en QlikView. QlikView utilizará por defecto el nombre de tabla asignado como nombre de la tabla lógica, pero es conveniente dar siempre nombre a sus cargas de tabla, para poder controlar después cómo referirse a ellas. QlikView pondrá automáticamente en cursiva el nombre de tabla una vez que haya añadido los dos puntos (:) tras el nombre.

14. Haga clic en el icono Guardar del Editor de Script. Esto guardará su documento QlikView completo, incluyendo el script de carga.

15. A continuación, repita este mismo procedimiento para cargar los

campos de las tablas Shippers, Products y Categories de la misma manera descrita anteriormente. Cambie el nombre del campo CompanyName por Shipper en la tabla Shipper para que los exportadores (shippers) no se mezclen con nuestras empresas cliente. Además, no cargue el campo UnitPrice de la tabla Products, ya que esos datos se extraerán desde la tabla Order Details.

/* Shippers Table comments */ Shippers: SQL SELECT ShipperID, CompanyName as Shipper FROM Shippers; /* Products Table comments */ Products: SQL SELECT CategoryID, ProductID, ProductName, QuantityPerUnit, SupplierID, UnitCost, UnitsInStock, UnitsOnOrder FROM Products; /* Categories Table comments */ Categories: SQL SELECT CategoryID, CategoryName, Description FROM Categories;

16. Pulse SELECT nuevamente y cargue la tabla Orders. Edite

manualmente el script para copiar el campo OrderDate tal como se muestra más adelante, para generar nuevos campos para año, mes y día. Cargaremos estos datos con una sentencia load precedente a fin de utilizar las funciones de fecha de QlikView, incluyendo el



formateado de mes. (La diferencia está en que el mes se representa como valor numérico cuando se emplea la sentencia select y como una combinación de texto y número con la sentencia load.) Observe que las cadenas de texto que se utilizan para representar los meses dependen de los parámetros regionales de su sistema operativo (como se ve en las sentencias de script iniciales). Si sus configuraciones estuvieran en inglés, los meses aparecerán en inglés.

Según el plan de proyecto, en la sección Trends, necesitaremos finalmente ofrecer un análisis de tiempos acerca del Mes, Trimestre y Año. El siguiente script proporcionará el Año, el Mes y el Día del mes. Ampliaremos información sobre esto mismo más adelante, a fin de añadir el Mes & Trimestre actualizado. Tenga presente que la sentencia Load no tiene cláusula From o Resident, dado que la fuente es la siguiente sentencia que se indica a continuación SQL SELECT.

/* Orders Table comments */ Orders: Load CustomerID,

EmployeeID, Freight, OrderDate,

Year(OrderDate) as Year, Month(OrderDate) as Month, Day(OrderDate) as Day, OrderID, ShipperID; SQL SELECT * FROM Orders;

17. Finalmente, cargaremos la tabla OrderDetails. Aquí crearemos un

nuevo campo NetSales que es la primera Medida Clave (Key Measure) identificada en el plan de proyecto, en la sección Medidas Clave (Key Measures). NetSales es el resultado de un cálculo basado en UnitPrice*Quantity*(1-Discount). El script de carga es como sigue:

/* Order Details Table comments */ Order_Details: SQL SELECT OrderID, ProductID, Quantity, UnitPrice, UnitPrice*Quantity*(1-Discount) as NetSales FROM Òrder Details`;



Consejo: No se permiten espacios en la etiqueta del nombre de la tabla.

Asegúrese de guardar su aplicación, bien mediante el diálogo Editor de Script, o en la interfaz de QlikView, mediante Archivo… Guardar.

7.3. Su primer script básico Su script debiera tener ahora más o menos el siguiente aspecto:

SET ThousandSep=','; SET DecimalSep='.'; SET MoneyThousandSep=','; SET MoneyDecimalSep='.'; SET MoneyFormat='$#,##0.00;($#,##0.00)'; SET TimeFormat='h:mm:ss TT'; SET DateFormat='M/D/YYYY'; SET TimestampFormat='M/D/YYYY h:mm:ss[.fff] TT'; SET MonthNames='Jan;Feb;Mar;Apr;May;Jun;Jul;Aug;Sep;Oct;Nov;Dec'; SET DayNames='Mon;Tue;Wed;Thu;Fri;Sat;Sun'; ODBC CONNECT TO [EnterpriseScript;DBQ=DATASOURCES\QWT.mdb]; /* Customers Table comments */

Customers: SQL SELECT Address, City, CompanyName, ContactName, Country, CustomerID, Fax, Phone, PostalCode, StateProvince FROM Customers; /* Shippers Table comments */ Shippers: SQL SELECT ShipperID, CompanyName as Shipper FROM Shippers; /* Products Table comments */ Products: SQL SELECT CategoryID, ProductID, ProductName,



QuantityPerUnit, SupplierID, UnitCost, UnitsInStock, UnitsOnOrder FROM Products; /* Categories Table comments */ Categories: SQL SELECT CategoryID, CategoryName, Description FROM Categories;

/* Orders Table comments */ Orders: Load CustomerID,

EmployeeID, Freight, OrderDate,

Year(OrderDate) as Year, Month(OrderDate) as Month, Day(OrderDate) as Day, OrderID, ShipperID; SQL SELECT * FROM Orders;

/* Order Details Table comments */ Order_Details: SQL SELECT OrderID, ProductID, Quantity, UnitPrice, UnitPrice*Quantity*(1-Discount) as NetSales FROM Òrder Details`;



7.4. Ejecución del script Para eliminar un posible riesgo de pérdida de su script, por una u otra causa, es importante guardarlo con cierta frecuencia, y especialmente antes de la ejecución de un script de carga. A continuación, haga clic en el icono Ejecutar Script de la barra de herramientas. El script se ejecutará y los datos se cargarán en la aplicación. Seleccionar Campos en el menú Diseño o Configuración… Propiedades de Hoja… Campos lista todos los campos cargados:

Figura 10. La página de diálogo Propiedades de Hoja: Campos



8. Estructura de los datos cargados En este capítulo se analizan los campos de sistema creados y mantenidos por QlikView de manera automática, y que se pueden emplear para comprender la estructura interna de nuestro documento QlikView. El capítulo nos introduce así mismo en una serie de métodos para monitorizar y analizar la estructura de los datos QlikView. Estas técnicas y herramientas nos resultarán útiles a la hora de crear el script de carga y la estructura del documento, y serán esenciales cuando tratemos de verificar la integridad de un documento, o de depurar errores.

8.1. Campos de sistema Durante el proceso de carga, se generan seis campos especiales que contienen información sobre la estructura de la base de datos asociativa de QlikView, es decir, contienen meta-datos sobre la base de datos AQL. Éstos son los que reciben el nombre de campos de sistema y a continuación veremos cómo se pueden utilizar al trabajar con QlikView. 1. $Field Muestra los nombres de todos los campos cargados 2. $Table Muestra los nombres de todas las tablas cargadas 3. $Rows Muestra el número de filas que hay en las tablas 4. $Fields Muestra el número de campos en las diversas tablas 5. $FieldsNo Muestra las posiciones de los campos en las tablas

(número de columna) 6. $Info Muestra los nombres de las tablas de información

cargadas

8.1.1. La pestaña sistema Cuando esté desarrollando un documento, una hoja de sistema le resultará muy útil, ya que le mostrará cómo se relacionan entre sí las tablas lógicas en el documento. Es una práctica muy conveniente la de crear una hoja de sistema como primer paso tras haber cargado los datos. A continuación crearemos una hoja de sistema:

1. Cree una nueva hoja, haciendo clic en el botón Añadir Hoja de la barra de herramientas Diseño o seleccionando Añadir Hoja en el menú Diseño.

2. Haga clic con el botón derecho en la hoja nueva, y seleccione

Propiedades. Introduzca el Título de la hoja como Sistema en la pestaña General.



3. En la pestaña Campos, marque la casilla de verificación Mostrar

Campos de Sistema y seleccione a continuación todos los campos que contengan un signo dólar $ frente a ellos.

4. Pulse Añadir, a continuación Aceptar.

Disponga los campos en la hoja y a continuación seleccione Propiedades, General, Mostrar Campos de Sistema para el cuadro de lista $Field, a fin de poder ver cuántas veces aparecen los diversos campos en las tablas de la base de datos asociativa. En la pestaña Ordenar podrá clasificarlos en orden descendente según su frecuencia de aparición, de modo que los campos que aparezcan un mayor número de veces se sitúen en la parte superior de la lista.

8.1.2. Utilización de los campos de sistema Si selecciona CustomerID en $Field verá en qué tablas aparece el campo, además de otra información relativa a los campos de sistema.

Figura 112. Resultado de seleccionar CustomerID en el cuadro de lista $Field

8.2. El visor de tablas Otra forma de mostrar la estructura lógica de las tablas disponibles en un documento QlikView y las conexiones entre las mismas, consiste en emplear el visor de tablas gráfico integrado. La opción Archivo… Visor de Tablas (o <Ctrl>-T) abre una ventana que muestra todas las tablas cargadas y sus campos de conexión clave. Puede reorganizar sus componentes haciendo clic y arrastrando, o seleccionando Auto-Diseño. Asegúrese de pulsar Aceptar cuando haya finalizado, para guardar su diseño.



Figura 13. Una vista de tabla a modo de ejemplo

8.3. La tabla de sistema En QlikView se pueden crear múltiples tablas de diversa índole, que contengan tipos de datos muy dispares, así pues, ¿por qué no emplear la misma técnica para investigar las relaciones entre las tablas de nuestra base de datos? La tabla de sistema es una tabla pivotante que ilustra las relaciones y conexiones que se dan entre tablas y campos de la base de datos asociativa de QlikView. Empezaremos por crear dicha tabla en nuestra hoja de sistema. Todo desarrollador de sistemas debiera contar con una tabla de sistema. Cuanto más complicada sea la estructura de datos, mayor la necesidad y el uso que se hará de dicha tabla.

1. En su aplicación QlikView, asegúrese de que se halla en la hoja

Sistema. 2. Haga clic con el botón derecho en la hoja y seleccione nuevo objeto

de hoja, Tabla de Sistema. Se creará una Tabla Pivotante con las dimensiones $Field y $Table. La expresión del gráfico será Only($Field). Ambas dimensiones se ordenan según el orden de carga.



Figura 14. Una tabla de sistema



8.4. Propiedades de Documento: la página Tablas Esta página de diálogo le ofrece otra forma más de contemplar la estructura de datos. Todas las tablas y campos incluidos en el documento QlikView se listan aquí, junto con unas estadísticas de cada entidad. Haga clic en el botón Exportar Estructura para exportar diversos archivos de texto delimitados por tabulador, que contienen dicha información. Estos archivos pueden importarse de nuevo a QlikView – bien este mismo documento, u otro distinto – para un análisis adicional.

Figura 15. Propiedades de Documento: el diálogo Tablas

Volveremos a este cuadro de diálogo más adelante, en un capítulo posterior, cuando analicemos las referencias circulares en la estructura de datos y como se puede hacer un seguimiento de las mismas empleando el diálogo Propiedades de Documento: Tablas. Más concretamente, analizaremos las casillas de verificación Parcialmente Desconectado para las Tablas, y sus posibilidades de utilización.



9. Añadir Datos de Texto Según nuestro plan de proyecto, hay tablas adicionales de datos que cargar. Estas no se encuentran en formato de base de datos, así que comenzaremos a utilizar el Asistente para Tablas a fin de crear las sentencias de Carga de QlikView. Las fuentes esta vez serán dos hojas de cálculo Excel y un archivo DIF. Estos archivos contienen datos acerca de los empleados, las oficinas y los proveedores. Comencemos analizando las fuentes de datos.

9.1. Empleados Tomamos los datos sobre los empleados del archivo Excel EmpOff.xls y la hoja de cálculo Employee (empleado) en la carpeta DataSources (Fuentes de Datos). Primero abrimos el archivo Excel y echamos un vistazo a su contenido.

Figura 16. La tabla Employee (Empleado)

La clave de esta tabla se halla en el campo EmpID, que conecta la tabla con los demás datos que hemos cargado.

9.2. Oficinas Los datos relativos a las oficinas de la compañía también se toman del archivo Excel: EmpOff.xls pero de la hoja de cálculo Office (Oficina), que es la segunda hoja de cálculo del archivo Excel EmpOff.xls.

Figura 17. La tabla Office (Oficina)

La clave de esta tabla es Office y los valores de este campo se asociarán a los valores del campo Office de la tabla Employee.



9.3. Proveedores Los datos sobre los proveedores se tomarán de un archivo DIF llamado suppliers.dif (carpeta DataSources). Este formato es en cierto modo diferente, como podrá observar si echa un vistazo al archivo en un editor de texto normal, por ejemplo en el Bloc de notas. El archivo DIF tendrá el siguiente aspecto:

TABLE 0,1 "EXCEL" VECTORS 0,30 "" TUPLES 0,9 "" DATA 0,0 "" -1,0 BOT 1,0 "SupplierID" 1,0 "CompanyName" 1,0 "ContactName" 1,0 "Address" 1,0 "City" 1,0 En cambio, el mismo archivo, pero en Excel, resulta bastante más legible:

Figura 18. El archivo DIF Suppliers (Proveedores)

Cargaremos datos desde este archivo más adelante, en otro capítulo posterior.

9.4. Generación de script mediante el asistente de archivo

Ahora continuamos con la generación de nuestro script de carga, añadiendo sentencias de Carga QlikView para los tres archivos que acabamos de ver.



Para crear estas sentencias, emplearemos el Asistente para Tablas del cuadro de diálogo Editor de Script. 1. Abra el diálogo Editor de Script desde el menú, o la barra de

herramientas. 2. Asegúrese de que la casilla de verificación Rutas Relativas esté

marcada. 3. Asegúrese de que la casilla de verificación Asistente esté marcada y

a continuación haga clic en el botón Ficheros Planos… para abrir el diálogo Abrir Archivos Locales.

4. Navegue hasta encontrar el archivo EmpOff.xls en la carpeta

DataSources y haga clic en Abrir.

Figura 19. El Asistente de Archivos

Compruebe que las configuraciones sugeridas por el asistente sean las correctas. Debiera mostrarse lo siguiente: Type: Excel files (BIFF), Table: Employee$, Embedded Labels 5. Haga clic en el nombre del campo EmpID y cambie el nombre por

el de EmployeeID.



6. Pulse Finalizar para volver al cuadro de diálogo Editor de Script y visualice la nueva sentencia Load generada para los datos de Employee...

7. Ahora, añada sus comentarios a esta carga de datos, y nombre la

tabla como Employee. También puede borrar la sentencia Directorio, generada debido a la especificación de Rutas Relativas. No necesitaremos estas sentencias en nuestro script.

8. Además, según nuestro plan de proyecto, necesitaremos añadir un

campo [Employee Hire Year]. Incluya dicho campo ahora, empleando la función year en el campo [Hire Date].

9. Las sentencias de script debieran ofrecer el siguiente aspecto:

/* Employee Table comments */ Employee: Load EmpID as EmployeeID, [Last Name], [First Name], Title, [Hire Date], Year([Hire Date]) as [Employee Hire Year], Office, Extension, [Reports To], [Year Salary] FROM Datasources\EmpOff.xls (biff, embedded labels, table is [Employee$]); 10. A continuación, siga el mismo procedimiento para los datos de la

tabla Office. Esta se encuentra en la segunda hoja de cálculo del archivo Excel EmpOff.xls. Cuando abra el Asistente para Tablas, asegúrese de cambiar a la hoja de cálculo Excel Office$ en el cuadro denominado Table (Tabla) en la primera página del asistente.

11. Añada los comentarios a la tabla y denomine la sentencia de Carga con el nombre Office. Las siguientes sentencias deberían incluirse en su script:

/* Office Table comments */ Office: Load Office, Address, [Postal Code], City, StateProvince, Phone, Fax, Country



FROM Datasources\EmpOff.xls (biff, embedded labels, table is [Office$]); Observe que los nombres de campo que contienen espacios se encierran entre corchetes (también se pueden emplear comillas " "), por ejemplo, [Código Postal]. 12. Pulse Aceptar en el Editor de Script, y guarde el documento. A

continuación recargue los datos desde los menús o desde la barra de herramientas.

Figura 20. Advertencia acerca de referencias circulares

13. QlikView le avisa si encuentra referencias circulares, o bucles, en la

estructura de tabla. Pulse Aceptar. Cuando trabaje con estructuras de datos muy complejas, que contengan gran cantidad de tablas, es posible que se vea en una situación en la que la interpretación de los datos sea incierta. QlikView ha sido desarrollado de tal manera que pueda manejar las estructuras más complejas, e interpretarlas automáticamente de forma correcta, no obstante existen ciertas limitaciones. Es importante que sea consciente de cuáles son estas limitaciones y sepa cómo resolver el problema de los bucles cuando éste se plantee. Pronto volveremos a la generación de nuestro script, pero primero analicemos las referencias circulares y sus consecuencias.

9.5. Referencias circulares Observe el siguiente ejemplo, que consiste en una estuctura de datos simple, con tres tablas: Clientes Pedidos Presupuesto IDCliente IDCliente País País IDProducto IDProducto ValorPedido



Como puede ver, es posible literalmente “ir en círculos”. En este ejemplo, es fácil detectar una referencia circular, pero esto puede complicarse mucho más en estructuras más complejas. Las estructuras de datos de este tipo debieran evitarse, ya que pueden llevar a una interpretación ambigüa de los datos. Desgraciadamente, las referencias circulares son algo habitual, y no es raro encontrárselas a lo largo de la vida laboral. A menudo se deben a un diseño pobre de la base de datos, pero en algunas ocasiones son inevitables. En ciertos casos, un campo (o tabla) puede cumplir diversos roles, por ejemplo, una compañía puede ser cliente y proveedor a la vez. El campo, o tabla, debe entonces cargarse dos veces en QlikView, bajo nombres diferentes. QlikView resuelve el problema de las referencias circulares empleando una tabla parcialmente desconectada. Si QlikView encuentra un bucle mientras se ejecuta el script de carga, se mostrará un diálogo de advertencia y una o más tablas se configurarán como parcialmente desconectadas. QlikView tratará de desconectar parcialmente la tabla de mayor longitud. Esta será a menudo una tabla de transacción. Si desea desviarse de la opción prederminada por defecto en QlikView, puede definir la tabla como parcialmente desconectada empleando una sentencia loosen table (desconectar tabla) en el script. También es posible modificar los parámetros de configuración de las tablas parcialmente desconectadas de forma interactiva tras la ejecución de script mediante la pestaña Tablas en Propiedades de Documento. También puede determinar qué tablas de su estructura están establecidas como parcialmente esconectadas empleando la utilidad Visor de Tabla. Las tablas parcialmente desconectadas mostrarán líneas de puntos a modo de conectores. Para evitar las referencias circulares y las tablas parcialmente desconectadas, debe renombrar los campos que ocasionan los bucles y eliminar las tablas parcialmente desconectadas en la pestaña Tablas en Propiedades de Documento.

9.6. Causas de las referencias circulares Con frecuencia, las estructuras circulares son resultado de la existencia de campos clave incluidos de manera no intencional en la carga de datos. En nuestro documento QlikView, hemos recibido un mensaje de advertencia ante referencias circulares porque muchos campos de tablas diferentes tenían el mismo nombre. Esto ocasiona asociaciones indebidas de campos QlikView. Puede verse más claramente analizando la hoja de sistema.



1. Vaya a la hoja de sistema y haga clic con el botón derecho en el cuadro de lista $Table y seleccione Propiedades.

2. Seleccione Mostrar Frecuencia en la pestaña General y ordene

por frecuencia.

3. Ahora podemos ver la frecuencia en ambos cuadros de lista $Field y $Table. Ahora seleccionamos todos los que tengan una frecuencia mayor que 1 en $Field y a continuación hacemos lo mismo para $Table.

4. Elimine todos los valores de $Field que tengan la frecuencia 1, y

luego proceda igual en $Table. Continúe de la misma manera hasta que ya no le sea posible eliminar los valores con frecuencia 1.

Si no es posible obtener la frecuencia 1 para todas las tablas posibles restantes en el cuadro de lista $Table, entonces tenemos una referencia circular en alguna parte de la aplicación.

Figura 21. Todos los valores posibles tienen una frecuencia mayor que 1 Si examinamos ahora más de cerca los valores posibles del cuadro de lista $Field, veremos que algunos de estos campos probablemente no deberían estar conectados. Un ejemplo de ello lo tenemos en el campo Fax.

1. Seleccione Fax en el cuadro de lista $Field.



2. Compruebe en qué tablas aparece el campo Fax.

Fax se encuentra en las tablas Customers y Office. No queremos que los números de fax de nuestros clientes se mezclen con los números de fax de nuestras oficinas. Por lo tanto, debemos renombrar este campo en la tabla Office, que fue la que se cargó más recientemente. Los demás campos de esta tabla también debieran ser renombrados.

9.7. Renombrar campos para evitar las referencias circulares

Podemos evitar las referencias circulares modificando el script. 1. Abra el cuadro de diálogo Editor de Script y renombre los campos

de la tabla Office tal y como se muestra más adelante. Observe que no queremos renombrar el campo clave intencional Office, dado que aún necesitamos un enlace con la tabla Employee. También aprovechamos la oportunidad para renombrar el campo City como [Sales Office] según nuestro plan de proyecto.

Office: Load Office, Address as OfficeAddress, [Postal Code] as OfficePostalCode, City as [Sales Office], StateProvince as OfficeStateProvince, Phone as OfficePhone, Fax as OfficeFax, Country as OfficeCountry FROM Datasources\EmpOff.xls (biff, embedded labels, table is [Office$]); 2. Haga clic en Aceptar en el Editor de Script, y guarde el documento.

A continuación recargue los datos desde los menús o la barra de herramientas. No debería haber ninguna advertencia más sobre referencias circulares, lo cual quiere decir que todas han sido eliminadas.



Figura 22. Las tablas posibles tienen ahora la frecuencia 1 Como puede ver en la figura superior, ya no hay ningún campo que asocie las tablas Office y Customers. QlikView eliminará automáticamente la designación de parcialmente desconectado de la tabla Orders (Pedidos) una vez que la referencia circular haya sido corregida.

9.8. Tablas parcialmente desconectadas En una tabla parcialmente desconectada, la lógica asociativa de QlikView está internamente desconectada. Esto significa que las selecciones en los campos no clave de una tabla no afectarán a otras tablas. En ciertos casos, esto puede resultar muy eficaz, aunque en nuestro caso no queremos implementar esta función. Para entender el concepto de parialmente desconectado, observe el siguiente ejemplo: Aquí vemos cuadros de tabla creados por tres tablas diferentes.

Si elegimos el valor 2 del campo B, ocurre lo siguiente:



La selección afecta a todas las tablas. Ahora conservemos este valor, pero haciendo la Tabla 2 parcialmente conectada. Esto implica que la lógica entre los campos A y C está desconectada. El resultado es:

Observe que la Tabla 2 mostrada arriba es un cuadro de tabla y no la tabla real. El cuadro de tabla muestra todas las combinaciones posibles de columnas. Como no existe una conexión lógica entre los campos A y C, todas las combinaciones posibles entre sus valores se muestran. Como la Tabla 2 está parcialmente conectada, las selecciones realizadas en la Tabla 1 no se propagarán a la Tabla 3.



10. Ejercicios

1. Use el botón Exportar Estructura situado en el diálogo Propiedades de Documento: Tablas para exportar la estructura de tabla desde su documento QlikView.

2. Cree un nuevo documento QlikView, y cargue los datos desde las tablas que exportó en el paso 1.

3. Muestre los campos de esta carga en una o más hojas.



11. Creación de datos en QlikView En nuestro plan de proyecto, una de las Dimensiones Clave que aparecen listadas es Sales Person. Dado que no existe ningún campo en nuestros datos fuente para Sales Person, necesitaremos generar este campo en QlikView durante el proceso de carga de datos. En este capítulo, practicaremos con las cargas residentes y condicionales, también se introducirá al lector en el concepto de creación de múltiples tablas lógicas en QlikView, basadas en una única tabla de datos fuente. También nos iniciaremos en la tabulación de script.

11.1. Carga residente En esta sección, aprenderemos cómo crear una nueva tabla lógica en QlikView, basada en una tabla (residente) previamente cargada. También se verá cómo segregar el script de carga en distintas pestañas para facilitar la lectura y el mantenimiento. 1. Abra el diálogo Editor de Script. 2. Añada una nueva tabla al script haciendo clic en el icono Añadir

nueva pestaña o seleccionando Añadir Pestaña… del elemento de menú Pestaña. Otorgue el nombre de Sales Person a la nueva pestaña.

3. Ahora añadiremos otra carga de tabla al script, pero esta vez, en

lugar de utilizar un asistente para crear el código, copiaremos código ya existente, y lo modificaremos. Primeramente localice la carga de la tabla Employee en la pespaña de script Principal. Copie (pulsando <Ctrl>-C, o mediante Editar… Copiar) todas las líneas de esta sentencia. A continuación vuelva a la pestaña Sales Person, y pegue (pulsando <Ctrl>-V, o mediante Editar… Pegar). Ahora debería tener un duplicado de la carga de la tabla Employee en la nueva pestaña.

4. A continuación, edite la sentencia de carga tal y como se le indica:

- Cambie el nombre de tabla por el de Sales_Person - Elimine el renombrado de EmpID, y cambie al nombre de campo QlikView: EmployeeID (ya no estamos leyendo de la fuente de datos). - Elimine los campos [Hire Date], Office, Extension, [Reports To], y [Year Salary] de la sentencia load. - Elimine la coma del campo Título (ahora es el último campo de esta carga) y renombre este campo con el nombre de SalesTitle. - Elimine la especificación Desde, dado que no se leerá desde un archivo de disco para esta carga.



- Añada la especificación Residente, apuntando al archivo residente del que deseamos cargar, en la misma ubicación en la que se hallaba Desde.

5. Su script debería tener ahora el siguiente aspecto: /* Sales Person Table comments */ Sales_Person: Load EmployeeID, [Last Name], [First Name], Title as SalesTitle Resident Employee; 6. Ahora queremos limitar la carga de todos los registros de datos de

Employee únicamente a aquellos que podamos identificar como vendedores (Salesperson). Para hacer esto, necesitamos hacer otro cambio al código de script. Primero, elimine el punto y coma (;) situado tras Resident Employee. A continuación, añada la condición where tras la línea Resident, tal como se indica:

where Left(Title,3) = 'Sal' OR Title = 'President'; 7. Pulse Aceptar en el Editor de Script, y guarde el documento. A

continuación recargue los datos desde los menús o mediante la barra de herramientas.

8. Añada cuadros de lista para [Last Name], Title, y SalesTitle a la

hoja Principal. Elija Seleccionar Todo en el campo SalesTitle, y observe que sólo algunos de los valores [Last Name] y Title se muestran como posibles (es decir, en blanco).

Para que un valor de la tabla Employee original sea incluido en la nueva tabla lógica Sales_Person, debe satisfacer al menos una de las condiciones ya definidas. La primera de ellas, que los tres primeros caracteres del campo Title deben ser Sal. La segunda, que el campo sea igual a President. 9. Guarde el documento.

11.2. Tablas de clave sintética No es algo deseable el tener varias claves comunes a lo largo de diversas tablas en una estructura de datos QlikView. Esto puede ocasionar que QlikView tenga que utilizar claves complejas (también conocidas como claves sintéticas) para generar las conexiones de la estructura de datos. Las claves sintéticas generalmente consumen muchos recursos y pueden ralentizar los cálculos o incluso, en casos



extremos, sobrecargar las aplicaciones. También dificultan la comprensión y el mantenimiento de los documentos. Existen varios casos en los que las claves sintéticas son imposibles de evitar (por ejemplo en las Tablas de Correspondencia de Intervalos), pero, en general, las claves sintéticas deberían eliminarse en todos los casos, siempre, si ello es posible. Cuando anteriormente cargamos la tabla que genera el campo SalesTitle, sin querer estábamos creando una clave sintética entre las tablas Employee y Sales_Person. La clave sintética se genera en una nueva tabla de clave sintética ($ Syn 1 Table) la cual puede verse desde el Visor de Tablas en el menú Archivo.

Figura 23. Las tablas de clave sintética vistas desde el Visor de Tablas

11.3. Cómo eliminar una tabla de clave sintética Como se puede deducir por lo expuesto en el Visor de Tablas ahora mismo tenemos una tabla de clave sintética que se compone de los campos First Name, Last Name y EmployeeID. En este caso, no hay razón por la que necesitaemos emplear los campos de nombre como una clave adicional entre estas tablas, dado que EmployeeID ya cumple este propósito. Para corregir esta situación, emplearemos de nuevo la técnica de renombrar campos. Para eliminar las conexiones redundantes, deberíamos renombrar los campos que no deseamos utilizar como campos clave. Podemos aprovechar la oportunidad para introducir un cambio más combinando los campos First Name y Last Name en nuevos campos Name por concatenación. Así mismo, nuestro plan de proyecto nos exige que proporcionemos un campo Sales Person consistente en nombre de pila y apellido.



Efectúe los siguientes cambios en las líneas de script que sirven para cargar los campos First Name y Last Name para que el script que carga las dos tablas implicadas ahora sea así:

Employee: Load EmpID as EmployeeID, [First Name] & ' ' & [Last Name] as Name, [Last Name], [First Name], Title, [Hire Date],

Year([Hire Date]) as [Employee Hire Year], Office, Extension, [Reports To], [Year Salary] FROM Datasources\EmpOff.xls (biff, embedded labels, table is [Employee$]); … Sales_Person: Load EmployeeID, Name as [SalesPerson], Title as SalesTitle Resident Employee Where Left(Title,3) = 'Sal' OR Title = 'President';

Tras ejecutar el script, puede constatar que la clave compleja se ha ido, empleando de nuevo para ello la utilidad Visor de Tablas. También puede añadir el nuevo cuadro de lista [Sales Person] a la hoja Principal para visualizar los resultados.

11.4. Avanzado – Cómo valerse de Orders (pedidos) para determinar Sales Person (Vendedor).

Acabamos de emplear un método bastante simple, que nos ha permitido probar los valores de campo requeridos para el campo SalesPerson. Este es un método perfectamente válido y adecuado, pero también podríamos haber obtenido el mismo resultado utilizando una solución más elegante. Comenzamos observando que todos los vendedores (sales people) están incluidos en nuestros datos de ventas. De ahí se deduce que deben estar incluidos en el campo EmployeeID en la tabla Orders. Comenzamos por crear un campo nuevo EmployeeSales en el script, en el que Orders se esté cargando. Haciendo referencia a este campo posteriormente en el script, podemos asegurarnos de que todos los empleados que han sido



acreditados por las ventas aparecerán listados en el campo [Sales Person]. 1. Para hacer esto, introduzca la siguiente línea en la sentencia load de

la tabla Orders inmediatamente después de la carga del campo EmployeeID.

EmployeeID as EmployeeSales,

2. A continuación, cambie la condición Where en la sentencia load de

la tabla Sales_Person para utilizar la función exists de QlikView. También incluiremos un campo exclusivo SalesPersonID para identificar al vendedor (SalesPerson).

Sales_Person: Load EmployeeID, EmployeeID as SalesPersonID, Name as [SalesPerson], Title as SalesTitle Resident Employee Where Exists(EmployeeSales,EmployeeID);

La condición de la cláusula Where comprueba que los datos cargados tengan sus correspondientes valores en el campo EmployeeSales. Como su propio nombre indica, la función exists puede utilizarse para comprobar si existe un valor de campo específico en un determinado campo de los datos cargados hasta el momento. Recuerde ser cuidadoso en el orden que siga en sus sentencias de script, ya que el campo de referencia debería ir lleno antes de comprobar los valores. En este ejemplo, la tabla Orders debe cargarse antes que la tabla Sales_Person para que esta condición funcione como es debido. Tras haber terminado de efectuar estos cambios, y haber guardado el documento, debería comprobar la funcionalidad de su script.



12. Cómo cargar un archivo DIF

12.1. Archivos de texto en Formato de Intercambio de Datos

El acrónimo formado por las siglas DIF significa Data Interchange Format (Formato de Intercambio de Datos) y se utiliza, por ejemplo, al transferir archivos de texto desde el entorno AS/400. Ahora añadiremos la tabla suppliers a nuestro script de carga, la cual, como ya se ha visto, está en formato DIF. 1. Abra el diálogo Editor de Script desde el menú o la barra de

herramientas. 2. Sitúe el cursor en la parte inferior de la pestaña Principal, y añada

su comentario para la carga de la tabla de datos Suppliers.

3. Asegúrese de que la casilla de verificación Asistente esté marcada y a continuación haga clic en el botón Ficheros Planos… para abrir el diálogo Abrir Archivos Locales.

4. Navegue hasta hallar el archivo suppliers.dif en la carpeta

DataSources y pulse Abrir.

5. Compruebe que el asistente haya interpretado el formato de archivo correctamente.

Tipo: DIF, Juego de Caracteres: OEM, Etiquetas Incrustadas.

Nota 1: El juego de caracteres correcto para este archivo es OEM. Los archivos creados en Windows tienen ANSI como juego de caracteres estándar. Macintosh usa el juego de caracteres MAC. A veces, como en este caso, se pueden utilizar otros juegos de caracteres al importar datos desde otros ordenadores. En tal caso, OEM quizá sea el más común. Este juego de caracteres se emplea por ejemplo en OS/2 y DOS. Si usted especifica un juego de caracteres indebido, existe el riesgo de que se pierdan algunos caracteres, o que se interpreten de manera incorrecta.

Nota 2: QlikView asocia campos con el mismo nombre. Si dos tablas tienen varios campos en común, QlikView puede crear claves complejas para poder asociar las tablas (véase tablas de clave sintética). Como sucedía en la tabla Office, suppliers.dif tiene varios campos en común con la tabla Customers en la base de datos de Access. Estos



campos no deberían asociarse unos con otros, y algunos de los campos de suppliers.dif deben ser renombrados. El único campo en común debería ser SupplierID, que también se encuentra en la tabla Products. Como renombraremos prácticamente todos los campos de suppliers.dif, emplearemos una sentencia especial de QlikView que califica todos los nombres de los campos con el nombre de la tabla, cuando éstos son cargados. Los nuevos nombres de campo serán por tanto table name.field name. Como queremos renombrar todos los campos excepto SupplierID, utilizaremos *. 6. Haga clic en Finalizar para volver al diálogo Editor de Script y ver

la nueva sentencia de Carga generada para los datos de los Proveedores (Suppliers).

7. Introduzca las siguientes líneas de código antes de la sentencia load de la tabla suppliers.

Qualify *; Unqualify SupplierID;

Como SupplierID va a conectarse a otra tabla, no debería tener el cualificador de tabla. Esto se especifica empleando la sentencia unqualify SupplierID.

8. Una vez que la tabla Suppliers haya sido cargada, debemos incluir

la siguiente sentencia, para que todos los campos cargados tras ésta no tengan el cualificador de tabla.

Unqualify *;

Ahora debería encontrarse con las siguientes líneas en su script: /* suppliers Table comments */ Qualify *; Unqualify SupplierID; suppliers: Load SupplierID, CompanyName, ContactName, Address, City, PostalCode, Country, Phone, Fax FROM Datasources\suppliers.dif (oem, dif, embedded labels); Unqualify *;



9. Pulse Aceptar en el Editor de Script y guarde el documento. A continuación recargue los datos desde los menús o la barra de herramientas.



13. Campos clave Los campos clave son campos comunes a una o más tablas (campos asociados). Cuando un campo se repite en más de una tabla, QlikView no sabe qué tabla utilizar para calcular la frecuencia de los datos.

13.1. Un ejemplo de problema que puede surgir Pongamos por caso que tenemos una tabla llamada Orders (Pedidos) con 1000 números diferentes de pedidos (OrderID). También tenemos una tabla llamada ForeignOrders (Pedidos del extranjero), que contiene 200 números. Estos números de pedidos también se encuentran incluidos en la primera tabla. Las dos tablas se asociarán a través del campo común OrderID (ID de pedido). El problema surge cuando deseamos saber el número exacto de OrderID únicos. Es 1000, 200 o 1200? Nosotros sabemos, por la información que tenemos, que la respuesta correcta es 1000 OrderID únicos, pero para QlikView no está tan claro. En este caso, QlikView buscará una tabla principal. Puede ser que elija la correcta, pero en muchos casos el programa tendrá que optar por una al azar. Como la elección al azar puede traer nefastas consecuencias, QlikView ha sido diseñado para que no permita ciertas operaciones si existe duda alguna respecto a qué campo es el más correcto para calcular la frecuencia.

13.2. ¿En qué me afecta esto? Debería tener en cuenta las siguientes limitaciones cuando trabaje con campos clave. • En la mayoría de ocasiones, no es posible obtener información

sobre la frecuencia en un cuadro de lista que muestre campos asociados. Verá que la casilla de verificación Mostrar Frecuencia está inactiva.

• En la mayoría de las ocasiones, tampoco será posible utilizar funciones para calcular la frecuencia de los campos asociados en gráficos (Count, etc.) Deberá emplear un cualificador Distinct en este tipo de expresiones.

• En general, es una buena medida evitar la utilización de campos clave en los cuadros de lista y las expresiones. Los campos clave



deberían emplearse para enlazar tablas unas con otras, y no para mostrar datos en un documento QlikView.

13.3. Cómo resolver el problema de los campos clave

Hay una solución relativamente fácil al problema de los campos clave y al cálculo de la frecuencia de los datos. Puede cargar de nuevo el campo que desee emplear para calcular la frecuencia pero esta vez bajo un nombre distinto. El problema descrito en el apartado anterior puede resolverse pues de la siguiente manera:

Load …, OrderID, OrderID as OrderIDCount, … from Order.xls (…); Ahora puede utilizar el campo nuevo (no asociado) en un cuadro de lista que muestre la frecuencia, o en un gráfico con funciones específicas para el cálculo de frecuencia. El nuevo nombre de campo puede ocultarse fácilmente otorgándole otro título para no confundir a los usuarios del documento.

13.4. ¿El gráfico muestra realmente lo que deseo mostrar?

Cuando cree un gráfico en QlikView, naturalmente es importante que verifique si realmente muestra lo que usted desea que muestre. Tenga cuidado con la elección de las expresiones, para que sean las más adecuadas para cada caso. QlikView cuenta con diversas expresiones. A continuación tiene un resumen de dichas expresiones, junto con lo que éstas muestran. Vendedor Artículo ClienteNo Cantidad Karl A 10 100 Janne A 101 200 Ola B 10 250 Karl B 111 350 Expresión Resultado Total Count(Vendedor) 4 Total Count(VendedorDistinto) 3 Total Count(Artículo) 4 Total Count(ArtículoDistinto) 2



Num(Cantidad) 4 Sum(Cantidad) 900



14. Ejercicios

1. Modifique el script en su documento QlikView de forma que incluya un campo llamado CuentaIDProducto, basado en el campo ProductID. El nuevo campo se utilizará para producir la Medida Clave (Key Measure) requerida: Total Productos Vendidos tal y como se detalla en nuestro plan de proyecto.

2. Modifique el script de su documento QlikView para que incluya un campo denominado CountOrderDate, basado en el campo OrderDate. El nuevo campo se empleará para contar el número total de Pedidos (Orders).

3. Cree una tabla pivotante, con las dimensiones Vendedor, NombreProducto, y Mes. La expresión debería contar el número de productos DISTINTOS vendidos, y debería etiquetarse [Productos Totales Vendidos]. Mostrar Sumas Parciales por Vendedor, y Mes.

4. Añada una nueva expresión para la cuenta total de productos vendidos y denomínela [Cantidad Ventas].

5. Ordene las dimensiones NombreProducto y Vendedor por la misma expresión que [Cantidad Ventas], en orden Descendente.

Figura 24. La solución



15. Campos de dimensión de tiempo adicionales

Hay dos (2) campos de dimensión de tiempo adicionales necesarios para nuestro documento QlikView según la sección Trends (Tendencias) de nuestro plan de proyecto. Necesitamos añadir Quarter (o Trimestre) y Rolling Month (Mes en curso actualizado). Emplearemos una técnica bastante simple para generar Quarter que introduce los conceptos de tablas de Load Inline, autogenerate y Mapping. Para Rolling Month, introduciremos algunas funciones de fecha QlikView adicionales, así como también indicaciones sobre cómo especificar formatos de fecha.

15.1. Tablas Inline Quizá recuerde que al principio del curso se analizaron las distintas maneras de cargar datos en el script QlikView. Ya se nos ha introducido en varias de estas técnicas, y ahora conoceremos una más. En algunos casos, puede resultar interesante poder introducir los datos de una tabla directamente en el script. Esto se hace con la ayuda de una sentencia denominada load inline. 1. Abra el diálogo Editor de Script desde el menú o la barra de

herramientas. 2. Sitúe el cursor cerca de la parte superior de la pestaña Principal,

antes que cualquier carga de tabla, pero tras las sentencias SET. Añada un comentario para cargar los datos del Trimestre.

3. Incluya la siguiente sentencia en el script: Quarters: Load * Inline [ Month, Quarter 1,Q1 2,Q1 3,Q1 4,Q2 5,Q2 6,Q2 7,Q3 8,Q3 9,Q3 10,Q4 11,Q4 12,Q4];



Como puede ver una carga inline contiene los nombres de campo y los datos encerrados entre corchetes ([]). También observe que los nombres de campo se sitúan en la primera línea, y los valores de datos van separados por comas. La tabla introducida en el script asocia meses numéricos con el correspondiente trimestre. Cuando ejecutamos el script, se genera un nuevo campo (Quarter). Pulse Aceptar en el Editor de Script, y guarde el documento. A continuación recargue los datos desde los menús o la barra de herramientas.

Consejo: Las tablas inline también se pueden generar por medio del Asistente Inline que se abre pulsando un botón del grupo Datos Inline en el editor de script.

15.2. Autogenerar tablas Otra forma de generar datos en QlikView consiste en emplear la cláusula autogenerate en la sentencia load. Especificar autogenerate en una sentencia load generará automáticamente un número de registros. Sólo se permiten funciones libres de parámetros y constantes en una autogenerate load. Muy a menudo, las funciones recno() o rowno() se emplean para proporcionar un número exclusivo y único para cada fila. 1. Abra el diálogo Editor de Script desde el menú o la barra de

herramientas. 2. Sitúe el cursor tras la carga de las tablas Quarters que acabamos de

añadir en el paso anterior, en la pestaña Principal. Asegúrese de comentar esa sentencia load, ya que la reemplazaremos con otra alternativa. Si añade REM frente a la etiqueta de la tabla, eso servirá para comentar toda la sentencia.

3. Incluya la siguiente sentencia en el script: Quarters: Load rowno() as Month, 'Q' & Ceil(rowno()/3) as Quarter Autogenerate(12); La función rowno() devolverá el número actual de filas de la tabla lógica QlikView que se está creando, empezando por 1. La función Ceil (de “ceiling”, techo o tope) redondea el número hacia el siguiente entero. El caracter & se usa para la concatenación de cadenas en QlikView.



Pulse Aceptar en el Editor de Script, y guarde el documento. A continuación recargue los datos desde los menús o la barra de herramientas. Recuerde emplear sólo una de las sentencias Quarters load, y comentar la otra.

15.3. Tablas Mapping o Tablas de correspondencias Este tipo de tabla es útil porque enlaza los datos de Mes (Month) con el Trimestre (Quarter) correcto en la tabla Orders (Pedidos). Sin embargo, el campo Month es ahora un campo clave, y esto probablemente acarreará problemas más adelante. Hay unas cuantas soluciones y ahora pasaremos a investigar una de ellas. Transformando nuestra tabla load inline Quarters en una tabla mapping, podremos integrar el campo Quarters en la misma tabla que Month (la tabla Orders). El prefijo mapping se utiliza en una sentencia join o select para crear una tabla mapping. Las tablas leídas vía mapping load o mapping select reciben un tratamiento distinto de las demás tablas. Se almacenan en un área de memoria diferente y se emplean únicamente como tablas mapping durante la ejecución de script. Tras la ejecución de script se descartan de forma automática. Una tabla mapping debe contener dos columnas, la primera con valores comparativos y la segunda con los valores de correspondencia que se desee. Hay que nombrar las dos columnas, pero los nombres no tienen especial relevancia en sí mismos. Los nombres de columna no tienen conexión con los nombres de campo de las tablas regulares. Cuando las tablas mapping se usan para mapear un determinado valor o expresión, ese valor será comparado con los valores de la primera columna de la tabla mapping. Si se encuentra, el valor original será reemplazado por el correspondiente valor en la segunda columna de la tabla mapping. Si no se encuentra, no se efectuará reemplazo alguno. La sintaxis es la siguiente: mapping ( load statement | select statement ) Ahora, cambie la carga de la tabla Quarters a una mapping, como se indica: Quarters_Map: Mapping Load … Si recarga los datos ahora, perderá la tabla Quarters y el campo, dado que las tablas mapping son temporales. No obstante, podemos usar la



tabla Quarters_Map en nuestro script (siempre y cuando lo empleemos tras haber sido definido en el script). Para hacer esto, emplearemos la función applymap. La sintaxis es: applymap( 'mapname', expr, [ , defaultexpr ] ) La función applymap hace corresponder cualquier expresión de una tabla mapping previamente cargada. Mapname es el nombre de una tabla mapping previamente cargada por una sentencia mapping load o mapping select. El nombre debe ir enmarcado por comillas simples. Expr es la expresión cuyo resultado habrá de ser mapeado. Defaultexpr es una expresión opcional, que se empleará como valor de correspondencia por defecto si la tabla mapping no contiene ningún valor que encaje con expr. Si no se suministra valor predeterminado alguno, el valor de expr es devuelto tal cual. Añada una función applymap a la tabla Orders, basándose en el valor numérico de Month. Esta función debería hacer referencia a la tabla the Quarters_Map. La función debería presentar el siguiente aspecto: applymap('Quarters_Map',num(Month(OrderDate))) as Quarter,

Pulse Aceptar en el Editor de Script y guarde el documento. A continuación recargue los datos desde los menús o la barra de herramientas. Luego incluya el campo Quarter a la hoja Principal, y revise su trabajo.

15.4. Mes en curso actualizado Completaremos nuestros campos de dimensión de tiempo creando un campo nuevo que haga cada mes único. Hay, desde luego, diversas maneras de acometer esto. En este curso, crearemos el campo Rolling Month (Mes en curso actualizado) empleando funciones de fecha QlikView basadas en el campo OrderDate, junto con una función de formateado de fecha que suministre el formato correcto de presentación para nuestro campo de mes. No vamos a entrar a discutir si limitar los valores del campo Rolling Month a los últimos 24 meses, ya que dicho tema se ve en el módulo de formación Time Dimension (Dimensión de Tiempo). 1. Abra el diálogo Editor de Script desde el menú o la barra de

herramientas. 2. Sitúe la sentencia de carga de la tabla Orders en la pestaña

Principal.



3. Cree un nuevo campo (Rolling Month ) en la sentencia Load de la tabla Orders, tal como se indica:

date(monthstart(OrderDate),'MMM-YYYY') as [Rolling Month],

La función monthstart devuelve el primer día del mes del valor OrderDate. La función date a continuación da formato a este valor con un nombre de mes compuesto de tres caracteres, seguidos de un año con cuatro dígitos. Dado que QlikView almacena este campo como una cadena de texto (en el formato que acabamos de detallar) y también como cadena numérica, puede ser ordenado numéricamente, como cabría esperar. Se analizarán más funciones de formato en un capítulo posterior.

4. La sentencia de carga completa de la tabla Orders debiera presentar ahora el siguiente aspecto. Asegúrese de que su script coincida con esto:

Orders: Load CustomerID, EmployeeID, EmployeeID as EmployeeSales, Freight, OrderDate, OrderDate as CountOrderDate, Year(OrderDate) as Year, Month(OrderDate) as Month, date(monthstart(OrderDate),'MMM-YYYY') as [Rolling Month], applymap('Quarters_Map',num(Month(OrderDate))) as Quarter, Day(OrderDate) as Day, OrderID, ShipperID; SQL SELECT * FROM Orders;

5. Pulse Aceptar y guarde a continuación su archivo. Ejecute el script.

6. Ahora, reemplace la dimensión Month en el gráfico de la tabla

pivotante que creó en el segundo grupo de ejercicios con el campo Rolling Month. Tendrá que definir de nuevo las propiedades de este campo tal y como se definieron para Month.

Consejo: Para una información más detallada acerca de la utilización de los datos de dimensión de tiempo en documentos QlikView, por favor consulte el módulo de formación Time Dimension (Dimensión de Tiempo).



16. Tabla cruzada y Carga Genérica Todos los datos que hemos cargado hasta ahora presentaban una estructura razonable, y pueden ser cargados mediante sentencias select o load estándar. Sin embargo, no todos los datos vienen con un formato favorable a una carga QlikView. En esta sección se exploran algunas opciones adicionales disponibles en QlikView para cargar formatos de datos no estándar. En el directorio DataSources encontrará un archivo Excel (Budget.xls) con datos financieros. Este archivo presenta datos en dos hojas. La primera es muy sencilla de cargar en QlikView, sin necesidad de manipulación alguna. La segunda, en cambio, contiene datos que se encontrarían habitualmenete en cualquier organización, pero presentan un formato para su visualización y no necesariamente para una carga QlikView. Ambas hojas incluyen campos que suministran costes de presupuestos e ingresos así como el resultado real en un cierto número de años recientes. Queremos cargar los datos en la Hoja2 empleando las técnicas de Tabla Cruzada y Carga Genérica.

16.1. Tabla Cruzada Eche un vistazo al archivo Excel de presupuestos antes de cargar los datos. Los datos contenidos en la hoja2 están en un formato de tabla cruzada, lo cual quiere decir que se trata de una matriz de valores entre dos listas de datos de cabecera. 1. Abra el archivo Budget.xls que se halla en el directorio

DataSources. Visualice la Hoja2. Este formato de datos presenta unos cuantos desafíos, pero por lo menos debería percatarse de que una carga regular en QlikView produciría campos para cada Año, en vez de valores anuales en un único campo Año, como nos gustaría que apareciera en nuestro documento QlikView.



Figura 25. Hoja de cálculo con datos del presupuesto en la Hoja2 2. Cierre el archivo Excel y retorne a QlikView. 3. Abra el diálogo Editor de Script. 4. Añada una nueva pestaña en el script haciendo clic en el icono

Añadir Nueva Pestaña o selecionando Añadir Pestaña… desde el elemento de menú Pestaña. Nombre la nueva pestaña: Budget/ Actual.

5. Primero, haremos uso del Asistente para Tablas para abrir el archivo

Budget.xls situado en el directorio Datasources.



Figura 26. Hoja de cálculo Presupuesto en el Asistente para Tablas

Seleccione la Hoja2 en Tabla (Table). Observe que hay una línea de cabecera extra en estos datos, así pues necesitamos incrementar el Tamaño de Cabecera para poder leer las Etiquetas de columna correctamente. Modifique este valor de 0 a 1 en Fila (Row).

6. A continuación, necesitamos rellenar las celdas vacías de Office

para que todos los datos se conecten como es debido. Haga clic en el botón Transformar… en el diálogo Asistente para Tablas. Elija la hoja Rellenar, y pulse el botón Rellenar… Verifique que la Columna Destino esté en 1, y pulse el botón Condición de Celda… Verifique que el Valor de Celda está vacío, y pulse Aceptar. Haga clic en Aceptar, en el diálogo Rellenar Celdas, y pulse Aceptar en el diálogo Rellenar.

Figura 27. Asistente de Tablas Transformar…. el diálogo Rellenar



7. Cuando vuelva al diálogo Asistente para Tablas, notará que las

celdas de la columna Office están ahora todas rellenas con valores.

8. A continuación, necesitamos especificar que estos datos están en un formato de tabla cruzado. Haga clic en Siguiente… para abrir el diálogo Asistente para Tablas: Avanzado. Aquí, pulse el botón Tabla cruzada… en Opciones.

9. A continuación se le pedirán los campos a importar. Un campo a

importar es simplemente un campo normal, con valores de datos en una columna. Un campo a importar no se modificará en una carga de tabla cruzada. En este caso, los campos Office y Metric son ambos campos a importar. En la carga de tabla cruzada, todos los campos a importar deben estar colocados antes de los campos de datos y atributos. Responda No cuando se le pida 2001 como campo a importar. Introduzca AñodePresupuesto como nombre del campo atributo. Introduzca Cantidad como nombre del campo de datos.

Figura 28. Opción de Tabla cruzada completa 10. Haga clic en Finalizar…para cerrar el cuadro de diálogo.

Ahora debería poder ver la sentencia de carga de la tabla cruzada en su script. Elimine la sentencia del Directorio e introduzca el nombre de tabla Budget_Actual_S1 antes de load. También puede ser que desee eliminar los nombres de campo y reemplazarlos por un “*”. Esto permitirá al script leer esta hoja de cálculo incluso cuando los valores de Year cambien. Su script debería presentar ahora el siguiente aspecto: /* Budget Actual crosstable load comments */ Budget_Actual_S1: CROSSTABLE(BudgetYear, Amount, 2) Load



* FROM Datasources\Budget.xls (biff, header is line, embedded labels, table is [Sheet2$], filters( Replace(1, top, StrCnd(null)) )); 11. Pulse Aceptar y guarde a continuación el archivo. Ejecute el script.

12. Cree una nueva hoja, haciendo clic en el botón Añadir Hoja , en la barra de herramientas Diseño, o seleccionando Añadir Hoja en el menú Diseño.

13. Haga clic con el botón derecho en la nueva hoja y seleccione

Propiedades. Introduzca como Título de la hoja: Budget/Actual en la pestaña General.

14. En la pestaña Campos, seleccione la tabla Budget_ Actual_S1 e

incluya todos los campos desde esta tabla. Observe que el campo Cantidad contiene todos los valores de las cantidades Presupuesto (Budget) y Real (Actual), pero preferiríamos tener estos valores por separado, en campos diferentes. Para hacerlo, necesitaremos implementar otro tipo de carga más para estos datos.

16.2. Generic Load (Carga Genérica) Un conjunto de datos genéricos es aquel en el que los nombres de campo se almacenan como valores de campo en una columna, mientras que los valores mismos de campo se almacenan en una segunda columna. En nuestro caso concreto tenemos el campo Metric (una columna), que contiene los nombres de los campos que necesitamos, y el campo Cantidad (otra columna), que contiene todos los valores de los campos individuales. Una manera de transformar estos datos en campos diferenciados, con todos sus valores, es emplear una sentencia Generic Load. Si piensa en una tabla cruzada como en unos datos que tienen valores a modo de campos, entonces una tabla genérica tendría los campos a modo de valores. Hemos visto ya cómo cambiar los datos de una tabla cruzada a datos estándar. Ahora veremos cómo pasar los datos genéricos a datos estándar. 1. Abra el diálogo Editor de Script desde el menú o la barra de

herramientas. 2. Sitúe el cursor en la parte inferior de la pestaña Budget/Actual, e

incluya la siguiente sentencia en su script:



/* Budget Actual generic load comments */ Budget_Actual: Generic Load Office, BudgetYear, Metric, Amount Resident Budget_Actual_S1; DROP TABLE Budget_Actual_S1; Tenga en cuenta que el orden de los campos en una Carga Genérica es sumamente importante, ya que los últimos dos campos listados se emplearán como nombres de campo y campos de valores, respectivamente. 3. Pulse Aceptar y a continuación guarde el archivo. Ejecute el script.

4. Ahora puede añadir los campos Actual cost, Actual rev., Budget cost y Budget rev. a su diseño.

El inconveniente de utilizar una Generic Load reside en que por lo general produce claves sintéticas (claves múltiples comunes entre las tablas). Puede verlo utilizando el Visor de Tablas. Otra de sus limitaciones es que las tablas genéricas resultantes no pueden ser concatenadas.



17. Include Es posible incluir archivos en el script que contengan script o partes de un script. Ahora veremos cómo se hace esto y cómo podemos hacer uso de aplicaciones más avanzadas con este fin, sin tener que escribir nada directamente en el script. Primero echemos un vistazo a lo que vamos a incluir en el script. Abra el archivo de texto Email.txt, situado en el directorio Datasources empleando para ello el Bloc de notas, o una herramienta similar. Este archivo contiene el siguiente script. Rem *** creates e-mail address; LOAD EmpID as EmployeeID, IF((ord("First Name") >= 65 AND ord("First Name") <= 90), chr(ord("First Name")+32), IF((Left("First Name",1)='Ä' OR Left("First Name",1)='ä'), chr(97), IF((Left("First Name",1)='Å' OR Left("First Name",1)='å'), chr(97), IF((Left("First Name",1)='Ö' OR Left("First Name",1)='ö'), chr(111),Left("First Name",1)))))& IF((ord("Last Name") >= 65 AND ord("Last Name") <= 90), chr(ord("Last Name")+32), IF((Left("Last Name",1)='Ä' OR Left("First Name",1)='ä'), chr(97), IF((Left("Last Name",1)='Å' OR Left("First Name",1)='å'), chr(97), IF((Left("Last Name",1)='Ö' OR Left("First Name",1)='ö'), chr(111), Left("Last Name",1)))))& IF((ord(Right("Last Name",1)) >= 65 AND ord(Right("Last Name",1)) <= 90), chr(Right("Last Name",1))+32, IF((Right("Last Name",1)='Ä' OR Left("First Name",1)='ä'), chr(97), IF((Right("Last Name",1)='Å' OR Left("First Name",1)='å'), chr(97), IF((Right("Last Name",1)='Ö' OR Left("First Name",1)='ö'), chr(111), Right("Last Name",1)))))& '@'& IF(Office=1,'stockholm.se', IF(Office=2,'lund.se', IF(Office=3,'paris.fr', IF(Office=4,'nice.fr','seattle.com')))) as "e-mail" FROM datasources\empoff.xls(ansi, biff, embedded labels, table is [Employee$]); Este es un ejemplo de sentencia load bastante complicada, porque se basa principalmente en sentencias if anidadas. En este caso, queremos crear direcciones de correo electrónico desde la información contenida en nuestra base de datos. Muchas condiciones han de ser satisfechas, lo



cual lleva a una sentencia load compleja, que genera una nueva tabla lógica con dos campos. Cargaremos EmployeeID y el nuevo campo e-mail, dándonos el primero de ellos el enlace con el resto de la estructura. La sentencia load crea una firma compuesta por la primera letra del primer nombre, y la primera y última letras del último nombre. También asegura que no haya letras mayúsculas en la firma, sólo minúsculas. Las letras extranjeras (del Sueco), por ejemplo å, Å, ä, Ä, ö y Ö también se eliminan. Siguiendo a la firma se inserta @, seguido de la dirección apropiada del servidor. Esta última vendrá determinada por la oficina en la que trabajen los empleados. Ahora incluiremos el archivo externo en nuestro script de carga. 1. Abra el diálogo Editor de Script desde el menú o la barra de

herramientas. 2. Sitúe el cursor en la parte inferior de la pestaña Principal.

3. Seleccione Include desde el comando de menú Editar.

4. Navegue hasta el archivo Email.txt situado en el directorio

Datasources, pulse Abrir. La siguiente línea se añadirá a su script: $(Include=datasources\Email.txt) Merece la pena reseñar que no existe punto y coma tras la sentencia, pero puede haber uno o más situados dentro del archivo de texto incluido. 5. Pulse Aceptar y guarde el documento QlikView. 6. Ejecute el script. 7. Añada una nueva hoja al diseño y nómbrela Employees. Añada el

nuevo campo e-mail como un cuadro de lista.

Por supuesto, cualquier parte o incluso el script completo puede emplazarse en un archivo Include externo. También podemos tener múltiples archivos Include en un script.



18. Archivos de Datos QlikView: Archivos QVD

Uno de los cambios que más notablemente han afectado a la escritura de script en QlikView ha sido la introducción de los archivos de Datos QlikView (QlikView Data = QVD). Un archivo QVD contiene una tabla de datos exportados desde QlikView. QVD es por tanto el formato propio, o nativo, de QlikView. Sólo puede leerse y escribirse desde QlikView. El formato de archivo está optimizado en su velocidad de lectura, para poder leer datos con suma rapidez desde un script QlikView, siendo al mismo tiempo muy compacto. Leer datos desde un archivo QVD es normalmente entre 10-100 veces más rápido que leer desde otras fuentes de datos.

18.1. El formato de archivo QVD Un archivo QVD contiene exactamente una tabla. Conceptualmente es muy similar a cualquier otro tipo de archivo estándar (csv, dif, biff o fix). Un archivo QVD consta de tres partes:

1. Una cabecera XML bien constituida (con juego de caracteres UTF-8) que describe los campos de la tabla, el diseño de la información subsiguiente, así como algunos otros metadatos.

2. Tablas de símbolos en un formato de bits. 3. Datos reales de la tabla en formato de bits.

18.2. ¿Para qué sirven los archivos QVD? Los archivos QVD se pueden emplear con muy diversa finalidad. Podemos identificar claramente al menos cuatro usos fundamentales. En muchos casos se aplicarán dos o más de ellos al mismo tiempo. Se trata de los siguientes:

Incremento de la velocidad de carga - Mediante el envío a buffers de las partes que no cambian, o cambian muy lentamente, de los datos de entrada de los archivos QVD, podemos acelerar considerablemente la ejecución de script en caso de tener grandes conjuntos de datos. Para conjuntos de datos de gran tamaño será por tanto mucho más fácil cumplir con los límites de tiempo de recarga de las ventanas.Cuando se desarrollan aplicaciones, a menudo es necesario ejecutar el script una y otra vez. Mediante el empleo de buffers QVD en tales ocasiones, los tiempos de espera se pueden reducir considerablemente, incluso en el caso de que el conjunto de datos no fuera tan grande.



Reducción de la carga en los servidores de las bases de datos - Mediante el envío a buffers de las partes que no cambian, o cambian muy lentamente, de los datos de entrada de archivos QVD, podemos reducir enormemente la cantidad de datos obtenidos de fuentes de datos externas. Esto alivia la carga de las bases de datos externas y reduce el tráfico de red. Cuando varios scripts QlikView comparten los mismos datos solo es necesario cargarlos una única vez desde la base de datos fuente. Las restantes aplicaciones pueden hacer uso de los datos de un archivo QVD.

Consolidación de los datos de múltiples aplicaciones QlikView - Se pueden consolidar los datos de múltiples aplicaciones QlikView gracias a los archivos QVD. Con la sentencia de script en binario solo se puede cargar datos de una aplicación a otra. Con los archivos QVD, un script QlikView puede combinar datos de cualquier aplicación QlikView. Esto abre todo un mundo de posibilidades, por ejemplo para aplicaciones que deseen consolidar datos similares procedentes de diversas unidades de negocio, etc.

Carga Incremental - En muchas ocasiones la funcionalidad QVD se puede emplear para facilitar la carga incremental, cargando por ejemplo únicamente los registros nuevos de una base de datos en expansión.

18.3. Creación de archivos QVD Se pueden crear archivos QVD de tres maneras diferentes. En el presente curso exploraremos los dos primeros métodos. 1. Pueden ser explícitamente creados y nombrados desde el script

mediante el comando store. Usted simplemente ha de indicar en el script que desea exportar una tabla anteriormente leída, o parte de ella, a un nombre de archivo explícitamente nombrado en una ubicación de su elección.

2. Se pueden crear y mantener automáticamente desde el script. Con una sentencia load o select precedida del nuevo prefijo buffer, QlikView crea de manera automática un archivo QVD que posteriormente, si se cumplen ciertas condiciones, se utilizará en lugar de la fuente de datos original al recargar los datos. El archivo QVD tendrá un nombre críptico basado en un hash de la sentencia de carga/select y residirá normalmente en una carpeta de datos de la aplicación Windows.

3. Pueden ser explícitamente nombrados y creados desde el diseño o mediante Automatización. Los datos exportados desde el diseño QlikView por medio de comandos GUI o macros de Automatización. En la GUI encontrará QVD como uno de los posibles formatos de exportación bajo el comando Export..., que se halla en el menú de objeto de la mayoría de objetos de hoja.



18.4. Creación manual desde el script Ahora crearemos un archivo QVD en nuestro script de carga mediante una sentencia store. Esta sentencia crea un archivo explícitamente denominado QVD. La sintaxis para la sentencia store es: store [(*|<lista_de_campos>) from] <tabla> into <nombre_de_archivo>; Donde: <tabla> es una tabla con etiqueta de script, ya cargada, residente. <nombre_de_archivo> se interpreta de manera similar a los nombres de las sentencias load, por ejemplo las sentencias directory. Los campos de la <lista de campos > pueden ser renombrados utilizando sintaxis as estándar. 1. Abra el Editor de Script desde el menú o la barra de herramientas. 2. Sitúe la sentencia de carga de la tabla Customers en la pestaña

Principal.

3. Siguiendo a la sentencia de carga de la tabla Customers, añada la sentencia store tal como se indica: store Customers into datasources/customers.qvd;

4. Pulse Aceptar y a continuación guarde el archivo.Ejecute el script.

No notará ningún cambio en la hoja de Sistema de su aplicación. No hay campos nuevos ni tablas lógicas nuevas. La sentencia store que acaba de incluir no tiene efecto alguno en su documento QlikView actual, más que el de ejecutar una sentencia adicional de script. Una vez se haya ejecutado esta sentencia, sin embargo, existe un nuevo archivo de datos que puede ser leído por este documento QlikView, o cualquier documento QlikView que tenga acceso a la carpeta en la que situamos el archivo customers.qvd. Para comprobar esto, vamos a reemplazar de forma temporal la sentencia select Customers por una nueva sentencia load procedente del archivo customers.qvd que acabamos de crear. 5. Abra de nuevo el Editor de Script desde el menú o la barra de

herramientas.

6. Comente la sentencia select Customers que ya está presente y la sentencia store que acabamos de añadir.

7. A continuación, añada una nueva sentencia de carga de Archivos de Tabla empleando el Asistente para Tablas. Sitúe el archivo



customers.qvd en la carpeta Datasources y ábrala.

Figura 29. Asistente para Tablas QVD 8. Compruebe que el Tipo esté bien indicado como QVD. Seleccione

Finalizar para cerrar el diálogo.

9. Puede eliminar la sentencia Directory y añadir la etiqueta de la tabla Customers a la nueva sentencia de carga. Su script tendrá ahora el siguiente aspecto:

Customers: Load Address, City, CompanyName, ContactName, Country, CustomerID, Fax, Phone, PostalCode, StateProvince FROM Datasources\customers.qvd (qvd); 10. Pulse Aceptar y guarde su archivo. Ejecute el script.

Una vez más, no notará cambio alguno en la hoja de su aplicación, ya que no se cambió ninguna tabla, sólo la ubicación y el tipo desde donde se leían los datos. En un entorno normal, usted probablemente notaría una gran diferencia en lo que se tarda en leer la tabla Customer, pero un archivo QVD se lee en QlikView de una manera extremadamente veloz.



Por supuesto, el inconveniente de esta técnica es que cuando los datos de nuestra base de datos Customers cambian, no se registrará en nuestro documento QlikView. Arreglaremos esto en la siguiente sección.

18.5. Creación automática de un archivo QVD en el script

Los archivos QVD también se pueden crear y mantener de manera automática mediante un prefijo buffer. Este prefijo puede utilizarse en la mayoría de sentencias load y select del script. Indica que un archivo QVD se emplea para enviar el resultado de la sentencia a una caché/buffer. Existen ciertas limitaciones, siendo la más notable de ellas que debe haber una carga de archivo, o una sentencia select en “la parte inferior”. El nombre del archivo QVD es un nombre calculado (un hash de 160 bits de sentencia y otra información distintiva, como hexadecimal) y normalmente se almacena en la carpeta DATOS: C:\Document and Settings\%user%\Local Settings\Application Data\QlikTech\QlikView\Buffers

Consejo: Para determinar y/o cambiar dónde debe situar QlikView los archivos buffer QVD, así como las ubicaciones por defecto de las carpetas adicionales, puede marcar Configuración… Preferencias de Usuario… Carpetas. La sintaxis del prefijo es: buffer [(opción [,opción])] load … o buffer [(opción [,opción])] select … donde una opción es cualquiera de lo siguiente:

incremental – permite leer sólo parte de un archivo subyacente. El tamaño previo del archivo se almacena en la cabecera XML, en el archivo QVD. Esto resulta especialmente útil en el caso de archivos de registro. Todos los registros cargados con anterioridad son leídos desde el archivo QVD mientras que los siguientes registros nuevos se leen desde la fuente principal, creándose finalmente un archivo QVD actualizado.

stale (after) amount [ (days | hours) ] – Esto se suele emplear normalmente con fuentes de BD en las que no existe una marca de tiempo (fecha/hora) en los datos originales. En su lugar, uno especifica qué antigüedad puede tener el pantallazo QVD antes de que sea reemplazado por una nueva lectura del archivo fuente o de la base de datos.



A continuación revisaremos nuestra carga de datos de la tabla Customers para emplear el método automático de generación de archivos QVD. Sabemos por nuestro plan de proyecto que los datos de Customers se actualizan semanalmente, así que solo necesitamos leer en los datos actualizados cada 7 días. Cambiaremos por tanto el script para que incluya el prefijo buffer QVD correcto, acorde con nuestra sentencia Customers select original. 1. Abra nuevamente el Editor de Script desde el menú o la barra de

herramientas.

2. Comente la sentencia load de la tabla Customers desde el QVD que añadimos en la sección anterior y elimine el comentario de la sentencia Customers select original.

3. Incluya ahora el prefijo buffer (stale after 7 days) a la sentencia select de Customers. Su script debiera mostrarse así:

Customers: buffer (stale after 7 days) SELECT Address, City, CompanyName, ContactName, Country, CustomerID, Fax, Phone, PostalCode, StateProvince FROM Customers; 4. Pulse Aceptar y guarde su archivo. Ejecute el script Cuando se emplea el prefijo buffer en sentencias load o select, no se necesitan sentencias explícitas para la lectura. QlikView determinará hasta qué punto utilizar los datos del archivo QVD o adquirir los datos mediante la sentencia load o select original. Independientemente del método QVD empleado, cuando no se aplique transformación alguna a los archivos leídos (aparte del renombrado de campos) se empleará el modo de lectura super-rápido (optimizado). Puede ver qué modo qvd se utilizó abriendo el cuadro de diálogo Progreso de Ejecución del Script.

18.6. Funciones de script de archivos QVD Hay varias funciones de script nuevas que han sido añadidas para acceder a los datos que se encuentran en la cabecera XML de un archivo QVD. Estas funciones se describen en la sección Funciones de



Archivo del Manual de Referencia QlikView. Aquí tiene una muestra de las nuevas funciones disponibles: QvdCreateTime( nombredearchivo ) – Devuelve la marca de tiempo de la cabecera XML de un archivo QVD si hubiera alguno (si no, devuelve NULL). QvdNoOfRecords( nombredearchivo ) – Devuelve el número de registros que hay actualmente en un archivo QVD. QvdNoOfFields( nombredearchivo ) – Devuelve el número de campos de un archivo QVD. QvdFieldName( nombredearchivo ) – Devuelve el nombre del campo número field_no, si existe en un archivo QVD (si no, NULL). QvdTableName( nombredearchivo ) – Devuelve el nombre de la tabla contenida en un archivo QVD.



19. Ejercicios

1. Modifique el script en su documento QlikView para emplear una carga qvd buffer en las tablas Orders y Order_Details.

2. Utilice la especificación stale. Consulte el plan de proyecto para determinar con qué frecuencia hay que refrescar estas tablas (es decir, con qué frecuencia se actualizan los datos según las reglas de la organización).



20. Script avanzado – 1ª Parte Dos de los Indicadores de Rendimiento Clave, según el plan de proyecto, requieren que nosotros calculemos el cambio anual de Ventas Netas (NetSales) por Cliente (Customer). Esta sección nos introduce en una serie de técnicas avanzadas de script QlikView, de las cuales podemos beneficiarnos, por ejemplo, para dar solución a esto. Por supuesto, como sucede con la mayoría de los problemas, existen múltiples enfoques para resolver este mismo problema. Este enfoque en particular nos permite explorar los conceptos de:

Unir Agregación Ordenar por Previo (acceder a los datos desde el registro previamente

cargado) Variables

20.1. Unir datos procedentes de múltiples tablas Si queremos comparar las NetSales (Ventas Netas) de un Customer (Cliente) entre dos años pasados, podríamos hacerlo simplemente seleccionando los años de forma individual en la interfaz de la aplicación y comparando los resultados en el gráfico, o incluyendo Year (Año) como una dimensión en un objeto gráfico que calcule NetSales. Esto pudiera bastar para nuestros requisitos, pero para determinar el rendimiento global de Customer, crearemos datos adicionales que describan el rendimiento anual de NetSales por Cliente en el script de carga. Luego podemos utilizar estos datos para determinar los aumentos/descensos por Cliente, así como los porcentajes de variaciones por Cliente en nuestro documento QlikView. Obtenemos el campo calculado NetSales de la tabla Order_Details, pero sólo para un determinado año que se suministra en el campo OrderDate y para un determinado Cliente del campo CustomerID en la tabla Orders. Para usar dos tablas a la vez, como en este caso, debemos comenzar combinándolas en una única tabla. Aquí, Join (Unir) datos entre tablas puede realizarse contrastando con la base de datos fuente o empleando un comando Join (Unir) de QlikView. Como ya tenemos los datos fuente que precisamos cargados en la memoria, usaremos la sentencia QlikView Join Load con estas dos tablas residentes (Order_Details y Orders). Comenzamos añadiendo una nueva pestaña en nuestro script, denominada Sales Change. 6. Abra el Editor de Script.



7. Añada una nueva pestaña al script haciendo clic en el icono Añadir

Nueva Pestaña o seleccionando Añadir Pestaña… desde el elemento de menú Pestaña. Denomine la nueva pestaña con el nombre de Sales Change (Cambios en Ventas).

8. Primero, necesitamos cargar una nueva tabla lógica basada en la

tabla residente Orders. Nombraremos a esta nueva tabla así: OrdersByYear_Source (PedidosPorAño_Fuente)

/* Sales Change Source load comments */ OrdersByYear_Source: Load CustomerID, OrderID, Year RESIDENT Orders Where Year = 2003 or Year = 2004; /*only load 2 years*/ Cargamos los campos CustomerID y Year para agrupar (agregar) los datos. El campo OrderID se usará para enlazar con la tabla Orders_Detail cuando enlacemos (Join) con dicha tabla. La cláusula Where limitará los datos a los años de pedidos 2003 and 2004 exclusivamente. A continuación, añadimos los datos de NetSales a esta tabla mediante un Join Load. 9. Incluya la siguiente sentencia en su script: Left Join (OrdersByYear_Source) Load OrderID, NetSales RESIDENT OrderDetails; Aquí empleamos una carga Left Join porque sólo queremos enlazar los pedidos cargados basados en la cláusula Where que especificamos en la carga anterior. Necesitamos asegurarnos de que el campo OrderID esté incluido en esta carga para que entronque con los registros de la tabla OrdersByYear_Source con la que estamos enlazando. En QlikView, el comportamiento de unión establecido por defecto es una unión externa completa (“a full outer join”). Por lo tanto, si no hay campos que se correspondan entre las dos tablas unidas, obtendrá un producto Cartesiano de los registros. Puesto que estamos especificando OrderID en ambas tablas, y estamos especificando Left, sólo los registros que se correspondan con OrderID incluidos en la tabla OrdersByYear_Source serán incluidos. Metemos el campo NetSales porque eso es



precisamente lo que queremos incluir en la tabla OrdersByYear_Source que estamos creando. 10. Pulse Aceptar y guarde el documento QlikView.

11. Ejecute el script.

12. Añada una nueva hoja al diseño y denomínela Sales Change. Añada

todos los campos de la tabla OrdersByYear_Source. Observe que todos estos campos son campos clave. ¿Sabría explicar por qué?

20.2. Agregar datos Para agrupar o agregar datos, emplearemos la cláusula Group by (Agrupar por) de la sentencia Load. En este caso, necesitamos agregar los datos de la tabla OrdersByYear_Source por CustomerID y Year. 1. Abra el diálogo Editor de Script.

2. Añada la siguiente sentencia en su script: /* Aggregation by Customer comments */ OrdersByYear: Load CustomerID, Year, sum(NetSales) as NetSalesByYear RESIDENT OrdersByYear_Source Group by CustomerID,Year; Observe la función de agregación sum(NetSales) incluida en esta sentencia. Esta función será evaluada por encima de todas las combinaciones posibles de los demás campos den la sentencia Load (CustomerID y Year). Normalmente, siempre agrupará con Group by los campos de Load que no sean campos de agregación. Este campo recibe un nombre nuevo para diferenciarlo de NetSales. Los campos CustomerID y Year se emplearán como campos Clave (aunque en la próxima sección eliminaremos el campo Year.

Consejo: Para una información adicional acerca de las funciones de agregación disponibles en el script de carga, consulte por favor el Manual de Referencia QlikView. 3. También podemos prescindir (Drop) de la tabla temporal que

utilizamos para la unión, dado que no la necesitaremos más:



DROP TABLE OrdersByYear_Source;

4. Pulse Aceptar y guarde el documento QlikView. 5. Ejecute el script. 6. Añada el campo NetSalesByYear a la hoja Sales Change. Observe

que si selecciona un CustomerID, generalmente verá dos valores asociados en este nuevo campo (los dos años de NetSales agregados a cada año).

20.3. Cómo calcular los datos entre registros Para calcular la variación anual para cada Cliente (Customer), podemos cargar estos datos de nuevo, empleando una cláusula Order by (Ordenar por) que ordene los registros adecuadamente, y una función Previous para acceder a los datos desde el registro anterior. 1. Abra el diálogo Editor de Script.

2. Incluya la siguiente sentencia en su script al final de la pestaña Sales

Change: /* Sales Change by Customer comments */ Sales_Change: Load CustomerID, NetSalesByYear, If(CustomerID = Previous(CustomerID), If(NetSalesByYear > Previous(NetSalesByYear),

'UP','DOWN'),null()) as SalesChangeIndicator, If(CustomerID = Previous(CustomerID), NetSalesByYear - Previous(NetSalesByYear),

null()) as SalesChangeAmt RESIDENT OrdersByYear Order by CustomerID,Year; Primero, observe la cláusula Order by al final de la sentencia. Esto asegurará que los registros se ordenen como es debido: por CustomerID y Year. El criterio de ordenación establecido por defecto que emplea QlikView es ascendente, de modo que el registro del año 2003 de un cliente (si es que existe) será el primero en cargarse. Ahora observe la primera función If empleada para el campo SalesChangeIndicator. Este es un If anidado, con el formato:

If(<condition>, [If(<condition>, then, else)], else) La primera <condición>: CustomerID = Previous (CustomerID) comparará el valor actual de registro del campo CustomerID con el registro previo de entrada que no haya sido descartado por una cláusula



where. En otras palabras, esta condición comprueba si ambos registros son para el mismo Cliente (Customer). La segunda <condición>: NetSalesByYear > Previous(NetSalesByYear) comparará el valor actual de registro del campo NetSalesByYear con el valor de entrada previamente registrado para NetSalesByYear. Así pues, si el Cliente (Customer) es el mismo, y el campo NetSalesByYear es mayor en 2004 que en 2003, el resultado en el campo SalesChangeIndicator será “ARRIBA”. Si el CustomerID no es el mismo, a este campo se le asignará el valor de nulo(). El campo SalesChangeAmount utiliza una función If similar, aunque no es un If anidado. En este caso, si el Cliente (Customer) es el mismo entre registros, calculará la diferencia entre NetSalesByYear en 2004 y NetSalesByYear en 2003, si no, el campo aparecerá como nulo(). 7. También podemos prescindir (Drop) de la tabla temporal que

utilizamos para la unión, dado que no la necesitaremos más: DROP TABLE OrdersByYear;

8. Pulse Aceptar y guarde el documento QlikView. 9. Ejecute el script. 10. Añada los camposSalesChangeIndicator y SalesChangeAmount a la

hoja Sales Change. Puede que necesite stablecer el formato Numérico del campo SalesChangeAmount en 2 decimales mediante el diálogo Configuración… Propiedades de Documento… Número.

También observará que el campo NetSalesByYear ya no es relevante, puesto que ya no conecta con los datos de Year. Incluimos este campo en nuestra tabla final Sales_Change por claridad (porque técnicamente no es algo necesario para QlikView), pero no necesitaremos este campo una vez que la carga esté completa. Podemos por lo tanto prescindir (Drop) del campo, empleando la sentencia Drop Field. DROP FIELD NetSalesByYear; 11. Pulse Aceptar y guarde el documento QlikView. 12. Ejecute el script. El campo NetSalesByYear no debería verse ahora ya como disponible.

20.4. Utilización de las variables en el script Es importante diseñar sus scripts de carga QlikView de modo que sean flexibles y fáciles de mantener. Una de las maneras de contribuir a



lograr este objetivo es utilizando variables de script. Las variables pueden establecerse en una constante numérica o de cadena de texto, o pueden asignarse a un valor mediante una expresión evaluada. Utilice la sentencia SET para asignar un valor constante, y la sentencia LET para asignar un valor a través de una expresión evaluada. También es una buena idea nombrar variables de forma única (exclusivas) para que se puedan identificar fácilmente en el documento QlikView. Las variables definidas en el script de carga están disponibles en la interfaz del documento. En este caso, vamos a asignar un valor al año en curso para una comparación de las Ventas Netas (NetSales). Previamente fijamos este valor de forma invariable en 2004, en el script. Primero, asignaremos un valor constante a la variable, y a continuación lo modificaremos para que se base de una forma dinámica en la fecha del sistema actual. 1. Abra el diálogo Editor de Script. 2. Sitúe el cursor en la pestaña Principal en la parte superior. Añada

una nueva sentencia SET que defina nuestra variable. Por lo general, debería asignar siempre variables al comienzo del script de carga, de modo que estén disponibles a lo largo del script. SET vCurrentFullYear = 2004;

3. Ahora, muévase a la pestaña Sales Change. Necesitamos editar la

cláusula Where para la tabla OrdersByYear_Source. Modifique esto de la siguiente manera:

/* Sales Change Source load comments */ OrdersByYear_Source: Load CustomerID, OrderID, Year RESIDENT Orders Where Year = $(vCurrentFullYear) - 1 or Year = $(vCurrentFullYear); /*only load 2 years*/ QlikView sustituirá el valor de vCurrentFullYear en la sentencia de script cuando éste se ejecute. En nuestro caso, el valor será 2004. 4. Pulse Aceptar y guarde el documento QlikView. 5. Ejecute el script. No deberían producirse más cambios en los valores de campo tras haberse ejecutado el nuevo script.



Esto funcionará bien hasta el próximo año. En lugar de requerir un cambio de script cada año, a fin de mantener esta variable, podemos asignar un valor a la misma empleando el sistema de fecha como entrada de datos. Como esta asignación requerirá una evaluación de la expresión, necesitaremos cambiar nuestra sentencia SET por una LET. 6. Abra el diálogo Editor de Script. 7. Sitúe el cursor en la parte superior de la pestaña Principal.

Modifique la sentencia SET (para que defina nuestra variable vCurrentFullYear) a una sentencia LET, como se indica: LET vCurrentFullYear = Year(today()) - 1;

Esta sentencia evaluará el año de la fecha de hoy (la fecha de ejecución del script), y restará 1 para obtener el año completo actual. 8. Pulse Aceptar y guarde el documento QlikView. 9. Ejecute el script. No deberían producirse más cambios en los valores de campo tras haberse ejecutado el nuevo script.



21. Ejercicios En este ejercicio nos vamos a tomar un respiro en cuanto a escritura de script y vamos a crear una tabla simple utilizando campos de la tabla Sales_Change que cargamos en la sección anterior. La tabla simple incorporará gráficos QlikView para suministrar una pista visual que indique la dirección de los cambios (hacia arriba o hacia abajo).

1. En la hoja de Sales Change (Cambios en las Ventas) que se añadió recientemente a la interfaz del documento, elija Diseño… Nuevo Objeto de Hoja… Gráfico. Introduzca Net Sales Change by Customer (o Cambios en las Ventas por Cliente) como Título de la Ventana. Seleccione Tabla Simple en el Tipo de Gráfico y añada el campo CompanyName como única Dimensión. Nombre la dimensión como Customer.

2. Añada una expresión NetSales [sum(NetSales)].

3. Añada otra expresión tal y como se indica a continuación:

If(SalesChangeIndicator = 'UP','qmem://<bundled>/BuiltIn/arrow_n_g.png',

If(SalesChangeIndicator = 'DOWN','qmem://<bundled>/BuiltIn/arrow_s_r.png',

'qmem://<bundled>/BuiltIn/cross.png'))

Consejo: Utilice la sección Imágenes del diálogo Editar Expresión para pegar la función qmem QlikView con el gráfico más apropiado. Etiquete esta expresión con una cadena dinámica, incluyendo los años de comparación de Sales Change. Pista: utilice la variable vCurrentFullYear que ya creamos en el script de carga.

4. Con un poco de formato, su nuevo objeto de gráfico debería mostrar más o menos el aspecto que puede ver en la página siguiente. Si ve la función qmem en lugar del gráfico listado en la columna Sales Change, asegúrese de especificar Imágen como Representación y Mantener Aspecto como Formato de Imagen para la expresión Sales Change.



Figura 30. Gráfico Sales Change, una Tabla Simple



22. Script avanzado – 2ª Parte Otra forma de unir datos procedentes de múltiples tablas es empleando concatenación.

22.1. Concatenación

Concatenación automática Si los nombres de campo y el número de campos de dos o más tablas cargadas son exactamente iguales, QlikView automáticamente concatenará los resultados de las distintas sentencias load o select en una tabla. Ejemplo: load a, b, c from table1.csv; load a, c, b from table2,csv; La tabla lógica resultante tiene los campos a, b & c. El número de registros es la suma de los números de registros de la tabla 1 y la tabla 2. Reglas:

El número y los nombres de los campos deben ser exactamente iguales.

El orden de los campos listados en cada sentencia es arbitrario. El orden de las dos sentencias es arbitrario.

Concatenación forzada Si dos o más tablas no tienen exactamente el mismo conjunto de campos, aún es posible obligar a QlikView a concatenar las dos tablas. Esto se realia mediante el prefijo concatenate en el script, el cual concatena una tabla con otra nombrada o con la tabla lógica creada en último lugar. Ejemplo: load a, b, c from table1.csv; concatenate load a, c from table2,csv;



La tabla lógica resultante tiene los campos a, b & c. El número de registros en la tabla resultante es la suma de los números de registros de la tabla 1 y la tabla 2. El valor del campo b en los registros provenientes de la tabla 2 es NULO. Reglas:

Los nombres de los campos deben ser exactamente iguales. El orden de los campos listados en cada sentencia es arbitrario. A menos que se especifique el nombre de una tabla cargada

anteriormente en la sentencia concatenate el prefijo concatenate utilizará la última tabla lógica creada con anterioridad. El orden de las dos sentencias por tanto no es arbitrario.

Impedir la concatenación Si dos tablas poseen el mismo conjunto de campos y por tanto se concatenarían normalmente de forma automática, puede evitar la concatenación mediante el prefijo noconcatenate. Esta sentencia impide la concatenación con cualquier otra tabla lógica existente que tenga los mismos campos. La sintaxis es: noconcatenate ( loadstatement | selectstatement ) Ejemplo: Load A,B from file1.csv; Noconcatenate load A,B from file2.csv;

Ejemplo En nuestros datos, se nos ha suministrado un conjunto adicional de empleados nuevos que aún no están contenidos en el archivo EmpOff.xls. Para incluir estos datos, necesitamos modificar nuestro script de carga. 1. Abra el Editor de Script. 2. Sitúe el cursor en la pestaña Principal, después de haber cargado la

tabla Employee necesitamos duplicar los campos que tenemos actualmente para Employee, así que no usaremos el Asistente para Tablas en este caso. En su lugar, copie la sentencia load Employee, y pegue el texto copiado tras el texto original.

3. Dado que el nuevo formato de datos del archivo encaja con nuestro

primer archivo, solo necesitamos cambiar la fuente de los datos.



Revise la cláusula From en la nueva sentencia load para que diga lo siguiente:

FROM Datasources\Employees_New.xls (biff, embedded labels, table is [Employee$]); 4. Pulse Aceptar y guarde el documento QlikView.

5. Ejecute el script.

Si observa varias Claves Sintéticas nuevas, o un nuevo valor $Table de Employee-1, puede estar seguro de que algo no funcionó correctamente en la concatenación automática.

6. Puede ahorrarse bastantes problemas con la concatenación automática empleando el prefijo concatenate en las sentencias load que sepa que deberían ir concatenadas. Añada el prefijo concatenate a la nueva sentencia Employee load y especifique la tabla Employee. Esto siempre concatenará estas dos tablas juntas, incluso si se realizasen cambios posteriores de forma inadvertida en una de las cargas pero no en la otra. La nueva sentencia de carga de Employee comenzaría ahora de la siguiente manera: concatenate (Employee) Load

7. Puede que se haya percatado de que existen escasas diferencias entre nuestras dos sentencias de Employee load. De hecho, podemos utilizar otra función QlikView que cargue los mismos datos en una sola sentencia load. Empleando una especificación comodín en el nombre de archivo From, QlikView automáticamente cargará desde todos los archivos que coincidan con tal especificación y concatenará los datos en una única tabla lógica para usted. Dado que ambos de nuestros nombres de archivo comienzan por “Emp” y tienen la extensión de archivo “.xls”, podemos emplear el comodín “Emp*.xls” en la cláusula From. Si hacemos este cambio, y comentamos la segunda sentencia de Employee load, el script debería verse ahora así:

Employee: Load EmpID as EmployeeID, [First Name] & ' ' & [Last Name] as Name, [Last Name], [First Name], Title, [Hire Date], Year([Hire Date]) as [Employee Hire Year], Office, Extension, [Reports To], [Year Salary] FROM Datasources\Emp*.xls (biff, embedded labels, table is [Employee$]);



REM Employee: concatenate (Employee) Load EmpID as EmployeeID, [First Name] & ' ' & [Last Name] as Name, [Last Name], [First Name], Title, [Hire Date], Year([Hire Date]) as [Employee Hire Year], Office, Extension, [Reports To], [Year Salary] FROM Datasources\Employees_New.xls (biff, embedded labels, table is [Employee$]);

8. Guarde el script una vez revisado, así como el documento QlikView. A continuación ejecute el script y verifique que los datos de Employee no hayan cambiado.

9. Como ejercicio opcional, puede que quiera tratar de determinar por qué a los empleados listados en el archivo Employees_New.xls no se les asignó dirección de correo electrónico (el campo e-mail es nulo para estos empleados). ¿Qué necesita para corregir este problema?



23. Seguridad La seguridad informática es un elemento importante en este curso. Los documentos QlikView a menudo contienen información confidencial y es esencial saber cómo impedir el acceso a usuarios no autorizados.

23.1. Control de accesso Un documento QlikView es un archivo encriptado que consta de una base de datos, un script, un diseño, etc. El formato de archivo en sí mismo puede proporcionar alguna protección intrínseca, ya que no es posible abrir un archivo si no dispone de la aplicación QlikView. También es posible incluir niveles de acceso en el script de carga.

23.2. Niveles de acceso A cada usuario del documento QlikView se le debe asignar un nivel de acceso: ADMINISTRADOR o USUARIO. Un usuario con privilegios de ADMINISTRADOR puede modificar cualquier elemento del documento (sujeto, claro está, a las limitaciones del producto), mientras que una persona con privilegios de USUARIO posee un acceso restringido. Un usuario de QlikView Analyzer+ se verá restringido de manera automática a los privilegios de USUARIO, independientemente de las configuraciones de nivel de acceso. Si no se asigna nivel alguno a un usuario en la sección de acceso, el usuario no podrá abrir el documento QlikView. Para mayor claridad, puede ser útil emplar otros niveles de acceso, por ejemplo NINGUNO. Este siempre recibirá el tratamiento de “ningún acceso”.

23.3. La base de datos de control de acceso Todo el control de acceso está gestionado por medio de archivos de texto, bases de datos o cláusulas inline de la misma manera que los datos se manejan normalmente en QlikView. Las tablas se cargan de la forma habitual, pero en una sección de acceso que se inicia en el script por medio de la sentencia section access.

Consejo: Tenga presente que todos los nombres de campo y valores se convertirán automáticamente a mayúsculas en la sección de acceso. Esto debe ser tenido en cuenta cuando se empleen sentencias de carga residentes o precedentes dentro de la sección de acceso.



Si dicha sección de acceso se declara en el script de carga, la parte del script que carga los datos estándar debe ir precedida por la sentencia section application. Hay una serie de nombres de campo protegidos en la base de datos de control de acceso, incluyendo: USERID, PASSWORD, SERIAL, NTNAME, NTDOMAINSID, NTSID, y ACCESS. Se pueden añadir otros campos definidos por el usuario, por ejemplo GRUPO o DEPARTAMENTO, para facilitar la reducción dinámica de datos o la administración, pero QlikView no utiliza los campos extra para limitar el acceso al documento. En la sección de acceso se pueden cargar ninguna, todas o cualquier combinación de los campos de seguridad. Si no se carga ninguno de los campos de seguridad, entonces todos los usuarios tendrán derechos de ADMINISTRADOR. Por lo tanto no es necesario emplear un IDdeUsuario – se puede hacer una comprobación en SERIAL (Nº de Serie) únicamente, por ejemplo. Este hecho puede ser aprovechado para las recargas de líneas de comandos de documentos de acceso restringido.

ACCESS Un campo que define el acceso que debiera tener el usuario.

USERID Un campo con un ID de usuario que tiene el privilegio especificado en el campo ACCESS.

PASSWORD Un campo que debiera contener una contraseña aceptada.

SERIAL Un campo que debiera contener un número correspondiente al número de serie QlikView. Ejemplo: 4900 2394 7113 7304

NTNAME Un campo que debiera contener una cadena correspondiente a un nombre de usuario o nombre de grupo de un Dominio Windows NT.

NTDOMAINSID Un campo que debiera contener una cadena que se corresponda con un SID de Dominio deWindows NT. Ejemplo: S-1-5-21-125976590-467238106-1092489882

NTSID Un campo que debiera contener un SID Windows NT. Ejemplo: S-1-5-21-125976590-467238106-1092489882-1378

QlikView comparará el número de serie de QlikView con el archivo en SERIE, el nombre de usuario o de grupo deWindows NT con NTNAME, el SID de Dominio Windows NT con NTDOMAINSID y el SID de Windows NT con NTSID. Además pedirá el ID de usuario y la contraseña y comparará éstos con los campos USERID y PASSWORD. Si la combinación encontrada de ID de usuario, contraseña y propiedades del entorno se encuentra también en la tabla de la Sección de Acceso, entonces el documento se abre con el correspondiente nivel de acceso. Si no, QlikView denegará el acceso de usuario al documento.



Si el ID de usuario y la contraseña no se introducen correctamente en tres intentos, habrá que repetir de nuevo todo el procedimiento de entrada registrada completo. En dicho procedimiento de entrada registrada, QlikView comprobará primeramente SERIAL, NTNAME, NTDOMAINSID, y NTSID para ver si esta información es suficiente para garantizar al usuario acceso al documento. Si es así, QlikView abrirá el documento sin pedir USERID y PASSWORD. Si sólo se cargan algunos de los campos de acceso, se emplearán los requisitos anteriores que se consideren más apropiados. Todos los campos listados en las sentencias Load o Select en la Sección de Acceso deben estar escritas en MAYÚSCULAS. Cualquier nombre de campo que contenga minúsculas será convertido a mayúsculas en la base de datos antes de ser leído por la sentencia Load o Select. Sin embargo, los campos USERID y PASSWORD introducidos por el usuario final cuando abre los documentos QlikView no son sensibles a mayúsculas/minúsculas.

23.4. Restricciones de acceso heredadas Una sentencia binary hará que la restricción de acceso sea heredada por el nuevo documento QlikView que contiene la sentencia binary. Una persona con derechos de ADMIN a este nuevo documento puede modificar los derechos de acceso del nuevo documento añadiendo una nueva sección de acceso. Una persona con privilegios de USUARIO puede ejecutar el script y modificar el script (añadiendo sus propios datos al archivo cargado con la sentencia binary). Una persona con derechos de USUARIO no puede cambiar los derechos de acceso. Esto hace posible que un administrador de la base de datos pueda controlar el acceso de los usuarios, incluyendo el de aquellos que comienzan con una sentencia binary.

23.5. Sección de acceso en el script Ahora incluiremos las líneas necesarias en nuestro script para comprobar los derechos de acceso de ciertos usuarios. Por lo general es una buena práctica situar el código de la sección de acceso en el área de “script oculto”.

Script Oculto Un script oculto es un área del script de código que está protegida por contraseña. Siempre se ejecuta antes del script estándar durante una recarga.



Cuando elija Editor de Script oculto del menú Archivo en el diálogo Editor de Script se le pedirá que introduzca una contraseña, la cual se requerirá de nuevo antes de darle acceso al script oculto. Si es la primera vez que accede al script oculto de un documento (creando con ello uno, por tanto), tendrá que confirmar la nueva contraseña. Tras esto, la pestaña de Script oculto aparecerá a la izquierda de todas las demás pestañas de script y permanecerá ahí hasta que cierre el documento. Tenga en cuenta los siguientes aspectos de los scripts ocultos, si elige utilizarlos:

Si emplea un script oculto, el comando binary no puede utilizarse en el script normal, ya que debe ser la primera sentencia ejecutada en un script de documento.

Las tablas generadas por la parte oculta del script no se representarán por nombre en el campo de sistema $Table.

El diálogo Progreso de Ejecución del Script no se actualizará durante la ejecución de un script oculto. No habrá entradas al archivo de registro, si se utiliza. Tenga en cuenta que en la versión 7 de QlikView hay disponible una anulación del automatismo de Seguridad de Documento que permite Mostrar Progreso de Script Oculto. La información de progreso también se escribirá en el archivo de registro de ejecución de script, si procede.

Si el script oculto contiene una Sección de Acceso, dicha sección no se permitirá en el script normal ni en un script que comience con una carga binaria del archivo QlikView que contenga el script oculto.

Adición de la Sección de Acceso A continuación añadiremos una sección de acceso básica en el área de script oculto de nuestro documento QlikView. 1. Abra el Editor de Script desde el menú o la barra de herramientas. 2. Añada un script oculto seleccionando Archivo… Editor de Script

oculto… Use qlikview como contraseña para el script oculto. A continuación, incluya las siguientes líneas de script:

/* SECURITY section access comments */ Section Access; Access01: Load * Inline [USERID, PASSWORD, ACCESS Demo, User, User Demo, Admin, Admin]; Section Application;



Consejo: ES NECESARIO QUE INCLUYA LA SENTENCIA Section Application TRAS LA CARGA DE ACCESO PARA PRODUCIR UN DOCUMENTO UTILIZABLE.

Esta simple comprobación de acceso requerirá que el usuario se identifique cuando abra un documento. La Demo de USERID y la CONTRASEÑA de Usuario impedirán que el usuario acceda al script de carga si tal requisito de seguridad estuviera contemplado en las Propiedades de Documento. Un usuario perteneciente al grupo USER tampoco tendrá acceso a la pestaña Seguridad de los diálogos Propiedades de Documento y Propiedades de Hoja. También tenga en cuenta que si utiliza QlikView Analyzer+ éste se abrirá automáticamente en modo de USUARIO, independientemente de cuáles sean las configuraciones de la Sección de Acceso. La Demo de USERID junto con la CONTRASEÑA de Admin otorgarán al usuario los derechos de realización de todo tipo de cambios en el documento, en QlikView Enterprise.

Consejo: SE RECOMIENDA ENCARECIDAMENTE GUARDAR UN DOCUMENTO CON SECCIÓN DE ACCESO COMO ARCHIVO NUEVO, CON UN NUEVO NOMBRE, TRAS EJECUTAR EL SCRIPT, PERO ANTES DE INTENTAR CERRAR Y VOLVER A ABRIR EL DOCUMENTO QlikView. SI TIENE ERRORES LÓGICOS EN LA SECCIÓN DE ACCESO, PUEDE QUE YA NO SEA POSIBLE ABRIR EL DOCUMENTO DE NUEVO UNA VEZ QUE HAYA SIDO CARGADO.

3. Pulse Aceptar. 4. Guarde su archivo, pero NO EJECUTE AÚN EL SCRIPT.

5. En Guardar Como elija un nuevo nombre de archivo (puede añadir

“_seguro” al nombre que ya tiene) y a continuación ejecute el script.

6. Salga de QlikView y abra su documento recién renombrado. Ahora verá el siguiente cuadro de diálogo, en el que puede introducir su ID de Usuario y contraseña.



Figura 31. Cuadro de diálogo en el que se introduce ID de usuario

23.6. Control de acceso para ciertos comandos Los parámetros en las pestañas de Seguridad de los diálogos Propiedades de Documento y Propiedades de Hoja en el menú Configuraciones permiten impedir el acceso a los usuarios, para que no puedan ejecutar determinados comandos de menú ni modificar el diseño. Para poder utilizar estos parámetros de configuración como medidas de seguridad, es importante no obstante, que los usuarios sólo tengan privilegios de USUARIO. Todo el que tenga privilegios de ADMIN puede cambiar las configuraciones de seguridad en cualquier momento.

23.7. Más control de acceso

Es fácil incrementar el control de la seguridad frente a aquellos usuarios que creemos que requerirán acceso a un documento específico. Añadiendo un campo a la tabla inline anteriormente creada, podemos conectarla con una nueva tabla de dos columnas, en la que especificaremos los números de serie que sí tienen acceso al documento. De esta manera, restringimos aún más el acceso a un documento. La nueva tabla de dos columnas se creará en el Bloc de notas, o en un editor de texto similar, y se llamará Access. Guardaremoss este nuevo archivo de texto delimitado por tabuladores en el directorio DataSources. Procederemos de la siguiente manera: 1. Añada otro campo llamado COMPUTER a la tabla inline Access01

que ya teníamos. Incluya uno o dos identificadores para ordenadores



en el presente curso (estos actuarán como campos conectados) tal como se indica a continuación:

/* SECURITY section access comments */ Section Access; Access01: Load * Inline [USERID, PASSWORD, ACCESS, COMPUTER Demo, User, User, Course1 Demo, Admin, Admin, Course2]; Section Application; 2. Abra el bloc de notas, u otro editor de texto similar y cree una

columna de dos tablas con los campos COMPUTER y SERIAL. Incluya su propio número de serie como un valor de campo; encontrará este número en el menú Acerca de QlikView en QlikView. Aquí tiene un ejemplo:

COMPUTER SERIAL Course1 2300 2394 7111 8000 Course2 2300 2394 7111 8001

3. Guarde este archivo como Access02.txt.

Como se puede ver, sólo dos números de licencia tienen acceso al documento que hemos creado, uno con derechos de USUARIO y otro con privilegios de ADMIN. Observe también que estamos añadiendo restricciones a los USERIDs (Demo) existentes, y no reemplazando las restricciones actuales.

4. Abra el script de carga y haga clic en el botón Ficheros Planos.

Cargue la tabla Access02.txt recién creada tras la tabla inline, y antes de la sentencia section application, como aquí se indica:

Access02: Load COMPUTER, SERIAL FROM Datasources\Access02.txt (ansi, txt, delimiter is '\t', embedded labels); Section Application;

5. Pulse Aceptar. 6. Guarde su archivo y a continuación ejecute el script. Si esto

funciona, guarde su archivo otra vez (quizás prefiera elegir Guardar como aquí de nuevo) y salga (Exit) de QlikView.



7. Abra nuevamente el programa e introduzca su USERID y CONTRASEÑA.

Dando por sentado que no ha introducido su número de serie en ambos registros en el archivo Access02.txt, sólo puede acceder como USER o ADMIN. Sería fácil añadir una tercera línea a las tablas de control de acceso que siempre otorgara derechos de USUARIO a cada número de serie, dando por hecho que se presenta un ID de Usuario y Contraseña válidos. Para hacer esto, podemos añadir un tercer ordenador (por ej. Cursoe3) e introducir * como valor en el campo SERIAL.

Otras consideraciones de líneas de comando desatendidas Para crear un acceso de seguridad para un proceso de recarga de líneas de comando de no-intervención, se tendría que introducir el SERIAL registrado a nombre del usuario asignado al proceso de recarga en el ordenador de recarga. Luego se conecta esto a USERID y CONTRASEÑA con * como valores (aquí * representa todos los valores posibles que evitarían que se solicite USERID y CONTRASEÑA). También debería fijar el campo ACCESS a Admin para este tipo de usuario. Si añade el siguiente registro a la sentencia Load Inline de Access01, esto permitirá que el ordenador Curso2 se pueda utilizar para recargas no atendidas. *,*,Admin,Course2]

23.8. Restricciones de acceso en valores de campo seleccionados

El acceso asegurado de QlikView suministra una funcionalidad que impide a los usuarios ver partes de los datos de uno o varios documentos. Esta funcionalidad se desarrolló originalmente para QlikView Server, pero también se puede usar en QlikView, con una serie de consideraciones.

La selección de valores que se habrán de mostrar u ocultar se controla teniendo uno o más campos con los mismos nombres en la sección de acceso y en la sección de aplicación. Cuando el usuario se ha introducido, una vez registrado, QlikView copia los valores seleccionados (en mayúscula) de la sección de acceso a campos de la sección de aplicación con el mismo nombre. QlikView ocultará al usuario, de manera permanente, todos los datos que hayan sido excluidos mediante este proceso.



Todos los nombres de campo y valores empleados para conectar sección de acceso y sección de aplicación deben ir escritos en mayúsculas, ya que todos los nombres y valores de campo son convertidos a mayúsculas por defecto en la sección de acceso. Para poder utilizar esta funcionalidad, la opción Reducción Inicial de Datos basada en la Sección de Acceso en la página Al Abrir del diálogo Propiedades de Documento debe ser comprobada. Si esta característica se emplea en documentos que van a ser distribuidos por otros medios diferentes a los de QlikView Server, la opción Carga Binaria no permitida, en la misma página, debe estar seleccionada, para mantener la integridad de la protección de los datos.

Consejo: Hay una cuestión ya conocida en la Reducción de Datos Dinámica de documentos QlikView en la que una ejecución de script ejecutada por completo ignorará los parámetros de configuración de la reducción de datos dinámica, permitiendo a los usuarios ver “todos” los datos. Para mitigar este riesgo de seguridad, la versión 7 de QlikView prohibirá las recargas en documentos que tengan activa la reducción de datos dinámica.

Sentencias de control de script

Ahora nos gustaría explicar un método diferente para determinar el acceso de seguridad a un documento empleando el campo SalesPerson, junto con reducción de datos. Utilizaremos el concepto de sentencias de control de script para permitir al administrador de este documento elegir qué método de seguridad de acceso emplear para utilizarlo con la recarga de datos. Para ello, fijamos una variable para especificar el método y luego referenciamos dicha variable en un control de script IF … THEN … ELSE. A diferencia de la función If, utilizada normalmente en una sentencia Load o una expresión de gráfico, el control de script IF … THEN … ELSE permite la inclusión de una o más sentencias de script en los parámetros de control. La sintaxis del control IF … THEN … ELSE es la siguiente: if condition then [ statements ] { elseif condition then [ statements ] } [ else [ statements ] ] end if dónde condition es una expresión lógica que puede ser evaluada comoverdadera o falsa.



statements es cualquier grupo de una o más sentencias de script QlikView.

Consejo: Dado que la sentencia if..then es una sentencia de control, cada una de sus cuatro cláusulas posibles (if..then, elseif..then, else y end if) no deben cruzar una línea fronteriza: deben ir terminadas por un punto y coma o un final de línea.

1. Abra el script de carga y el Editor de Script Oculto (recuerde que

debe tener privilegios de Administrador para poder editar el script oculto). Verifique que su cursor está situado en la parte superior de la pestaña de Script Oculto.

2. Primeramente, añadimos la variable de control de script y las sentencias de control de script. Su pestaña de Script Oculto debería mostrar ahora el siguiente aspecto (las nuevas sentencias se han resaltado en amarillo):

/* SECURITY section access comments */ /* Use for BASIC security access */ SET vSecureType = 'BASIC'; /* Comment following statement for BASIC security access */ /* Use for SalesPerson and Data Reduction */ //SET vSecureType = 'DATA'; Section Access; IF vSecureType = 'BASIC' THEN Access01: Load * Inline [USERID, PASSWORD, ACCESS, COMPUTER Demo, User, User, Course1 Demo, Admin, Admin, Course2 *,*,Admin,Course2]; Access02: Load COMPUTER, SERIAL FROM Datasources\Access02.txt (ansi, txt, delimiter is '\t', embedded labels); Section Application; ELSE /* 'DATA' Security Access */ END IF NO hemos añadido sentencia alguna en la parte de control a los accesos de seguridad de los DATOS aún, así que necesitamos asegurarnos



primero de que la sentencia que fija el vSecureType = 'DATA' sea comentada. 3. Pulse Aceptar. 4. Guarde su archivo y ejecute el script. Si esto funciona, guarde de

nuevo el archivo (puede que desee pulsar Guardar Como nuevamente) y salga (Exit) de QlikView.

5. Abra de nuevo el programa e introduzca su USERID y

PASSWORD.

Nada debería haber cambiado todavía en lo que se refiere a su documento. Ahora, sin embargo, implementaremos el segundo método utilizando el campo SalesPerson y reducción de datos.

Limitación del valor de campo en la sección de acceso

Ahora trataremos de limitar la cantidad de datos mostrados en nuestro documento QlikView. Queremos distribuir el archivo a los empleados implicados en las ventas. No obstante, no todos los agentes de ventas tendrán acceso a todos los datos que son propiedad de sus colegas. Por lo tanto, incluiremos una limitación en el script, que asegure que cada persona tiene acceso única y exclusivamente a sus propios datos. Para ello emplearemos dos archivos de texto. El primero establecerá los campos de la sección de acceso para cada usuario autorizado. El segundo archivo de texto se cargará en la sección de aplicación, y limitará los datos de la aplicación que cada usuario esté autorizado a ver una vez que abran el documento QlikView. Ambos archivos de texto se localizan en el directorio Datasources. También hemos de tener en cuenta que necesitamos un administrador que gestione el documento. Uno de los agentes de ventas es también el Director de Marketing de la empresa, por lo que éste será el más indicado para tener acceso total a todo el documento y así poder evaluar el rendimiento de cada agente de ventas. También tenemos un Coordinador de Ventas en Lund (Suecia) que debe tener acceso a los datos de todos los agentes de ventas. Este acceso se puede implementar mediante el uso de un valor nulo, especificado en el campo de enlace cuando se carga en la sección de acceso. Podría utilizar el valor * para este campo, como ya lo utilizamos antes para los campos de USERID y PASSWORD, pero generalmente es preferible usar nulo para los campos de conexión, puesto que ello permitirá el acceso a TODOS los datos, independientemente de si tiene una conexión lógica con el campo conector.



1. Abra el script de carga y el Editor de Script Oculto (recuerde que

debe tener privilegios de Administrador para poder editar el script oculto). Verifique que su cursor está situado sobre la pestaña Script Oculto.

2. Ahora, añadiremos las sentencias en la parte de acceso de seguridad a los DATOS. Aquí, incluimos sentencias Load para los dos achivos de texto, separados por la sentencia Section Application.

3. El primer archivo de texto que se habrá de cargar es SalesSecurity.txt, situado en el directorio Datasources. Denomine esta tabla lógica como Access01.

4. Luego añada la sentencia Section Application.

5. A continuación, cree una sentencia de carga para el archivo SalesInitials.txt, situado en el directorio Datasources. Es una buena práctica utilizar la función Superior con el campo conector (SP), ya que el valor debe hallarse en mayúsculas para coincidir con el valor de la sección de acceso. Las nuevas sentencias deberían verse así:

ELSE /* 'DATA' Security Access */ Access01: Load [USERID], [ACCESS], SP /* Connecting field for data reduction */ FROM Datasources\SalesSecurity.txt (ansi, txt, delimiter is '\t', embedded labels); Section Application; Access_Application: Load upper(SP) as SP, /* Connecting field for data reduction */ [SalesPerson] FROM Datasources\SalesInitials.txt (ansi, txt, delimiter is '\t', embedded labels); END IF 6. Pulse Aceptar. 7. Guarde su archivo y ejecute el script. Si esto funciona, guarde de

nuevo el archivo (Elija Guardar Como si lo desea de nuevo) y abandone (Exit) QlikView.

8. Abra de nuevo el programa e introduzca James como USERID.



Debería poder ver todos los datos. A continuación cierre QlikView y entre registrándose como Leif. Observe que puede ver los datos para este usuario, así como también los del agente de ventas Tom Lindwall.



24. Ejercicios En este ejercicio, nos aseguraremos de que es posible realizar una recarga de líneas de comando desatendida, independientemente del método de seguridad de acceso empleado en el script.

1. Haga los cambios que considere necesarios en el script para permitir que se abra el número de SERIE registrado en la computadora Curso2, ejecute el script y guarde este documento QlikView, sin tener en consideración si el método de seguridad empleado es el ‘BÁSICO’ o el de ‘DATOS’.



25. Depuración Cuando se realizan cambios en el script, a veces es difícil encontrar los errores. QlikView cuenta con un depurador de errores de script que le ayudará a identificar los errores cometidos en su script. Ejecutar el script en el depurador hace mucho más fácil la localización de errores. También puede ahorrar mucho tiempo. En el depurador, puede estudiar cada sentencia y comprobar los valores de las variables mientras el script se está ejecutando. El script se muestra en la ventana, en la mitad superior del diálogo. Un cursor amarillo indica hasta dónde ha llegado la ejecución. Se pueden insertar Puntos de Interrupción haciendo clic en un número de línea y eliminarlos haciendo clic de nuevo sobre ellos. Todos los puntos de interrupción pueden eliminarse haciendo clic en el botón Borrar. Cuando se encuentra un nuevo punto de interrupción, la ejecución se detiene hasta que el comando ordene reanudar. La actual sentencia de script se muestra en la ventana, en la parte intermedia del diálogo. Los códigos de estado y mensajes de error se muestran en la ventana inferior izquierda. Esta es esencialmente la misma información que se muestra en la ventana de Progreso de Ejecución del Script cuando el script se ejecuta sin el depurador. La ventana inferior a mano derecha muestra todas las variables y sus valores. Los valores que han sido modificados, aparecen en rojo. El script se puede ejecutar en tres modos diferentes:

Ejecutar Este es el modo normal de ejecución de script. El script se ejecuta hasta el final, o hasta que se encuentra con un punto de interrupción.

Animar El script se ejecuta como se describe arriba, pero con una breve pausa tras cada sentencia. Esto le permite seguir la ejecución con más cuidado.

Paso a paso

El script se ejecuta sentencia por sentencia, una cada vez.

Para ejecutar el script completo, utilice uno de los métodos siguientes:



Seleccione Carga limitada e introduzca un número en la ventana inferior. El número es el mayor número de registros aceptados para cada sentencia load y select. Esta es una manera muy práctica de limitar el tiempo de ejecución cuando un script se está ejecutando con datos en vivo. Haga clic en Finalizar Aquí para salir del depurador. Los datos que se hayan cargado se conservarán en QlikView. Haga clic en Cancelar para detener la ejecución y descartar los datos cargados.

Figura 32. El diálogo Depurador

Ahora vamos a tratar de ejecutar el depurador en nuestro script. 1. Abra el diálogo Editor de Script desde el menú o la barra de

herramientas. 2. Haga clic en el icono Depurar de la barra de herramientas para

abrir el diálogo Depurador.

3. Inserte puntosde interrupción antes de SQL Select en las tablas Products, Categories y antes de Load en la tabla Sales_Person, haciendo clic en el número de línea en la ventana de script.

Los puntos de inserción se verán como puntos rojos.

4. Observe lo que sucede cuando pulsa el botón Animar.



Ejecutar el script en los diversos modos disponibles en el depurador es tan sencillo como pulsar Ejecutar en el script. Cuando el script ha sido cargado, debe hacer clic en Cerrar para acceder al diálogo Seleccionar Campos.

5. Abra de nuevo el depurador y pulse Ejecutar el script con una Carga limitada de 10 registros. Esto no sólo puede ser una herramienta muy útil para identificar errores y validar cambios, sino que también puede ser una manera de crear plantillas para aplicaciones con un pequeño número de registros en ellos.

25.1. El archivo de registro de ejecución de script

Al principio del curso, fijamos la selección de Generar Archivo log en Propiedades de Documento. Ahora vamos a echar un visazo al archivo que se genera durante la ejecución de script.

El archivo log (o archivo de registro) tendrá el mismo nombre que su documento QlikView, pero con un apéndice “.qvw “añadido a él, y una extensión .log (por ej. QVE_Course.qvw.log). El archivo se ubicará en el mismo directorio que el documento QlikView que está siendo ejecutado.

El archivo log generalmente contiene todas las sentencias de script ejecutadas, sin las líneas y comentarios entre corchetes (se muestran sentencias REM). Incluye también la siguiente información:

Marca de tiempo (Fecha /hora) de inicio de ejecución

Marca de tiempo (Fecha /hora) de final de ejecución

El número de campos y el nombre de cada campo identificado en una sentencia load o select, junto con el número de registros incluidos en dicha load o select.

El número de líneas del script

La versión de QlikView que ejecuta el script

Cualquier error de ejecución de script que pueda haberse producido

Cualquier Clave Sintética que se cree se listará al final del archivo log.

Vea si puede localizar el archivo de registro (log) desde su aplicación, y ábralo utilizando el Bloc de notas u otra herramienta similar.



25.2. Informes de errores en QlikView Si descubre un error en QlikView, le rogamos lo comunique a QlikTech o a un Partner certificado por QlikTech. También es fundamental que suministre cuanta más información le sea posible para describir el error, y, si es posible, que los desarrolladores de QlikTech puedan reproducir el comportamiento. Hay varias cosas que puede hacer para convertir el descubrimiento de un error en un proceso útil y eficaz. 1. Proporcione una descripción clara y detallada del problema,

incluyendo las acciones que le llevaron hasta el error y los mensajes de error que se dispararon, si es que los hubo.

2. Si ello fuera posible, suministre una muestra de un documento QlikView que pueda emplearse para demostrar el error; esto sería de gran utilidad en la resolución del problema.

3. Si el error se produjo durante una recarga, incluya el archivo de registro (log) QlikView junto con el informe de error. El archivo de registro se describe en la sección precedente de este curso.

4. Siempre debería crear una hoja de Sistema en sus documentos QlikView, la cual le ayudará a determinar la integridad de su estructura de datos. Esta hoja se puede “ocultar” fácilmente a los usuarios en una aplicación de producción mediante el uso del parámetro Mostrar Hoja en Propiedades de Hoja.

5. Todo informe de error debiera incluir la información de Información Adicional del Documento. Estos datos contienen información muy valiosa acerca de la computadora que experimentó el problema, la versión de QlikView en ejecución, y los parámetros del documento QlikView. Está disponible desde la Ayuda de menú, o pulsando Ctrl-Mayús-Q. Utilice el botón Copiar al Portapapeles para copiar esta información y pegarla en su correo electrónico, o en un documento de texto.



Figura 33. Información Adicional del Documento

25.3. Materiales de referencia QlikView Hay varios materiales de referencia QlikView a su disposición. Muchos ya se han ido mencionando a lo largo de este curso. Es importante familiarizarse con estas herramientas según avanzan sus conocimientos y habilidades en la creación de documentos QlikView que puedan resultar útiles y eficaces. 1. El Manual de Referencia QlikView: Los documentos del

Manual de Referencia se instalan en su ordenador como parte del proceso habitual de instalación de QlikView. Estos incluyen una guía o Tutorial para usuarios inexpertos, junto con guías de referencia más detallada para desarrollo de script y diseño. Póngase en contacto con QlikTech o su proveedor QlikView certificado habitual si desea solicitar más manuales en copia impresa.

2. Sistema de Ayuda QlikView: El subsistema de Ayuda está disponible directamente desde su aplicación, en la mayoría de diálogos y menús. Incluye unos contenidos generales, un índice con la información disponible y una funcionalidad completa de búsqueda de texto. Si se invoca desde un diálogo, abrirá información relacionada con el contexto.

3. Documentos de ejemplo en QlikView: Estos documentos se han incluido a modo de muestra porque pueden ser una fuente muy valiosa de información que muestre métodos válidos de



desarrollo de documentos QlikView. Pueden resultar de gran utilidad si se navega por ellos en busca de ideas acerca de lo que se puede lograr con QlikView.

4. Material formativo de QlikView: El presente curso, junto con otros cursos ofrecidos por QlikTech, puede emplearse también como guía de referencia de gran valor, a la que siempre se puede recurrir una vez que la formación haya finalizado.



26. Apéndice 1: Tipos de datos en QlikView

QlikView puede manejar cadenas de texto, números, fechas, horas, marcas de tiempo y monedas. Estos pueden ordenarse, mostrarse en diversos formatos y emplearse en los cálculos. Esto significa que las fechas, horas, marcas de tiempo, etc. pueden ser sumadas y restadas. El presente capítulo se suministra como información de referencia y de consulta respecto a cómo maneja QlikView los tipos de datos.

26.1. Almacenamiento de datos en QlikView Para comprender cómo interpreta QlikView los formatos de datos y números, primero debe conocer cómo se almacenan los datos internamente en la aplicación. Todos los datos cargados en QlikView se almacenan de dos maneras: como cadenas de texto o como números.

1. La cadena de texto siempre se utiliza. Es la que se muestra en los

cuadros de lista y en otros objetos de hoja. En el formateado de datos de los cuadros de lista (formato de números) sólo la cadena de texto se ve afectada.

2. Los números sólo se emplean cuando los datos pueden ser

interpretados como un número válido. Se pueden emplear todas las formas posibles de cálculos numéricos y ordenación.

Si varios conjuntos de datos con un mismo valor numérico se cargan en el mismo campo, serán tratados como múltiples ocurrencias del mismo valor y se les asignará conjuntamente la primera cadena de texto encontrada. Si los números 1.0, 1 y 1.000 se cargan por este orden, recibirán el valor numérico 1,y la cadena de texto original 1.0.

26.2. Datos que contienen información sobre tipos de datos

Los campos que contienen números de un determinado tipo de datos, en una base de datos cargada mediante ODBC, se manejarán según su tipo de datos correspondiente en QlikView. QlikView recuerda el formato original de los campos, incluso si es modificado en uno de los diálogos de formato de números. Siempre es posible volver a restaurar el formato original haciendo clic con el ratón en el botón Configuración predeterminada para la entrada en el diálogo de formato de números.



QlikView utiliza los siguientes formatos estándar de datos para cada tipo de número:

Enteros, números de punto flotante: formato numérico estándar Dinero: formato estándar para unidades monetarias Hora, fecha, marca de tiempo: estándar ISO

Las configuraciones estándar para números y monedas se definen mediante variables, las cuales se interpretan en el script, o a través de parámetros de configuración de los sistema operativos (Panel de Control).

26.3. Datos sin información sobre el tipo de datos El manejo de datos sin información específica de formato (por ejemplo datos de archivos de texto, o datos ODBC con un formato general) son más complicados. El resultado final depende al menos de seis factores.

1. El formato de los datos en la base de datos 2. Las configuraciones del sistema operativo en cuanto a números,

hora, fecha, etc. (Panel de Control) 3. La utilización de variables para su interpretación en el script

4. El empleo de funciones de interpretación en el script 5. El uso de funciones de formateado en el script 6. La utilización de diálogos de formato numérico en el documento

QlikView trata de interpretar los datos de entrada como números, fechas, horas, etc. Mientras se empleen las configuraciones del sistema estándar, QlikView interpretará y formateará los datos automáticamente. Por lo tanto el usuario no tiene por qué cambiar el script o las configuraciones en QlikView. Hay una manera muy simple de comprobar si QlikView ha interpretado los datos correctamente: los datos numéricos normalmente se alinean a la derecha en cuadros de lista, mientras que las cadenas de texto suelen ir alineadas a la izquierda. La rutina habitual implica atravesar el siguiente proceso hasta que se encuentra el formato adecuado. (El formato estándar incluye, por ejemplo, el separador decimal, el orden de los años, meses y números, etc. en el sistema operativo, es decir, en el Panel de Control, o en algunos casos definido mediante variables especiales para que las interprete el script.)



QlikView interpreta datos como: 1. un número según el formato numérico estándar 2. una fecha según el formato estándar de fecha 3. una marca de tiempo según el formato estándar de fecha y hora 4. una hora según el formato estándar de hora 5. una fecha según el siguiente formato: yyyy-MM-dd 6. una marca de tiempo según el siguiente formato: yyyy-MM-dd

hh:mm [:ss[.fff]]

7. una hora según el siguiente formato: hh:mm [:ss[.fff]] 8. las monedas según el formato estándar de moneda 9. un número con '.' como separador decimal y ',' como separador de

miles, dando por sentado que ni el separador decimal ni el separador de miles está establecido en ','

10. un número con ',' como separador decimal y '.' como separador de

miles, dando por sentado que ni el separador decimal ni el separador de miles está establecido en '.'

11. una cadena de texto. El siguiente test nunca falla: si es posible

cargar los datos, siempre será posible interpretarlos como cadena de texto.

Los problemas de interpretación suelen surgir cuando los datos se cargan desde archivos de texto. Un separador de decimales incorrecto o un separador de miles en uno u otro idioma pueden llevar a QlikView a interpretar los números de forma incorrecta. Lo primero que debería hacer es comprobar que las variables de interpretación de números en el script estén correctamente definidas y que los parámetros del sistema en el Panel de Control sean los correctos. Cuando QlikView ha interpretado los datos como una fecha u hora, es posible cambiar el formato de tiempo y fecha en el diálogo Propiedades del objeto de hoja (en la pestaña Número). La omisión de formato es algo que se realiza a nivel de documento en Propiedades de Documento: hoja número. Como no existe un formato predefinido para los datos, un registro puede contener obviamente valores con distintos formatos en un único



campo. Por ejemplo, se pueden encontrar en un mismo campo fechas válidas, enteros y texto. Estos datos no recibirán formato, pero se mostrarán en cuadros de lista en su formato original. Cuando el diálogo de formato numérico para dicho campo se abra por primera vez, el formato será Mixto. Una vez que haya modificado el formato será imposible que QlikView lo revierta al formato original en estos valores de campo, es decir, si la casilla de Mantener Formato tras Recarga se encuentra marcada cuando se ejecuta el script. El botón Configuración predeterminada para la entrada no está activo por tanto para este tipo de campo una vez que el formato numérico ha sido modificado.

26.4. Fechas y horas QlikView almacena fechas, horas y marcas de tiempo como un número de serie de datos para fecha. El número en serie para las fechas se utiliza para fechas, horas y marcas de tiempo, así como para cálculos aritméticos basados en unidades de fecha y hora. Las fechas y horas pueden por tanto sumarse y restarse, y los intervalos pueden compararse, etc. Los números empleados para fecha y hora son los valores del número de días que han transcurrido después del 30 de diciembre de 1899. QlikView es por tanto compatible con el sistema de fecha 1900 empledo por Microsoft Excel paraWindows, Lotus 1-2-3 y otros programas, entre el 1 de marzo de 1900 y el 28 de febrero de 2100. Fuera de este marco de tiempo QlikView utiliza el mismo sistema de fecha extrapolado con la ayuda del calendario Gregoriano, el cual está considerado como un estándar en el mundo occidental en la actualidad. El número de serie para las fechas es un número entre 0 y 1. El número de serie 0.00000 corresponde a 00:00:00, mientras que 0.99999 se corresponde con 23:59:59. La mezcla de números muestra ambos, la fecha y la hora: el número en serie 2.5 corresponde al 1 de enero de 1900, a las12.00 horas. Los datos se muestran conforme al formato de la cadena de texto. Los parámetros fijados en el Panel de Control se utilizan como estándar. También es posible definir el formato para fecha y hora mediante una serie de variables que son interpretadas por el script o con la ayuda de una función de formateado. Además, también es posible reformatear datos en el diálogo Propiedades de los objetos de hoja. Ejemplo: • 1997-08-06 se almacena como 35648



• 09:00 se almacena como 0.375

• 1997-08-06 09:00 se almacena como 35648.375

o vice versa • 35648 en formato numérico 'D/M/YY' se muestra como

6/8/97

• 0.375 en formato numérico 'hh.mm' se muestra como 09.00

Como ya se ha mencionado anteriormente, QlikView seguirá un determinado procedimiento para la interpretación de los datos de fecha, hora, etc. El resultado final, no obstante, se verá afectado por una serie de factores.



27. Apéndice 2: El script final ///$tab HiddenScript /* SECURITY section access comments */ /* Use for BASIC security access */ SET vSecureType = 'BASIC'; /* Comment following statement for BASIC security access */ /* Use for SalesPerson and Data Reduction */ //SET vSecureType = 'DATA'; Section Access; IF vSecureType = 'BASIC' THEN Access01: Load * Inline [USERID, PASSWORD, ACCESS, COMPUTER Demo, User, User, Course1 Demo, Admin, Admin, Course2 *,*,Admin,Server,Course2]; /* UnComment following statement AFTER adding correct serial number in Access02.txt file */ REM Access02: Load COMPUTER, SERIAL FROM Datasources\Access02.txt (ansi, txt, delimiter is '\t', embedded labels); Section Application; ELSE /* 'DATA' Security Access */ Access01: Load [USERID], '*' as SERIAL, /* Needed for command line user */ [ACCESS], SP /* Connecting field for data reduction */ FROM Datasources\SalesSecurity.txt (ansi, txt, delimiter is '\t', embedded labels); /* Concatenate data for command line reload */ concatenate (Access01) Load * Inline [USERID, SERIAL, ACCESS, SP *,1002 3426 4752 6766,Admin,]; Section Application; Access_Application: Load



upper(SP) as SP, /* Connecting field for data reduction */ [Sales Person] FROM Datasources\SalesInitials.txt (ansi, txt, delimiter is '\t', embedded labels); END IF /* Security Access */ ///$tab Main LET vCurrentFullYear = Year(today()) - 1; SET ThousandSep=','; SET DecimalSep='.'; SET MoneyThousandSep=','; SET MoneyDecimalSep='.'; SET MoneyFormat='$#,##0.00;($#,##0.00)'; SET TimeFormat='h:mm:ss TT'; SET DateFormat='M/D/YYYY'; SET TimestampFormat='M/D/YYYY h:mm:ss[.fff] TT'; SET MonthNames='Jan;Feb;Mar;Apr;May;Jun;Jul;Aug;Sep;Oct;Nov;Dec'; SET DayNames='Mon;Tue;Wed;Thu;Fri;Sat;Sun'; /* Quarters comments */ rem Quarters_Map: Mapping Load * Inline [ Month, Quarter 1,Q1 2,Q1 3,Q1 4,Q2 5,Q2 6,Q2 7,Q3 8,Q3 9,Q3 10,Q4 11,Q4 12,Q4]; Quarters_Map: Mapping Load rowno() as Month, 'Q' & Ceil(rowno()/3) as Quarter Autogenerate(12); /* CONNECT to QWT database */ ODBC CONNECT TO [EnterpriseScript;DBQ=DATASOURCES\QWT.mdb]; /* Customers Table load using QVD buffer */ Customers: buffer (stale after 7 days) SELECT Address, City, CompanyName, ContactName, Country, CustomerID, Fax, Phone,



PostalCode, StateProvince FROM Customers; rem store Customers into datasources/customers.qvd; rem Customers: Load Address, City, CompanyName, ContactName, Country, CustomerID, Fax, Phone, PostalCode, StateProvince FROM Datasources\customers.qvd (qvd); /* Shippers Table comments */ Shippers: SQL SELECT ShipperID, CompanyName as Shipper FROM Shippers; /* Products Table comments */ Products: SQL SELECT CategoryID, ProductID, ProductName, QuantityPerUnit, SupplierID, UnitCost, UnitsInStock, UnitsOnOrder FROM Products; /* Categories Table comments */ Categories: SQL SELECT CategoryID, CategoryName, Description FROM Categories; /* Orders Table comments */ Orders: buffer (stale after 1 days) Load CustomerID, EmployeeID, EmployeeID as EmployeeSales, Freight, OrderDate, OrderDate as CountOrderDate,



Year(OrderDate) as Year, Month(OrderDate) as Month, date(monthstart(OrderDate),'MMM-YYYY') as [Rolling Month], applymap('Quarters_Map',num(Month(OrderDate))) as Quarter, Day(OrderDate) as Day, OrderID, ShipperID; SELECT * FROM Orders; /* Order Details Table comments */ Order_Details: buffer (stale after 1 days) SQL SELECT OrderID, ProductID, ProductID as CountProductID, Quantity, UnitPrice, UnitPrice*Quantity*(1-Discount) as NetSales FROM Òrder Details`; Employee: Load EmpID as EmployeeID, [First Name] & ' ' & [Last Name] as Name, [Last Name], [First Name], Title, [Hire Date], Year([Hire Date]) as [Employee Hire Year], Office, Extension, [Reports To], [Year Salary] FROM Datasources\Emp*.xls (biff, embedded labels, table is [Employee$]); REM Employee: concatenate (Employee) Load EmpID as EmployeeID, [First Name] & ' ' & [Last Name] as Name, [Last Name], [First Name], Title, [Hire Date], Year([Hire Date]) as [Employee Hire Year], Office, Extension, [Reports To], [Year Salary] FROM Datasources\Employees_New.xls (biff, embedded labels, table is [Employee$]); Office: Load Office, Address as OfficeAddress, [Postal Code] as OfficePostalCode,



City as [Sales Office], StateProvince as OfficeStateProvince, Phone as OfficePhone, Fax as OfficeFax, Country as OfficeCountry FROM Datasources\EmpOff.xls (biff, embedded labels, table is [Office$]); /* Suppliers Table comments */ Qualify *; Unqualify SupplierID; suppliers: Load SupplierID, CompanyName, ContactName, Address, City, PostalCode, Country, Phone, Fax FROM Datasources\suppliers.dif (oem, dif, embedded labels); Unqualify *; /* Include external script file */ $(Include=datasources\email.txt) ///$tab Sales Person /* Sales Person Table comments */ Sales_Person: Load EmployeeID, EmployeeID as SalesPersonID, Name as [SalesPerson], Title as SalesTitle Resident Employee Where Exists(EmployeeSales,EmployeeID); ///$tab Sales Change /* Load and Join Order data based on vCurrentFullYear variable setting */ OrdersByYear_Source: Load CustomerID, OrderID, Year RESIDENT Orders Where Year = $(vCurrentFullYear) - 1 or Year = $(vCurrentFullYear); /*only load 2 years*/ Left Join (OrdersByYear_Source) Load OrderID,



NetSales RESIDENT Order_Details; /* Aggregation by Customer comments */ OrdersByYear: Load CustomerID, Year, sum(NetSales) as NetSalesByYear RESIDENT OrdersByYear_Source Group by CustomerID,Year; DROP TABLE OrdersByYear_Source; /* Sales Change using Previous function */ SalesChange: Load CustomerID, NetSalesByYear, If(CustomerID = Previous(CustomerID), If(NetSalesByYear > Previous(NetSalesByYear), 'UP','DOWN'),null()) as SalesChangeIndicator, If(CustomerID = Previous(CustomerID), NetSalesByYear - Previous(NetSalesByYear), null()) as SalesChangeAmt RESIDENT OrdersByYear Order by CustomerID,Year; DROP TABLE OrdersByYear; DROP FIELD NetSalesByYear; ///$tab Budget/Result Budget_Actual_S1: CROSSTABLE(BudgetYear, Amount, 2) Load * FROM Datasources\Budget.xls (biff, header is line, embedded labels, table is [Sheet2$], filters( Replace(1, top, StrCnd(null)) )); Budget_Actual: Generic Load Office, BudgetYear, Metric, Amount Resident Budget_Actual_S1; DROP TABLE Budget_Actual_S1;

Documents

q v Enterprise Modulo i i