Qlikview Proyecto

Desarrollo de Script
QV Enterprise
Noviembre 2005
QV Versión 7.0 Español
copyright © 1996-2005 QlikTech International PJB/2005-04-01

QlikView Enterprise Script
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
copyright © 1996-2005 QlikTech International Page 2

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 `Order 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;Oc
t;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:
SQL SELECT
ShipperID,
FROM Shippers;
Products:
SQL SELECT
CategoryID,
ProductID,
ProductName,

QuantityPerUnit,
SupplierID,
UnitCost,
UnitsInStock,
UnitsOnOrder
FROM Products;
Categories:
SQL SELECT
CategoryID,
CategoryName,
Description
FROM Categories;
Orders:
Load
CustomerID,
EmployeeID,
Freight,
OrderDate,
OrderID,
ShipperID;

Order_Details:
SQL SELECT
OrderID,
ProductID,
Quantity,
UnitPrice,

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


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
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
[First Name] & ' ' & [Last Name] as Name,
[Last Name],
[First Name],
Title,
[Hire Date],
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,
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 *;
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.

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

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.

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

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

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).

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,
Freight,
OrderDate,
OrderDate as CountOrderDate,
date(monthstart(OrderDate),'MMM-YYYY') as [Rolling Month],
applymap('Quarters_Map',num(Month(OrderDate))) as Quarter,
OrderID,
ShipperID;
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.
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.

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

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.
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.
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;
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.
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,
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;
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;
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.
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 */
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.
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.
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.
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

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
[Last Name],
[First Name],
Title,
[Hire Date],
Office,
Extension,
[Reports To],
[Year Salary]
FROM Datasources\Emp*.xls (biff, embedded labels,

REM Employee:
[Last Name],
[First Name],
Title,
[Hire Date],
Office,
Extension,
[Reports To],
[Year Salary]
FROM Datasources\Employees_New.xls (biff, embedded
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:
Section Access;
Access01:
Load * Inline
[USERID, PASSWORD, ACCESS, COMPUTER
Demo, User, User, Course1
Demo, Admin, Admin, Course2];
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,
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):
/* 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
Demo, Admin, Admin, Course2
*,*,Admin,Course2];
Access02:
Load
COMPUTER,
SERIAL
FROM Datasources\Access02.txt (ansi, txt, delimiter
is '\t', embedded labels);
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í:
Access01:
Load
[USERID],
[ACCESS],
SP /* Connecting field for data reduction */
FROM Datasources\SalesSecurity.txt (ansi, txt,
Access_Application:
Load
upper(SP) as SP, /* Connecting field for data
reduction */
[SalesPerson]
FROM Datasources\SalesInitials.txt (ansi, txt,
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 El script se ejecuta sentencia por sentencia, una cada

paso 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.

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
/* 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
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);
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,];
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:
SQL SELECT
ShipperID,
FROM Shippers;
Products:
SQL SELECT
CategoryID,
ProductID,
ProductName,
QuantityPerUnit,
SupplierID,
UnitCost,
UnitsInStock,
UnitsOnOrder
FROM Products;
Categories:
SQL SELECT
CategoryID,
CategoryName,
Description
FROM Categories;
Orders:
buffer (stale after 1 days) Load
CustomerID,
EmployeeID,
Freight,
OrderDate,
OrderDate as CountOrderDate,

date(monthstart(OrderDate),'MMM-YYYY') as [Rolling
Month],
applymap('Quarters_Map',num(Month(OrderDate))) as
Quarter,
OrderID,
ShipperID;
SELECT * FROM Orders;

Order_Details:
buffer (stale after 1 days) SQL SELECT
OrderID,
ProductID,
ProductID as CountProductID,
Quantity,
UnitPrice,
Employee:
Load
[Last Name],
[First Name],
Title,
[Hire Date],
Office,
Extension,
[Reports To],
[Year Salary]
FROM Datasources\Emp*.xls (biff, embedded labels, table is
[Employee$]);
REM Employee:
[Last Name],
[First Name],
Title,
[Hire Date],
Office,
Extension,
[Reports To],
[Year Salary]
FROM Datasources\Employees_New.xls (biff, embedded labels,
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 *;
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,
Title as SalesTitle
Resident Employee
Where
Exists(EmployeeSales,EmployeeID);
///$tab Sales Change
/*
Load and Join Order data based on
vCurrentFullYear variable setting
*/
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(NetSalesByYear > Previous(NetSalesByYear),
'UP','DOWN'),null()) as SalesChangeIndicator,
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;

Qlikview Proyecto

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Qlikview Proyecto

Transféré par

Droits d'auteur :

Formats disponibles

Desarrollo de Script

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

Copyright © 1994-2005 Qlik®Tech International AB, Suecia.

Documento original en inglés: Abril 2005

copyright © 1996-2005 QlikTech International Page 2

2. EL PLAN DE PROYECTO BI QLIK WHOLESALE TRADE (QWT)................................... 9

3. UNA BREVE INTRODUCCIÓN A LAS ESTRUCTURAS DE DATOS............................... 11

4. ESTRUCTURAS DE DATOS QLIKVIEW .............................................................................. 12

5. CARGAR DATOS EN QLIKVIEW .......................................................................................... 14

7. CREACIÓN DEL SCRIPT......................................................................................................... 30

8. ESTRUCTURA DE LOS DATOS CARGADOS ...................................................................... 39

copyright © 1996-2005 QlikTech International Page 3

8.2. EL VISOR DE TABLAS ............................................................................................................... 40

9. AÑADIR DATOS DE TEXTO ................................................................................................... 44

11. CREACIÓN DE DATOS EN QLIKVIEW.............................................................................. 55

12. CÓMO CARGAR UN ARCHIVO DIF ................................................................................... 60

13. CAMPOS CLAVE ..................................................................................................................... 63

15. CAMPOS DE DIMENSIÓN DE TIEMPO ADICIONALES................................................. 67

16. TABLA CRUZADA Y CARGA GENÉRICA......................................................................... 72

18. ARCHIVOS DE DATOS QLIKVIEW: ARCHIVOS QVD................................................... 80

copyright © 1996-2005 QlikTech International Page 4

18.4. CREACIÓN MANUAL DESDE EL SCRIPT ................................................................................... 82

20. SCRIPT AVANZADO – 1ª PARTE ......................................................................................... 88

22. SCRIPT AVANZADO – 2ª PARTE ......................................................................................... 97

23. SEGURIDAD ........................................................................................................................... 101

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

25. DEPURACIÓN ........................................................................................................................ 115

26. APÉNDICE 1: TIPOS DE DATOS EN QLIKVIEW ........................................................... 121

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

copyright © 1996-2005 QlikTech International Page 5

1.1. Acerca de este curso

Este curso da respuesta a las siguientes preguntas:

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

El material del curso se ha diseñado siguiendo un enfoque modular. Su

Al igual que sucede con cualquier otro producto, para convertirse en un

copyright © 1996-2005 QlikTech International Page 6

1.2. Archivos de datos empleados en el curso

QWT - Base de datos en Access

Tras la instalación, encontrará un documento con el nombre

1.4. Guardar archivos

Cualquier archivo nuevo de datos que cree durante el curso puede

copyright © 1996-2005 QlikTech International Page 7

1.5. Formato de texto del material de curso

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

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

Los nombres de hojas, cuadros de lista, campos y expresiones, etc. se

Los nombres de archivo aparecen del siguiente modo:

copyright © 1996-2005 QlikTech International Page 8

2. El plan de proyecto BI Qlik Wholesale

2.1. Introducción al plan de proyecto

Encontrará el plan de proyecto, entre los materiales del curso, con el

2.2. Plan de Proyecto: Visión general

¾ Mediciones clave: aquí hallará algunas de las expresiones que

copyright © 1996-2005 QlikTech International Page 9

¾ Descripciones de los datos de origen: suministra la ubicación y

copyright © 1996-2005 QlikTech International Page 10

3. Una breve introducción a las

3.1. Acerca de las estructuras de datos

3.2. Bases de datos relacionales

Una base de datos relacional se fundamenta en una serie de reglas. Una

3.3. Otras estructuras de datos

copyright © 1996-2005 QlikTech International Page 11

4. Estructuras de datos QlikView

4.1. Comparación entre estructuras de datos y