# Utilisation de chargements inline pour charger des données
Saisissez manuellement des données dans un script pour définir une table inline, qui peut être chargée dans une application. Vous pouvez utiliser des chargements inline dans l'Éditeur de chargement de données.
Vous créez des tables inline en saisissant manuellement des données dans le script, au lieu de vous connecter à des fichiers et des bases de données. Utilisez la syntaxe requise pour indiquer que le texte de script doit être interprété comme des données inline. Les données ajoutées avec des chargements inline seront contenues dans l'application si l'application est exportée. Les tables inline peuvent être lues et éditées au sein du script de chargement.
Un chargement inline de base crée une table et insère les enregistrements et les champs de données.
Chargement inline dans l'éditeur de chargement de données
Chargement inline dans l'éditeur de chargement de données
Chargement inline dans l'éditeur de chargement de données 
## Exemple de syntaxe de base
Le script suivant contient un chargement inline simple.
```
MyTable:
Load * Inline [
Country, Year, Sales
Argentina, 2014, 66295.03
Argentina, 2015, 140037.89
Austria, 2014, 54166.09
Austria, 2015, 182739.87
];
```
La syntaxe suivante est utilisée pour le chargement inline ci-dessus :
* Load \* Inline demande à Qlik Sense de charger tous les champs de la table inline qui suit.
* MyTable: définit le nom de la table. La liste de tables de l'application est accessible via Visionneur de modèle de données et d'autres domaines.
* Les données sont encadrées de crochets.
* La première ligne de l'instruction LOAD définit les champs de données.
* Les enregistrements et les champs de données sont séparés par des virgules.
* L'instruction LOAD est fermée par un point-virgule.
## Chargement d'une table inline
Procédez comme suit :
1. Dans une application, ouvrez Éditeur de chargement de données.
2. Sur une nouvelle ligne, définissez la table via la syntaxe requise.
[Exemple de syntaxe de base](https://help.qlik.com/fr-FR/sense/May2026/Subsystems/Hub/Content/Sense_Hub/Scripting/inline-loads-qs.htm#BasicSyntax)
3. Une fois que vous avez terminé, cliquez sur Charger les données.
## Pourquoi utiliser des chargements inline ?
Les chargements inline peuvent s'avérer utiles dans un certain nombre de cas d'utilisation :
* Administration et édition de données sans besoin de se connecter à des sources externes.
* Enrichissement de données existantes dans le modèle de données. Par exemple, vous pouvez ajouter une table supplémentaire à un modèle de données qui provient essentiellement de sources de base de données.
* Ajout de données que vous souhaitez éviter d'avoir à charger continuellement depuis des sources externes. Cela peut vous faire gagner du temps, si vous savez que la source de données est susceptible de changer à l'avenir, mais que les valeurs des données resteront les mêmes.
* Facile à utiliser pour copier-coller dans le script un contenu provenant d'autres fichiers. Par exemple, des tables ou des fichiers .csv provenant de documents de traitement de texte.
* Création de scripts test pouvant être rapidement copiés-collés.
## Vue d'ensemble de la syntaxe
### Attribution d'un nom à la table
Vous pouvez ajouter un nom à la table inline, comme vous le feriez pour d'autres tables chargées. La définition du nom de table est facultative.
Après le nom de la table, insérez un point-virgule.
### LOAD et inline instructions
Une table inline est chargée avec la clause inline lorsque vous utilisez l'instruction de script LOAD. La clause inline indique que le texte qui suit dans la table contiendra des données saisies manuellement dans l'éditeur. Sauf indication contraire de votre part, une table inline utilise le format txt, qui suit la structure d'un fichier texte délimité.
Pour plus d'informations sur l'instruction LOAD, voir [Load](https://help.qlik.com/fr-FR/sense/May2026/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptRegularStatements/Load.htm).
### Encadrements et saisie de données
Les données saisies à l'aide d'une clause inline doivent être encadrées par des caractères spécifiques. Voici les combinaisons de caractères acceptées pour l'encadrement des données :
* Crochets : `[` et `]`
* Guillemets doubles : `"` et `"`
* Guillemets simples : `'` et `'`
* Backticks : `` ` `` et `` ` ``
Le caractère que vous sélectionnez comme encadrement peut vous aider à charger des données inline contenant des caractères conflictuels. Par exemple, si vos données contiennent des enregistrements avec des crochets, à la place, vous pouvez les encadrer de guillemets ou de backticks.
Pour un exemple d'encadrements alternatifs, voir [Exemple - Encadrements de données alternatifs](https://help.qlik.com/fr-FR/sense/May2026/Subsystems/Hub/Content/Sense_Hub/Scripting/inline-loads-qs.htm#ExDataEnc).
À moins de spécifier un format de table alternatif (le format par défaut est le format txt), le texte encadré est interprété de la même manière que le contenu d'un fichier. C'est pourquoi vous devez également insérer une nouvelle ligne dans la clause inline, là où vous en auriez inséré une dans un fichier texte : en appuyant sur la touche Entrée lors de la saisie du script.
### Fin de l'instruction inline load
La fin de l'instruction inline load est indiquée par un point-virgule.
### Transformations de données
Dans un chargement inline simple sans transformations, le nombre de colonnes est défini par la première ligne. Il existe trois colonnes dans la table chargée par l'exemple suivant : `Product_ID`, `Supplier_Name`, et `Product_Category`.
```
Products:
Load * Inline [
Product_ID, Supplier_Name, Product_Category
1, Paracel, Home Decor
2, PageWave, Electronics
3, Talarian, Software
4, Userland, Appliances
];
```
Vous pouvez également effectuer des transformations et créer de nouvelles colonnes au sein de la même table inline. Vous pouvez utiliser preceding loads, et vous pouvez utiliser plusieurs instructions LOAD pour charger la même table.
Pour des exemples spécifiques, voir [Exemples - Chargements inline avec des transformations](https://help.qlik.com/fr-FR/sense/May2026/Subsystems/Hub/Content/Sense_Hub/Scripting/inline-loads-qs.htm#ExTransform).
### Configuration de la spécification de format d'un chargement inline
Comme pour les autres tables chargées, vous pouvez modifier la spécification de format de la table inline via des éléments de spécification de format. La spécification de format est ajoutée entre parenthèses. Elle doit être ajoutée après les encadrements de données, mais avant le point-virgule terminant l'instruction LOAD. Parmi les personnalisations que vous pouvez inclure figurent les suivantes :
* Remplacement du délimiteur de type virgule par un autre caractère. Pour des exemples, voir [Exemples - Délimiteurs alternatifs](https://help.qlik.com/fr-FR/sense/May2026/Subsystems/Hub/Content/Sense_Hub/Scripting/inline-loads-qs.htm#ExDelimiter).
Voir : [Delimiter is](https://help.qlik.com/fr-FR/sense/May2026/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptSpecifiers/delimiter.htm)
* Omission d'en-têtes de colonne de table. Pour un exemple, consultez [Exemple - Omission d'en-têtes de colonne](https://help.qlik.com/fr-FR/sense/May2026/Subsystems/Hub/Content/Sense_Hub/Scripting/inline-loads-qs.htm#ExOmitLabels).
Voir : [Labels](https://help.qlik.com/fr-FR/sense/May2026/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptSpecifiers/labels.htm)
* Utilisation d'un autre format de données (par exemple, un format d'enregistrement fixe). Pour un exemple, consultez [Exemple - Chargement d'un autre type de données](https://help.qlik.com/fr-FR/sense/May2026/Subsystems/Hub/Content/Sense_Hub/Scripting/inline-loads-qs.htm#ExChangeFormat).
Voir : [Table format](https://help.qlik.com/fr-FR/sense/May2026/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptSpecifiers/table-format.htm)
Note InformationsToutes les options Table format ne sont pas supportées dans les chargements inline.
* Autorisation de contenu multiligne. Pour un exemple, consultez [Exemple - Contenu multiligne](https://help.qlik.com/fr-FR/sense/May2026/Subsystems/Hub/Content/Sense_Hub/Scripting/inline-loads-qs.htm#ExMultLine).
Voir : [Quotes](https://help.qlik.com/fr-FR/sense/May2026/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptSpecifiers/quotes.htm)
Pour pouvoir utiliser plusieurs éléments de spécification de format dans la même table, séparez-les par des virgules. Par exemple :` (Delimiter is '|', no labels) `
Pour des informations complètes sur la spécification de format, voir [Éléments de spécification du format](https://help.qlik.com/fr-FR/sense/May2026/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptSpecifiers/format-specification-items.htm).
### Opérateurs et autres clauses
De plus, étant donné qu'un chargement inline est une instruction LOAD, vous pouvez combiner d'autres arguments pour l'instruction LOAD dans le chargement inline. Par exemple, utilisez la clause where ou while pour déterminer s'il faut charger ou non une ligne spécifique en fonction du texte qu'elle contient.
De même, vous pouvez également utiliser des opérateurs en dehors du contenu textuel lui-même. Avec des opérateurs, vous pouvez personnaliser la manière dont vous transformez les données inline et également définir le moment où charger ou non certaines données.
Pour un exemple spécifique, voir [Exemple - Opérateurs avec des transformations et des clauses](https://help.qlik.com/fr-FR/sense/May2026/Subsystems/Hub/Content/Sense_Hub/Scripting/inline-loads-qs.htm#ExOpsAndClauses).
## Exemple - Encadrements de données alternatifs
Vous pouvez utiliser des crochets, des guillemets ou des backticks (`) pour encadrer un chargement inline. Cette section en montre un exemple. Pour plus d'informations, consultez [Encadrements et saisie de données](https://help.qlik.com/fr-FR/sense/May2026/Subsystems/Hub/Content/Sense_Hub/Scripting/inline-loads-qs.htm#Enclosure).
#### Script de chargement et résultats
Cet exemple montre comment utiliser des backticks pour encadrer les données inline. Les données de l'exemple contiennent des caractères de type crochet, ce qui rend les crochets incompatibles comme encadrements pour l'instruction LOAD.
Vue d'ensemble
Ouvrez l'Éditeur de chargement de données et ajoutez le script de chargement suivant à une nouvelle section.
Script de chargement
```
DataTable:
Load * inline
`
custom_property, date, amount
[11402], 1/1/2024, 92.99
[11403], 1/2/2024, 102.34
[11404], 1/3/2024, 50.26
[11405], 1/4/2024, 153.69
[11406], 1/5/2024, 75.62
`;
```
Résultats
Chargez les données et ouvrez une feuille. Créez une table et ajoutez ces champs comme dimensions :
* `custom_property`
* `date`
* `amount`
Table de résultats
| custom\_property | date | amount |
| --- | --- | --- |
| [11402] | 1/1/2024 | 92.99 |
| [11403] | 1/2/2024 | 102.34 |
| [11404] | 1/3/2024 | 50.26 |
| [11405] | 1/4/2024 | 153.69 |
| [11406] | 1/5/2024 | 75.62 |
## Exemples - Délimiteurs alternatifs
Vous pouvez utiliser un autre caractère qu'une virgule pour délimiter les valeurs des colonnes de la table. Pour plus d'informations, consultez [Configuration de la spécification de format d'un chargement inline](https://help.qlik.com/fr-FR/sense/May2026/Subsystems/Hub/Content/Sense_Hub/Scripting/inline-loads-qs.htm#FormatSpec).
#### Script de chargement et résultats
Vue d'ensemble
Le remplacement du délimiteur s'avère utile lorsque les données de la table contiennent des virgules, ce qui, sinon, signalerait le passage à la colonne suivante de la table.
Ouvrez l'éditeur de chargement de données et ajoutez le script de chargement ci-dessous à une nouvelle section.
Le script de chargement contient :
* Quatre tables à charger. Il s'agit des suivantes :
* Table1 : le délimiteur est une barre verticale (pipe). Les données de la colonne Phrase contiennent des virgules.
* Table2 : le délimiteur est un point-virgule.
* Table3 : le délimiteur est une barre oblique inversée.
* Table4 : la table est délimitée par une pression sur la touche Tab du clavier. Cette option s'avère utile lorsque vous copiez une table d'un traitement de texte et que vous la collez dans le script.
Le Table1 montre un cas d'utilisation pratique d'un autre délimiteur. Les autres tableaux montrent d'autres options de délimiteur.
Script de chargement
```
Table1:
LOAD * INLINE [
ID|Phrase
1 | 'The transaction was complete, but the order has not yet shipped.'
2 | 'We need to confirm the following details: sales rep number, order status, and shipping priority.'
] (Delimiter is '|');
Table2:
LOAD * INLINE [
Num1:Chr1
1:A
2:B ] (Delimiter is ':');
Table3:
LOAD * INLINE [
Num2\Chr2
1\A
2\B ] (Delimiter is \\);
Table4:
LOAD * INLINE [
Num3 Chr3
1 A
2 B ] (Delimiter is '\t');
```
Résultats
Chargez les données et ouvrez une feuille. Créez quatre tables et ajoutez-y les dimensions comme suit :
* Table1: ID, Phrase
* Table2: Num1, Chr1
* Table3: Num2, Chr2
* Table4: Num3, Chr3
Tableau de résultats : Table1Table1
| ID | Phrase |
| --- | --- |
| 1 | The transaction was complete, but the order has not yet shipped. |
| 2 | We need to confirm the following details: sales rep number, order status, and shipping priority. |
Tableau de résultats : Table2Table2
| Num1 | Chr1 |
| --- | --- |
| 1 | A |
| 2 | B |
Tableau de résultats : Table3Table3
| Num2 | Chr2 |
| --- | --- |
| 1 | A |
| 2 | B |
Tableau de résultats : Table4Table4
| Num3 | Chr3 |
| --- | --- |
| 1 | A |
| 2 | B |
## Exemple - Mélange de chargements inline et de chargements provenant d'autres sources de données
#### Script de chargement et résultats
Vue d'ensemble
Le script suivant commence par charger une série de champs provenant d'un connecteur, puis charge une table inline avec un champ commun et un champ supplémentaire. Ce nouveau champ fournit une autre propriété sur l'élément de ligne qui n'a pas été chargé via la connexion de données. Notez que cela fonctionne bien uniquement lorsqu'il existe un seul nom de champ en commun entre les deux tables. S'il existe plusieurs noms de champ en commun, une clé synthétique est produite.
Dans cet exemple tronqué, nous chargeons une table de détails de commandes provenant d'une connexion de données. Nous utilisons ensuite une table inline pour ajouter un champ supplémentaire, Supplemental Info. Celui-ci peut, par exemple, contenir des détails sur des commentaires spéciaux sur des ID de commande spécifiques.
Script de chargement
```
SET DateFormat='MM/DD/YYYY';
Orders:
LIB CONNECT TO 'My_Generic_Connection';
LOAD PRODUCT_DIVISION_A_ORDER_ID as Order ID,
PRODUCT_DIVISION_A_ORDER_DATE as ISSUE_KEY as Order Date,
PRODUCT_DIVISION_A_TYPE as Product Type,
PRODUCT_DIVISION_A_SALES_MANAGER as Manager,
PRODUCT_DIVISION_A_SHIPPED_STATUS as Shipped Status;
SELECT PRODUCT_DIVISION_A_ORDER_ID,
PRODUCT_DIVISION_A_ORDER_DATE,
PRODUCT_DIVISION_A_TYPE,
PRODUCT_DIVISION_A_SALES_MANAGER,
PRODUCT_DIVISION_A_SHIPPED_STATUS
FROM SourceTable
WITH PROPERTIES (
[...]
);
Orders_Inline_Info:
load * inline [
Order ID,Supplemental Info
PSF-001014,'Bulk order, pending deal with Paracel.'
PSF-001625,'NOTE: Product damaged. Investigation required.'
];
```
Résultats
Après avoir chargé les données, imaginons que nous ajoutions les dimensions suivantes à une table :
* Order ID
* Order Date
* Product Type
* Manager
* Shipped Status
* Supplemental Info
Le graphique obtenu pourrait prendre la forme suivante.
Tableau de résultats : OrdersOrders
| Order ID | Order Date | Product Type | Manager | Shipped Status | Supplemental Info |
| --- | --- | --- | --- | --- | --- |
| PSF-000998 | 1/13/2024 | Electronics | Amanda Honda | Shipped | - |
| PSF-000999 | 1/15/2024 | Automotive | Molly McKenzie | Not Shipped | - |
| PSF-001014 | 1/17/2024 | Home Appliances | Amalia Craig | Undefined | Bulk order, pending deal with Paracel. |
| PSF-001625 | 1/21/2024 | Electronics | Amanda Honda | Undefined | Product damaged. Investigation required. |
Notez comment tous les champs des deux tables peuvent être ajoutés à la même visualisation. Les tables sont associées l'une à l'autre dans le modèle de données.
## Exemple - Omission d'en-têtes de colonne
Modifiez la spécification de format de sorte à charger une table inline sans définir d'en-têtes de colonne. Cela s'effectue via la spécification labels (en la configuration sur une valeur no labels). Pour plus d'informations, consultez [Configuration de la spécification de format d'un chargement inline](https://help.qlik.com/fr-FR/sense/May2026/Subsystems/Hub/Content/Sense_Hub/Scripting/inline-loads-qs.htm#FormatSpec).
Lorsque vous chargez une table sans définir de noms de colonne, les noms de colonne définis par le système sont automatiquement utilisés.
#### Script de chargement et résultats
Vue d'ensemble
Cet exemple montre comment charger une table inline sans définir de noms de colonne.
Ouvrez l'Éditeur de chargement de données et ajoutez le script de chargement suivant à une nouvelle section.
Script de chargement
```
Expenses:
Load * inline
[
1,Category1,40566.49
2,Category2,3504.54
3,Category3,593206.30
] (no labels);
```
Résultats
Chargez les données et ouvrez une feuille. Créez une table et ajoutez ces champs comme dimensions :
* @1
* @2
* @3
Table de résultats
| @1 | @2 | @3 |
| --- | --- | --- |
| 1 | Category1 | 40566.49 |
| 2 | Category2 | 3504.54 |
| 3 | Category3 | 593206.30 |
## Exemple - Chargement d'un autre type de données
Cet exemple montre comment charger une table inline dans un format d'enregistrement fixe. Consultez [Configuration de la spécification de format d'un chargement inline](https://help.qlik.com/fr-FR/sense/May2026/Subsystems/Hub/Content/Sense_Hub/Scripting/inline-loads-qs.htm#FormatSpec).
#### Script de chargement et résultats
Vue d'ensemble
Ouvrez l'éditeur de chargement de données et ajoutez le script de chargement ci-dessous à une nouvelle section.
Le script de chargement contient :
* Instruction inline load définissant la table DataTable.
* Utilisation de fix (dans le cadre de la spécification Table format) pour indiquer que les données à charger se présentent dans un format d'enregistrement fixe.
Script de chargement
```
DataTable:
LOAD
"@1:4",
"@5:8",
"@9:12",
"@13:16"
INLINE [
a b c d
1 2 3 4
x y z w
] (fix, utf8, embedded labels);
```
Résultats
Chargez les données et ouvrez une feuille. Créez une table et ajoutez ces champs comme dimensions :
* a
* b
* c
* d
Table de résultats
| a | b | c | d |
| --- | --- | --- | --- |
| 1 | 2 | 3 | 4 |
| x | y | z | w |
## Exemple - Contenu multiligne
Cet exemple montre comment saisir un contenu de champ multiligne dans une table inline. Consultez [Configuration de la spécification de format d'un chargement inline](https://help.qlik.com/fr-FR/sense/May2026/Subsystems/Hub/Content/Sense_Hub/Scripting/inline-loads-qs.htm#FormatSpec).
#### Script de chargement et résultats
Vue d'ensemble
Ouvrez l'éditeur de chargement de données et ajoutez le script de chargement ci-dessous à une nouvelle section.
Le script de chargement contient :
* Chargement inline simple permettant de définir la table T1.
* Utilisation du spécificateur Quotes (avec la valeur msq) pour prendre en charge le contenu multiligne.
* Valeurs de longueur spécifiées en pieds et en pouces.
* Le symbole de guillemet double (") indique la fin d'une entrée multiligne. Dans cet exemple, le même symbole est également utilisé pour indiquer des valeurs en pouces. Cet exemple montre la syntaxe et le comportement qui en découle si vous devez utiliser les deux dans la même instruction LOAD. En fait, la saisie du symbole " pour deux caractères consécutifs ("") indique que le code doit être interprété comme une seule instance de texte du symbole.
Script de chargement
```
T1:
Load *, recno() as ID inline [
Length
"1' 2""
22' 10"""
14' 8" ] (msq);
```
Résultats
Chargez les données et ouvrez une feuille. Créez une table et ajoutez ces champs comme dimensions :
* ID
* Length
Pour afficher le contenu multiligne comme souhaité, le paramètre Renvoi à la ligne du texte des cellules doit être activé dans le panneau des propriétés. De plus, le thème de l'application (our les paramètres de la visualisation) doit accepter la Hauteur de ligne (des lignes) suffisante.
Table de résultats
| ID | Length |
| --- | --- |
| 1 | 1' 2"
22' 10" |
| 2 | 14' 8" |
Dans le tableau ci-dessus, l'enregistrement avec une valeur ID égal à 1 inclut un contenu multiligne.
## Exemples - Chargements inline avec des transformations
Ces exemples montrent comment effectuer des calculs sur des champs chargés inline pour créer de nouveaux champs dans le modèle de données.
Pour plus d'informations, consultez [Transformations de données](https://help.qlik.com/fr-FR/sense/May2026/Subsystems/Hub/Content/Sense_Hub/Scripting/inline-loads-qs.htm#Transform).
#### Exemple : Changement de nom simple d'un champ
Vue d'ensemble
Ouvrez l'Éditeur de chargement de données et ajoutez le script de chargement suivant à une nouvelle section.
Script de chargement
```
ORDERS:
Load Original as Updated,
* Inline
[
Original
ProductA
ProductB
ProductC
];
```
Résultats
Chargez les données et ouvrez une feuille. Créez une table et ajoutez ces champs comme dimensions :
* Original
* Updated
Table de résultats
| Original | Updated |
| --- | --- |
| ProductA | ProductA |
| ProductB | ProductB |
| ProductC | ProductC |
#### Exemple : Insertion simple d'un champ d'ID
Vue d'ensemble
Cet exemple montre comment définir un champ calculé pour indiquer l'ID de chaque ligne de données, sans avoir à saisir manuellement chaque valeur d'ID.
Ouvrez l'Éditeur de chargement de données et ajoutez le script de chargement suivant à une nouvelle section.
Script de chargement
```
ORDERS:
Load RowNo() as ID,
* Inline
[
ProductName
A
B
C
D
E
];
```
Résultats
Chargez les données et ouvrez une feuille. Créez une table et ajoutez ces champs comme dimensions :
* ID
* ProductName
Table de résultats
| ID | ProductName |
| --- | --- |
| 1 | A |
| 2 | B |
| 3 | C |
| 4 | D |
| 5 | E |
#### Exemple : Configuration d'LOAD instructions pour gérer les transformations
Vue d'ensemble
Cet exemple montre plusieurs manières d'appliquer une simple transformation à des données inline. Vous pouvez utiliser une ou plusieurs instructions LOAD et configurer la syntaxe de différentes manières afin de déterminer si une transformation remplace ou non le champ d'origine ou si le champ d'origine et le nouveau champ sont tous les deux chargés.
Notez surtout les variations des éléments suivants et comment elles affectent le résultat :
* Nombre d'instructions LOAD dans la table.
* Présence ou absence de symbole \* (charge tous les champs suivants).
* Présence ou absence de virgules (symbole ,).
Ouvrez l'éditeur de chargement de données et ajoutez le script de chargement ci-dessous à une nouvelle section.
Le script de chargement contient :
* Quatre tables, chacune référençant les mêmes données. Les noms de champ sont différents.
* DerivedYears1 : utilise deux instructions LOAD pour charger une colonne inline et une colonne contenant une transformation de la colonne inline.
* DerivedYears2 : utilise deux instructions LOAD. Le script charge une colonne inline, puis charge un champ calculé transformé à partir de la colonne d'origine. Avec la deuxième instruction LOAD, la colonne d'origine n'est pas chargée dans la table, entraînant effectivement le remplacement du champ d'origine par le nouveau champ.
* DerivedYears3 : utilise une seule instruction LOAD pour charger la colonne inline d'origine et une colonne transformée.
* DerivedYears4 : utilise une seule instruction LOAD pour définir un champ inline et une transformation de ce champ d'origine. Seul le champ transformé est chargé dans la table.
Script de chargement
```
DerivedYears1:
Load *,
Year(initial_date1) as derived_year1
;
Load
* inline [
initial_date1
'1/1/2022'
'1/1/2023'
'1/1/2024'
];
DerivedYears2:
Load
Year(initial_date2) as derived_year2
;
Load
* inline [
initial_date2
'1/1/2022'
'1/1/2023'
'1/1/2024'
];
DerivedYears3:
Load Year(initial_date3) as derived_year3,
* inline [
initial_date3
'1/1/2022'
'1/1/2023'
'1/1/2024'
];
DerivedYears4:
Load Year(initial_date4) as derived_year4
inline [
initial_date4
'1/1/2022'
'1/1/2023'
'1/1/2024'
];
```
Résultats
Chargez les données et ouvrez une feuille. Créez trois tables et ajoutez-y les dimensions comme suit :
* DerivedYears1: initial\_date1, derived\_year1
* DerivedYears2 : initial\_date2
* DerivedYears3: initial\_date3, derived\_year3
Tableau de résultats : DerivedYears1DerivedYears1
| initial\_date1 | derived\_year1 |
| --- | --- |
| 1/1/2022 | 2022 |
| 1/1/2023 | 2023 |
| 1/1/2024 | 2024 |
Tableau de résultats : DerivedYears2DerivedYears2
| derived\_year2 |
| --- |
| 2022 |
| 2023 |
| 2024 |
Tableau de résultats : DerivedYears3DerivedYears3
| initial\_date3 | derived\_year3 |
| --- | --- |
| 1/1/2022 | 2022 |
| 1/1/2023 | 2023 |
| 1/1/2024 | 2024 |
Tableau de résultats : DerivedYears4DerivedYears4
| derived\_year4 |
| --- |
| 2022 |
| 2023 |
| 2024 |
#### Exemple : Modification du contenu d'un champ
Vue d'ensemble
Supposons que vous colliez dans l'éditeur de script des informations provenant d'un fichier texte volumineux, puis que vous souhaitiez appliquer un traitement supplémentaire aux enregistrements du jeu de données. Par exemple, vous voulez supprimer certains caractères et préfixes et capitaliser chaque terme.
Ouvrez l'éditeur de chargement de données et ajoutez le script de chargement ci-dessous à une nouvelle section.
Le script de chargement contient :
* Table inline, Transformations, dans laquelle une transformation est définie de sorte à modifier le contenu textuel d'un champ. Le texte en cours de transformation est ajouté après cela.
* Deux LOAD déclarations. Avec la configuration de l'exemple, seul le champ dérivé ProductName\_Trimmed est chargé dans la table.
Script de chargement
```
Transformations:
Load
Capitalize(TextBetween(OrigColumn, '{','}')) as ProductName_Trimmed;
Load * inline [
OrigColumn
Product: {soft drinks and other beverages}
Product: {snack food}
Product: {electronics and video games}
];
```
Résultats
Chargez les données et ouvrez une feuille. Créez une table et ajoutez ce champ comme dimension : ProductName\_Trimmed.
Table de résultats
| ProductName\_Trimmed |
| --- |
| Soft Drinks And Other Beverages |
| Snack Food |
| Electronics And Video Games |
## Exemple - Opérateurs avec des transformations et des clauses
Vous pouvez utiliser des opérateurs pour définir des transformations et des clauses spécifiques dans l'instruction LOAD. Pour plus d'informations, consultez [Opérateurs et autres clauses](https://help.qlik.com/fr-FR/sense/May2026/Subsystems/Hub/Content/Sense_Hub/Scripting/inline-loads-qs.htm#OpsAndClauses).
[Opérateurs](https://help.qlik.com/fr-FR/sense/May2026/Subsystems/Hub/Content/Sense_Hub/Scripting/Operators/operators.htm)
#### Script de chargement et résultats
Vue d'ensemble
Ouvrez l'éditeur de chargement de données et ajoutez le script de chargement ci-dessous à une nouvelle section.
Le script de chargement contient :
* Chargement inline simple permettant de définir la table Purchases.
* Insertion d'un champ calculé, OrderSize. Ce champ est une transformation du champ amount du jeu de données inline. Il catégorise des achats comme peu importants ou importants, suivant que le montant dépasse ou non $2000.00.
* Clause where empêchant le chargement des enregistrements lorsque la valeur de amount est inférieure à $0.05.
Script de chargement
```
Purchases:
Load
If(amount<2000,'Small Purchase','Large Purchase') as OrderSize,
* inline
[
ID, amount
1,2660.39
2,100.01
3,500.42
4,5023.99
5,0.04
6,2002.39
7,31034.53
8,1643.58
9,3993.65
10,614.34
11,675.93
]
WHERE
amount>0.05
;
```
Résultats
Chargez les données et ouvrez une feuille. Créez une table et ajoutez ces champs comme dimensions :
* ID
* amount
* OrderSize
Table de résultats
| ID | amount | OrderSize |
| --- | --- | --- |
| 1 | 2660.39 | Large Purchase |
| 2 | 100.01 | Small Purchase |
| 3 | 500.42 | Small Purchase |
| 4 | 5023.99 | Large Purchase |
| 6 | 2002.39 | Large Purchase |
| 7 | 31034.53 | Large Purchase |
| 8 | 1643.58 | Small Purchase |
| 9 | 3993.65 | Large Purchase |
| 10 | 614.34 | Small Purchase |
| 11 | 675.93 | Small Purchase |
Dans le tableau ci-dessus, la transaction avec un ID égal à 5 n'a pas été chargée dans la table. Cela est dû au fait que la valeur amount est inférieure à $0.05.
## Exemple - Création de valeurs nulles dans une table inline
Cet exemple montre comment utiliser la variable NullInterpret pour créer des valeurs nulles dans vos données inline.
[NullInterpret](https://help.qlik.com/fr-FR/sense/May2026/Subsystems/Hub/Content/Sense_Hub/Scripting/ValueHandlingVariables/NullInterpret.htm)
#### Script de chargement et résultats
Vue d'ensemble
Ouvrez l'éditeur de chargement de données et ajoutez le script de chargement ci-dessous à une nouvelle section.
Le script de chargement contient :
* Chargement inline simple permettant de définir la table T2.
* Variable NullInterpret définie sous forme de deux guillemets simples. Lors du chargement du script, les enregistrements contenant cette valeur sont traités comme des valeurs nulles.
Script de chargement
```
set nullinterpret = '';
T2:
Load * inline [
Test
''
x ];
```
Résultats
Chargez les données et ouvrez une feuille. Créez une table et ajoutez ce champ comme dimension : Test.
Table de résultats
| Test |
| --- |
| x |
Dans le tableau ci-dessus, le premier enregistrement est une valeur nulle. Par conséquent, il n'est pas inclus dans la visualisation. Les valeurs nulles existant dans les tables avec des dimensions supplémentaires seraient indiquées par un symbole -.
## Plus d'exemples
Pour d'autres exemples, voir [Load](https://help.qlik.com/fr-FR/sense/May2026/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptRegularStatements/Load.htm).
SUPPORTS D APPRENTISSAGE ASSOCIÉS
* [Introduction à l'éditeur de chargement de données](https://help.qlik.com/lnk/Intro_Data_Load_Editor_QS)
## En savoir plus
* [Load](https://help.qlik.com/fr-FR/sense/May2026/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptRegularStatements/Load.htm)
* [Éléments de spécification du format](https://help.qlik.com/fr-FR/sense/May2026/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptSpecifiers/format-specification-items.htm)
* [Introduction à l'éditeur de chargement de données](https://help.qlik.com/lnk/Intro_Data_Load_Editor_QS)