Débuter avec le script de chargement Qlik

Les données utilisées par une application Qlik proviennent d’une source : une base de données, un QVD, un fichier Excel, un CSV… Le script de chargement lit ces données et les charge dans Qlik sous forme de tables. Ces tables peuvent ensuite être transformées, associées ou utilisées dans les visualisations.

La source d’origine et la table chargée dans Qlik sont deux choses différentes. Un fichier QVD reste sur le disque tandis que les données lues dans ce fichier sont chargées dans l’application.

Le fichier Clients.qvd contient des données que l’application doit utiliser. L’instruction LOAD permet de lire les champs souhaités dans ce fichier et de les charger dans Qlik.

Clients.qvd est le fichier source présent sur le disque. Clients est la table chargée dans l’application à partir de ce fichier. Une transformation appliquée ensuite à la table Clients ne modifie pas automatiquement le QVD d’origine.

// Le fichier Clients.qvd est notre source de données.

Clients:
LOAD ID_CLIENT, NOM_CLIENT, VILLE
FROM [lib://Donnees/Clients.qvd] (qvd);

// Les données lues dans le QVD sont maintenant disponibles dans la table Clients.

Un QVD n’est pas la seule source possible. Qlik peut aussi charger un fichier Excel ou CSV. Le principe reste le même : LOAD lit les données de la source et les rend disponibles dans l’application.

FROM désigne la source et LOAD indique les champs à charger dans Qlik. Les options comme ooxml ou txt précisent simplement à Qlik comment lire le type de fichier concerné.

// Produits.xlsx contient les données à charger.

Produits:
LOAD ID_PRODUIT, LIBELLE_PRODUIT, CATEGORIE
FROM [lib://Donnees/Produits.xlsx]
(ooxml, embedded labels, table is Produits);

// Les données sélectionnées sont maintenant disponibles dans la table Produits.

Avec une base de données, la source n’est plus un fichier. Une requête SQL demande d’abord les données à la BDD. Qlik peut ensuite appliquer un LOAD à ces données avant de les rendre disponibles dans l’application.

Pour comprendre les données, lisez ici le bloc depuis la source : la BDD fournit les lignes avec SELECT, puis le LOAD Qlik les transforme. Cette construction est un Preceding Load ; nous l’expliquerons tranquillement plus loin.

// Les données de départ se trouvent dans la table COMMANDES de la BDD.

Commandes:
LOAD
    ORDER_ID AS ID_COMMANDE,
    CUSTOMER_ID AS ID_CLIENT,
    Date(ORDER_DATE) AS DATE_COMMANDE,
    AMOUNT AS CA_HT;
SQL SELECT
    ORDER_ID,
    CUSTOMER_ID,
    ORDER_DATE,
    AMOUNT
FROM COMMANDES;

// Le résultat est maintenant disponible dans la table Qlik Commandes.

Un LOAD ne sert pas seulement à copier des colonnes. Pendant que les lignes entrent dans Qlik, vous pouvez renommer des champs et en calculer de nouveaux.

Le LOAD ne sert donc pas seulement à choisir des champs : il peut aussi préparer les données au moment de leur chargement dans Qlik.

// Le QVD fournit les données ; le LOAD les prépare avant de les charger dans Commandes.

Commandes:
LOAD
    ID_COMMANDE,
    ID_CLIENT,
    Date(DATE_BRUTE) AS DATE_COMMANDE,
    QUANTITE,
    PRIX_UNITAIRE,
    QUANTITE * PRIX_UNITAIRE AS CA_HT
FROM [lib://Donnees/Commandes.qvd] (qvd);

// Commandes contient maintenant DATE_COMMANDE et CA_HT.

Jusqu’ici, toutes les lignes de la source étaient chargées. WHERE permet de ne charger que celles qui répondent à une condition. DISTINCT permet, lui, de ne conserver qu’une seule fois des lignes identiques dans le résultat.

DISTINCT ne doit pas servir à supprimer des doublons sans en comprendre la cause. Avant de l’utiliser, vérifiez pourquoi plusieurs lignes identiques sont présentes.

// Le QVD contient tous les clients.

ClientsActifs:
LOAD DISTINCT
    ID_CLIENT,
    NOM_CLIENT
FROM [lib://Donnees/Clients.qvd] (qvd)
WHERE ACTIF = 1;

// ClientsActifs contient uniquement les lignes qui ont passé le filtre.

Nous allons maintenant conserver deux tables dans l’application. La première, Clients, est chargée depuis son QVD. La seconde, Commandes, est chargée juste après. Elles possèdent toutes les deux un champ appelé ID_CLIENT.

Dans Qlik, deux champs portant exactement le même nom sont associés. C’est voulu pour les clés, mais dangereux pour les homonymes accidentels.

// 1. On charge d’abord la table Clients.
Clients:
LOAD ID_CLIENT, NOM_CLIENT, VILLE
FROM [lib://Donnees/Clients.qvd] (qvd);

// 2. On charge ensuite la table Commandes.
Commandes:
LOAD ID_COMMANDE, ID_CLIENT, DATE_COMMANDE, CA_HT
FROM [lib://Donnees/Commandes.qvd] (qvd);

// Qlik associe automatiquement les deux tables grâce à ID_CLIENT.

Cette fois, nous ne voulons pas conserver deux tables séparées. Nous allons d’abord charger Clients, puis utiliser LEFT JOIN pour ajouter à cette table des informations provenant d’une seconde source.

Avant un JOIN, vérifiez qu’une même clé ne correspond pas à plusieurs lignes de façon inattendue. Sinon, le JOIN peut multiplier le nombre de lignes.

// ÉTAPE 1 : on charge d’abord Clients.
Clients:
LOAD ID_CLIENT, NOM_CLIENT
FROM [lib://Donnees/Clients.qvd] (qvd);

// ÉTAPE 2 : on lit Segments.qvd et on fusionne dans Clients.
LEFT JOIN (Clients)
LOAD ID_CLIENT, SEGMENT
FROM [lib://Donnees/Segments.qvd] (qvd);

// APRÈS : Clients contient aussi SEGMENT.

KEEP rapproche également deux jeux de données grâce à leurs champs communs, mais contrairement à JOIN il ne les fusionne pas dans une seule table.

Pour débuter, retenez surtout : JOIN fusionne ; KEEP filtre les ensembles tout en conservant les tables.

// 1. On charge d’abord Clients.
Clients:
LOAD ID_CLIENT, NOM_CLIENT
FROM [lib://Donnees/Clients.qvd] (qvd);

// 2. Commandes est chargée et comparée à Clients.
INNER KEEP (Clients)
Commandes:
LOAD ID_COMMANDE, ID_CLIENT, CA_HT
FROM [lib://Donnees/Commandes.qvd] (qvd);

// APRÈS : Clients et Commandes restent deux tables distinctes.

CONCATENATE sert à empiler des lignes. Nous allons d’abord charger les ventes 2025 dans une table Ventes, puis ajouter à cette même table les lignes provenant du fichier 2026.

Image mentale : CONCATENATE empile des lignes verticalement ; JOIN rapproche des lignes et ajoute généralement des colonnes.

// 1. Ventes est créée avec les lignes 2025.
Ventes:
LOAD ID_VENTE, DATE_VENTE, CA_HT
FROM [lib://Donnees/Ventes_2025.qvd] (qvd);

// 2. On ajoute les lignes 2026 à la table Ventes déjà chargée.
CONCATENATE (Ventes)
LOAD ID_VENTE, DATE_VENTE, CA_HT
FROM [lib://Donnees/Ventes_2026.qvd] (qvd);

// APRÈS : une seule table Ventes contient 2025 + 2026.

Qlik peut concaténer automatiquement deux tables qui ont exactement les mêmes champs. NoConcatenate sert à dire : « même structure, mais je veux quand même une nouvelle table ».

Sans NoConcatenate, deux chargements ayant exactement les mêmes champs peuvent être regroupés automatiquement par Qlik. Ici, nous demandons explicitement de conserver deux tables.

// 1 — On charge les ventes 2025.
Ventes:
LOAD ID_VENTE, DATE_VENTE, CA_HT
FROM [lib://Donnees/Ventes_2025.qvd] (qvd);

// 2 — Même structure, autre source.
// NoConcatenate impose la création d’une nouvelle table.
Ventes_2026:
NoConcatenate
LOAD ID_VENTE, DATE_VENTE, CA_HT
FROM [lib://Donnees/Ventes_2026.qvd] (qvd);

// À la fin, Ventes et Ventes_2026 restent deux tables distinctes.

Resident sert à repartir de données que Qlik a déjà chargées. Avant de pouvoir écrire Resident Commandes, il faut donc qu’une instruction précédente du script ait créé la table Commandes.

Resident ne relit pas le fichier ou la base de données d’origine. Il utilise comme source une table déjà chargée plus haut dans le script.

// ÉTAPE 1 — On charge d’abord Commandes depuis le QVD.
Commandes:
LOAD ID_COMMANDE, ID_CLIENT, CA_HT
FROM [lib://Donnees/Commandes.qvd] (qvd);

// À ce stade, les données de Commandes sont déjà chargées dans Qlik.

// ÉTAPE 2 — Resident repart de cette table déjà chargée.
CA_Par_Client:
LOAD
    ID_CLIENT,
    Sum(CA_HT) AS CA_CLIENT
Resident Commandes
Group By ID_CLIENT;

// Le script dispose maintenant de Commandes et de CA_Par_Client.

Avec Resident, une première table a déjà été chargée et on la relit ensuite. Le Preceding Load évite cette étape intermédiaire : le résultat du chargement placé en dessous est transmis directement au LOAD placé au-dessus.

Resident : je repars d’une table déjà chargée dans Qlik. Preceding Load : le résultat de l’instruction du dessous est traité directement par le LOAD du dessus.

// Le flux des données remonte du LOAD inférieur vers le LOAD supérieur.
Commandes:
LOAD
    ID_COMMANDE,
    Date(DATE_BRUTE) AS DATE_COMMANDE;
LOAD
    ID_COMMANDE,
    Timestamp#(DATE_TEXTE,'YYYY-MM-DD hh:mm:ss') AS DATE_BRUTE
FROM [lib://Donnees/Commandes.csv]
(txt, utf8, embedded labels, delimiter is ',');

// APRÈS : seule Commandes est créée comme table de ce bloc.

Un mapping se déroule en deux temps. D’abord Qlik charge une petite correspondance clé → valeur. Ensuite un autre LOAD utilise ApplyMap() pour rechercher la valeur correspondant à chaque clé.

Le mapping doit être chargé avant le LOAD qui appelle ApplyMap(), puisque Qlik doit déjà connaître la correspondance au moment de la recherche.

// ÉTAPE 1 — On charge d’abord la table de correspondance.
MapSegment:
Mapping LOAD
    ID_CLIENT,
    SEGMENT
FROM [lib://Donnees/Segments.qvd] (qvd);

// ÉTAPE 2 — Charger Commandes et consulter le mapping ligne par ligne.
Commandes:
LOAD
    ID_COMMANDE,
    ID_CLIENT,
    ApplyMap('MapSegment', ID_CLIENT, 'Non classé') AS SEGMENT,
    CA_HT
FROM [lib://Donnees/Commandes.qvd] (qvd);

// APRÈS : Commandes contient le champ SEGMENT enrichi.

Jusqu’ici, LOAD faisait entrer des données dans Qlik. STORE fait autre chose : il prend les données d’une table déjà chargée dans Qlik et les enregistre dans un fichier, généralement un QVD.

LOAD charge des données dans Qlik ; STORE écrit dans un fichier le contenu d’une table déjà chargée dans Qlik.

// ÉTAPE 1 — On charge d’abord Commandes.
Commandes:
LOAD ID_COMMANDE, ID_CLIENT, DATE_COMMANDE, CA_HT
FROM [lib://Donnees/Commandes_Source.qvd] (qvd);

// ÉTAPE 2 — Le contenu de la table déjà chargée dans Qlik est écrit sur disque.
STORE Commandes
INTO [lib://QVD/Commandes.qvd] (qvd);

// À la fin : Commandes reste disponible dans Qlik
//             et Commandes.qvd existe aussi sur le disque.

Nous pouvons maintenant réunir trois instructions que l’on rencontre souvent ensemble. LOAD charge les données dans Qlik, STORE enregistre ces données dans un QVD, puis DROP TABLE retire la table de l’application lorsqu’elle n’est plus nécessaire pour la suite du script.

Après STORE, le QVD existe sur le disque et la table reste chargée dans Qlik. DROP TABLE retire ensuite cette table de l’application sans supprimer le QVD.

// 1 — On charge les données dans Qlik.
Commandes:
LOAD
    ID_COMMANDE,
    ID_CLIENT,
    DATE_COMMANDE,
    CA_HT
FROM [lib://Donnees/Commandes_Source.qvd] (qvd);

// 2 — On enregistre le résultat dans un QVD.
STORE Commandes
INTO [lib://QVD/Commandes.qvd] (qvd);

// 3 — On retire la table de Qlik si elle n’est plus utile.
DROP TABLE Commandes;

// À la fin : Commandes a été retirée de Qlik,
//             mais Commandes.qvd reste bien sur le disque.

DROP ne charge aucune donnée. Il sert à retirer une table ou un champ que Qlik a déjà chargé auparavant dans le script.

Attention à la distinction : DROP TABLE Commandes retire la table Commandes de Qlik. Il ne supprime ni Commandes.qvd sur le disque, ni une table COMMANDES dans une base de données.

// On suppose que ces objets ont été créés plus haut dans le script.

DROP TABLE Commandes_Temp;
DROP FIELD CleTechnique FROM Commandes;

// Commandes_Temp a été retirée de Qlik.
// Commandes est toujours présente, mais sans CleTechnique.

Avec INLINE, il n’y a ni fichier ni base de données à lire : les quelques valeurs à charger sont écrites directement dans le script.

INLINE est idéal pour expérimenter : vous voyez la source et le résultat sans dépendre d’un fichier externe.

// Les données sont écrites directement dans le script.
Statuts:
LOAD * INLINE [
CODE_STATUT, LIBELLE_STATUT
O, Ouverte
C, Clôturée
A, Annulée
];

// La table Statuts est maintenant chargée dans Qlik avec 3 lignes.

Nous savons maintenant charger plusieurs tables et nous avons vu que Qlik les associe lorsque des champs portent le même nom. Construisons un premier modèle simple avec des clients, des commandes et des produits.

Ouvrez ensuite le Data Model Viewer : il permet de voir les trois tables chargées et les associations que Qlik a créées entre elles.

// 1 — On charge Clients.
Clients:
LOAD ID_CLIENT, NOM_CLIENT, VILLE
FROM [lib://Donnees/Clients.qvd] (qvd);

// 2 — On charge Commandes.
Commandes:
LOAD
    ID_COMMANDE,
    ID_CLIENT,
    ID_PRODUIT,
    DATE_COMMANDE,
    QUANTITE,
    CA_HT
FROM [lib://Donnees/Commandes.qvd] (qvd);

// 3 — On charge Produits.
Produits:
LOAD ID_PRODUIT, LIBELLE_PRODUIT, CATEGORIE
FROM [lib://Donnees/Produits.qvd] (qvd);

// Associations : Clients ← ID_CLIENT → Commandes ← ID_PRODUIT → Produits

Les instructions vues dans ce parcours n’ont pas toutes le même rôle. Certaines lisent une source externe, d’autres réutilisent ou enrichissent des données déjà chargées, écrivent un fichier ou retirent une table devenue inutile.

Resident, Preceding Load, Mapping/ApplyMap et le modèle associatif sont approfondis dans les tutoriels dédiés.