ComposantsComponents › TraitementProcessing
Le composant central des transformations. Dans un éditeur graphique, il relie un flux principal et des lookups (flux de référence) à une ou plusieurs sorties : chaque colonne de sortie reçoit une expression Java. Entre les deux : des jointures sur des clés (charger le lookup une fois ou à chaque ligne, garder une, la première ou toutes les correspondances, jointure interne ou externe), des variables calculées une fois par ligne, des filtres sur les entrées et les sorties, et des sorties de rejet. Pour des documents XML, voyez le tXMLMap. The central transformation component. In a graphical editor, it connects a main flow and lookups (reference flows) to one or more outputs: each output column gets a Java expression. In between: joins on keys (load the lookup once or at each row, keep one, the first or all the matches, inner or outer join), variables computed once per row, filters on the inputs and the outputs, and reject outputs. For XML documents, see the tXMLMap.
EntréeInput
Main un flux, obligatoire : le principal, lu ligne à ligne.one flow, required: the main one, read row by row.
Lookup autant que nécessaire : les liens suivants, chargés avant le flux principal (ou à chaque ligne).as many as needed: the next links, loaded before the main flow (or at each row).
SortieOutput
Main au moins une : une par table de sortie de l'éditeur, qui donne son nom au lien. Les rejets (sortie, jointure interne, erreurs) sont des sorties comme les autres.at least one: one per output table of the editor, which gives its name to the link. Rejects (output, inner join, errors) are outputs like the others.
Déclencheurs en sortieOutput triggers
AucunNone
On Component Ok, On Component Error et Run if sont fermés (MAX_OUTPUT="0") : enchaînez sur le sous-job.On Component Ok, On Component Error and Run if are closed (MAX_OUTPUT="0"): chain on the subjob.
Le lookup est chargé en mémoire avant que le flux principal commence (son sous-job tourne d'abord), puis chaque ligne principale y cherche sa correspondance par la clé de jointure, et la sortie reprend des colonnes des deux. The lookup is loaded in memory before the main flow starts (its subjob runs first), then each main row looks for its match through the join key, and the output takes columns from both.
Chaque sortie a son filtre ; une sortie de rejet reçoit les lignes qu'aucune autre n'a prises. Sans filtre, chaque sortie reçoit chaque ligne. Each output has its filter; a reject output gets the rows that no other one took. Without a filter, each output gets each row.
row3…). Le menu Ligne du clic droit sur le tMap propose aussi les sorties déjà créées dans l'éditeur.
Draw the output links: each one creates an output table named after the link (row3…). The Row menu of the right click on the tMap also offers the outputs already created in the editor.
Tout le travail du composant se fait dans son éditeur, enregistré dans le job avec le nœud (nodeData de type MapperData). Dans le Studio, la plupart de ses réglages restent en anglais quelle que soit la langue ; Talaxie les traduit. La page donne le nom anglais, puis le libellé français de Talaxie entre parenthèses.
All the work of the component is done in its editor, saved in the job with the node (nodeData of type MapperData). In the Studio, most of its settings stay in English whatever the language; Talaxie translates them. The page gives the English name, then the French label of Talaxie in brackets.
Une table par lien entrant : le flux principal en tête, puis les lookups, dans l'ordre où ils sont traités (modifiable). Ses colonnes sont le schéma du lien, modifiable dans le composant d'amont. Sur un lookup, la colonne Expr. key (Clé d'expr.) reçoit les clés de jointure. One table per incoming link: the main flow first, then the lookups, in the order they are processed (which can be changed). Its columns are the schema of the link, editable in the upstream component. On a lookup, the Expr. key column gets the join keys.
La table Var : une expression, un type et un nom par variable. Elles sont calculées pour chaque ligne, de haut en bas, après les lookups ; on les lit par Var.nom dans les sorties, les filtres de sortie et les variables suivantes.
The Var table: one expression, one type and one name per variable. They are computed for each row, top to bottom, after the lookups; they are read through Var.name in the outputs, the output filters and the following variables.
Une table par sortie (ajouter, retirer, réordonner, renommer par son titre). Chaque colonne a son expression ; une expression vide donne null, ou la valeur par défaut d'un type primitif. En bas, deux onglets : Schema editor (Éditeur de schéma : schémas d'entrée et de sortie, colonnes, types, longueurs, modèles de date) et Expression editor (Éditeur d'expression : texte complet de l'expression choisie).
One table per output (add, remove, reorder, rename through its title). Each column has its expression; an empty expression gives null, or the default value of a primitive type. At the bottom, two tabs: Schema editor (input and output schemas, columns, types, lengths, date patterns) and Expression editor (full text of the chosen expression).
Une expression est du Java qui rend une valeur du type de la colonne : row1.qty * row3.price, row2.name == null ? "unknown" : row2.name.toUpperCase(), Var.amount, context.folder, (String)globalMap.get("key"), une routine (StringHandling.UPCASE(row1.name)). Un lien relie chaque colonne utilisée à l'expression qui l'utilise.
An expression is Java code that returns a value of the column type: row1.qty * row3.price, row2.name == null ? "unknown" : row2.name.toUpperCase(), Var.amount, context.folder, (String)globalMap.get("key"), a routine (StringHandling.UPCASE(row1.name)). A link connects each column used to the expression that uses it.
Le bouton … d'une expression, d'un filtre ou d'une clé GlobalMap ouvre le constructeur d'expression : les routines par catégorie avec leur aide, les colonnes d'entrée et les variables, et une zone de test qui calcule l'expression avec des valeurs saisies pour les colonnes utilisées. The … button of an expression, a filter or a GlobalMap key opens the expression builder: the routines by category with their help, the input columns and the variables, and a test area that computes the expression with values typed for the columns used.
* et ? acceptés, casse ignorée).
The search of the header finds a text in the names and the expressions (next, previous). The Enable/disable column name filter button of a table only shows its columns whose name matches (* and ? accepted, case ignored).
Dans un lookup, l'expression d'une colonne (souvent une colonne principale glissée dessus) est sa clé : la ligne du lookup correspond quand la valeur de la colonne est égale à celle de l'expression. Plusieurs clés se combinent (toutes doivent être égales). Les lookups sont traités dans l'ordre de l'éditeur : une clé peut utiliser le flux principal et les lookups placés au-dessus. In a lookup, the expression of a column (often a main column dragged onto it) is its key: the lookup row matches when the column value equals the value of the expression. Several keys combine (all must be equal). Lookups are processed in the order of the editor: a key can use the main flow and the lookups placed above.
La comparaison est celle de Java (equals) : sensible à la casse pour une chaîne ; l'expression doit avoir le type de la colonne du lookup. Une clé BigDecimal ignore par défaut les zéros de fin (exemple). La première clé saisie fait passer le Match Model de All rows à Unique match ; sans plus aucune clé, il revient à All rows.
The comparison is the Java one (equals): case sensitive for a string; the expression must have the type of the lookup column. A BigDecimal key ignores trailing zeros by default (example). The first key typed switches the Match Model from All rows to Unique match; with no key left, it goes back to All rows.
Chaque table d'entrée et de sortie a le bouton Enable/disable expression filter (Activer/désactiver le filtre d'expression) : une condition Java booléenne, sous l'en-tête de la table (exemples). Each input and output table has the Enable/disable expression filter button: a boolean Java condition, below the header of the table (examples).
null en jointure externe, rejet en jointure interne.Lookup: applied after the search, it can also read the main columns. A found row that does not meet it counts as missing: null in an outer join, reject in an inner join.Chaque lookup et chaque sortie a ce bouton (⚙, Paramètres du tMap) ; l'entrée principale n'en a pas. Il déplie un tableau Property / Value ; une valeur changée est surlignée et comptée sur le bouton. Each lookup and each output has this button (⚙); the main input has none. It unfolds a Property / Value table; a changed value is highlighted and counted on the button.
| RéglageSetting | DéfautDefault | VisibleShown | Description |
|---|---|---|---|
| Lookup Model (Modèle de lookup)lookupMode | Load once | Lookup |
Load once (Charger une fois) : le lookup est lu en entier et gardé en mémoire avant le flux principal. Reload at each row (Recharger à chaque ligne) : son sous-job est relancé pour chaque ligne principale, après avoir placé les clés GlobalMap Key dans globalMap. Reload at each row (cache) (Recharger à chaque ligne (cache)) : de même, mais une clé de jointure déjà trouvée est servie par un cache, sans recharger (exemple).
Load once: the lookup is read entirely and kept in memory before the main flow. Reload at each row: its subjob is run again for each main row, after putting the GlobalMap Key keys into globalMap. Reload at each row (cache): the same, but a join key already found is served by a cache, without reloading (example).
|
| Match Model (Modèle de correspondance)matchingMode | All rows ; Unique match dès qu'il y a une cléAll rows; Unique match as soon as there is a key | Lookup | Unique match (Correspondance unique) : une seule ligne, la dernière chargée parmi celles qui correspondent. First match (Première correspondance) : la première. All matches (Toutes les correspondances) : une ligne de sortie par correspondance. All rows (Toutes les lignes) : chaque ligne principale est jointe à toutes les lignes du lookup, les clés sont ignorées (exemple). Unique match: one single row, the last loaded among the matching ones. First match: the first one. All matches: one output row per match. All rows: each main row is joined to all the lookup rows, the keys are ignored (example). |
| Join Model (Modèle de jointure)innerJoin | Left Outer Join | Lookup |
Left Outer Join (Jointure externe gauche) : une ligne sans correspondance passe, les colonnes du lookup à null. Inner Join (Jointure interne) : elle est écartée, ou envoyée à une sortie Catch lookup inner join reject (exemple).
Left Outer Join: a row without match goes through, the lookup columns set to null. Inner Join: it is dropped, or sent to a Catch lookup inner join reject output (example).
|
| Store temp data (Stocker les données temporaires)persistent | false | Lookup ; grisé en Reload at each row (cache)Lookup; greyed out in Reload at each row (cache) | Le lookup est écrit trié sur disque, dans le dossier des réglages du tMap, au lieu d'être gardé en mémoire. Avec une clé, le flux principal est lui aussi trié sur disque par la clé : les lignes sortent dans l'ordre de la clé (exemple). The lookup is written sorted on disk, in the folder of the tMap settings, instead of being kept in memory. With a key, the main flow is also sorted on disk by the key: the rows come out in key order (example). |
| Catch output reject (Capturer les rejets de sortie)reject | false | SortieOutput | La sortie reçoit les lignes qu'aucune sortie filtrée n'a prises. Il faut que toutes les autres sorties aient un filtre : une seule sortie sans filtre prend chaque ligne, et le rejet ne reçoit plus rien (exemple). The output gets the rows that no filtered output took. All the other outputs must have a filter: a single output without filter takes each row, and the reject gets nothing any more (example). |
| Catch lookup inner join reject (Capturer les rejets de jointure interne)rejectInnerJoin | false | SortieOutput | La sortie reçoit les lignes écartées par une jointure interne ; ses expressions lisent les colonnes principales (celles du lookup sont vides). The output gets the rows dropped by an inner join; its expressions read the main columns (the lookup ones are empty). |
En Reload at each row, avec ou sans cache, le lookup montre sous son en-tête une table globalMap Key (Clé globalMap) : une expression (la valeur, souvent une colonne principale glissée dessus) et une clé, une chaîne entre guillemets ("myKey1" à la création, bouton +). Pour chaque ligne principale, le tMap fait globalMap.put(clé, expression), puis relance le sous-job du lookup, dont la source lit la valeur : une requête "SELECT … WHERE id = " + globalMap.get("id"), un nom de fichier, une valeur de tFixedFlowInput.
In Reload at each row, with or without cache, the lookup shows below its header a globalMap Key table: an expression (the value, often a main column dragged onto it) and a key, a quoted string ("myKey1" on creation, + button). For each main row, the tMap does globalMap.put(key, expression), then runs the lookup subjob again, whose source reads the value: a query "SELECT … WHERE id = " + globalMap.get("id"), a file name, a tFixedFlowInput value.
Le cache demande une clé de jointure (le Studio signale sinon une configuration invalide). D'après le code généré, seules les lignes trouvées y entrent : une clé sans correspondance recharge le lookup à chaque fois. The cache needs a join key (otherwise the Studio reports an invalid configuration). Per the generated code, only the rows found go into it: a key without match reloads the lookup each time.
Le bouton de l'en-tête de l'éditeur (Configurer le tMap) ouvre Property Settings (Paramètres des propriétés), écrits dans des paramètres du composant : The button in the header of the editor (Setup the configurations of tMap) opens Property Settings, written in parameters of the component:
DIE_ON_ERROR, coché) : une exception dans une expression arrête le job. Décoché, l'éditeur ajoute une sortie ErrorReject (errorMessage, errorStackTrace, en lecture seule, plus vos colonnes) qui reçoit la ligne en erreur, et le job continue ; recoché, elle est retirée (exemple).Die on error (DIE_ON_ERROR, checked): an exception in an expression stops the job. Unchecked, the editor adds an ErrorReject output (errorMessage, errorStackTrace, read-only, plus your columns) that gets the row in error, and the job goes on; checked again, it is removed (example).LKUP_PARALLELIZE, décoché ; dans le Studio, et dans Talaxie à partir de 9.0.7) : les lookups sont chargés en même temps, par un tParallelize ajouté à la génération.Lookup in parallel (LKUP_PARALLELIZE, unchecked; in the Studio, and in Talaxie from 9.0.7): the lookups are loaded at the same time, through a tParallelize added at generation.ENABLE_AUTO_CONVERT_TYPE, décoché) : voir l'exemple.Enable Auto-Conversion of types (ENABLE_AUTO_CONVERT_TYPE, unchecked): see the example.temp du workspace) et Max buffer size (nb of rows) (taille du tampon, 2000000), aussi dans l'onglet Composant.Store on disk: Temp data directory path (empty: the temp folder of the workspace) and Max buffer size (nb of rows) (2000000), also in the Component tab.L'éditeur de Talaxie reprend les tables, les liens, les variables, les clés de jointure, les réglages des tables, les filtres, le glisser-déposer, Auto map, la recherche, le constructeur d'expression et les Property Settings du Studio, avec en plus annuler et rétablir. The Talaxie editor takes over the tables, links, variables, join keys, table settings, filters, drag and drop, Auto map, search, expression builder and Property Settings of the Studio, with undo and redo on top.
null (voir les erreurs). Et la première clé de jointure ne faisait pas passer All rows à Unique match : le lookup restait en All rows et la clé était ignorée (exemple) ; avec Talaxie 9.0.6, choisissez le Match Model vous-même.
Up to Talaxie 9.0.6, the GlobalMap keys of a reloaded lookup were lost on the first save of the job, even without touching the tMap: the lookup source then read null (see the errors). And the first join key did not switch All rows to Unique match: the lookup stayed in All rows and the key was ignored (example); with Talaxie 9.0.6, choose the Match Model yourself.
Ce qui reste différent du Studio :What remains different from the Studio:
* et ?, cherche aussi dans les filtres et sait tout surligner.The search covers names and expressions, as plain text; the Studio one accepts * and ?, also searches the filters and can highlight everything.L'essentiel est dans l'éditeur. Le nom technique, en gris, est celui du paramètre dans le fichier du job. Most of it is in the editor. The technical name, in grey, is the parameter name in the job file.
| ParamètreSetting | DéfautDefault | VisibleShown | Description |
|---|---|---|---|
| Éditeur de mappingMap EditorMAP | — | ToujoursAlways | Ouvre l'éditeur, comme un double clic sur le composant. Talaxie 9.0.6 n'affiche pas ce bouton : double-cliquez. Opens the editor, like a double click on the component. Talaxie 9.0.6 does not show this button: double-click. |
| Les liens de mapping s'affichent commeMapping links display asLINK_STYLE | videempty | ToujoursAlways | Dessin des liens dans l'éditeur du Studio : Auto, Courbes, Lignes (rapide) ; vide, le Studio prend sa préférence. Sans effet sur le job ; ignoré par l'éditeur de Talaxie. Drawing of the links in the Studio editor: Auto, Curves, Lines (fast); empty, the Studio takes its preference. No effect on the job; ignored by the Talaxie editor. |
| Chemin du répertoire des données temporairesTemp data directory pathTEMPORARY_DATA_DIRECTORY | videempty | Toujours (groupe Stocker sur le disque)Always (Store on disk group) |
Dossier des fichiers des lookups en Store temp data ; vide, le dossier temp du workspace. Une expression Java (context.folder + "/tmp").
Folder of the files of the lookups in Store temp data; empty, the temp folder of the workspace. A Java expression (context.folder + "/tmp").
|
| AperçuPreviewPREVIEW | — | ToujoursAlways | Image du mapping dans le Studio ; non affichée dans Talaxie 9.0.6. Image of the mapping in the Studio; not shown in Talaxie 9.0.6. |
| Die on errorDIE_ON_ERROR | true | Jamais (Property Settings)Never (Property Settings) |
Lu par le code généré : à false, la ligne en erreur va dans la sortie ErrorReject (exemple).
Read by the generated code: set to false, the row in error goes to the ErrorReject output (example).
|
| Lookup in parallelLKUP_PARALLELIZE | false | Jamais (Property Settings du Studio)Never (Studio Property Settings) | Charge les lookups en parallèle. Le job de l'exemple 4, lancé avec ce réglage, donne la même sortie. Loads the lookups in parallel. The job of example 4, run with this setting, gives the same output. |
| Enable Auto-Conversion of typesENABLE_AUTO_CONVERT_TYPE | false | Jamais (Property Settings)Never (Property Settings) | Conversion automatique d'une colonne vers le type de la sortie (exemple). Automatic conversion of a column to the type of the output (example). |
| Levenshtein, JaccardLEVENSHTEIN, JACCARD | 0 | JamaisNever | Poids d'un Auto map par ressemblance des noms, réglables seulement dans l'édition commerciale du Studio. À 0, Auto map relie les noms identiques. Weights of an Auto map by name similarity, only settable in the commercial edition of the Studio. At 0, Auto map connects identical names. |
| ParamètreSetting | DéfautDefault | VisibleShown | Description |
|---|---|---|---|
| Taille maximale de la mémoire tampon (nombre de lignes)Max buffer size (nb of rows)ROWS_BUFFER_SIZE | 2000000 | Toujours (obligatoire)Always (required) | Avec Store temp data : nombre de lignes gardées en mémoire avant d'être triées et écrites dans un fichier temporaire. Plus petit : moins de mémoire, plus de fichiers. With Store temp data: number of rows kept in memory before being sorted and written to a temporary file. Smaller: less memory, more files. |
| Ignorer les zéros de fin pour BigDecimalIgnore trailing zeros for BigDecimalCHANGE_HASH_AND_EQUALS_FOR_BIGDECIMAL | OuiYes | ToujoursAlways |
Une clé de jointure BigDecimal est comparée sans ses zéros de fin (1.5 = 1.50). Décoché, la comparaison de Java (BigDecimal.equals) les distingue (exemple).
A BigDecimal join key is compared without its trailing zeros (1.5 = 1.50). Unchecked, the Java comparison (BigDecimal.equals) tells them apart (example).
|
Avec All matches ou All rows, les étapes 3 et 4 se répètent pour chaque ligne trouvée. With All matches or All rows, steps 3 and 4 are repeated for each row found.
Chaque lookup est chargé par un composant ajouté à la génération, tAdvancedHash, qui garde ses lignes en mémoire (ou sur disque avec Store temp data) ; il demande notamment advancedPersistentLookupLib-1.5. Avec un lookup sur disque, le code généré découpe le composant en tMap_1_TMAP_OUT et tMap_1_TMAP_IN, qui apparaissent dans les messages d'erreur. Les jobs des exemples ont tourné dans Talaxie, en Java 21, y compris sur disque et en parallèle.
Each lookup is loaded by a component added at generation, tAdvancedHash, which keeps its rows in memory (or on disk with Store temp data); it asks among others for advancedPersistentLookupLib-1.5. With a lookup on disk, the generated code splits the component into tMap_1_TMAP_OUT and tMap_1_TMAP_IN, which appear in error messages. The jobs of the examples ran in Talaxie, on Java 21, including on disk and in parallel.
Aucune : le composant ne déclare pas de variable (RETURNS vide), pas même NB_LINE. Comptez les lignes sur les composants suivants (tLogRow_1_NB_LINE…) ou dans une variable de la table Var. Le tMap écrit seulement dans globalMap les clés GlobalMap d'un lookup rechargé.
None: the component declares no variable (empty RETURNS), not even NB_LINE. Count the rows on the next components (tLogRow_1_NB_LINE…) or in a variable of the Var table. The tMap only writes into globalMap the GlobalMap keys of a reloaded lookup.
Les flux viennent de tFixedFlowInput en mode tableau, sauf mention. Les tLogRow sont en mode tableau, ou en mode simple (séparateur |, null affiché vide) quand l'ordre des lignes compte. Les sorties sont celles de la console, copiées depuis une exécution des jobs dans Talaxie.
The flows come from tFixedFlowInput components in table mode, unless stated. The tLogRow components are in table mode, or in basic mode (separator |, null printed empty) when the order of the rows matters. The outputs are the console ones, copied from a run of the jobs in Talaxie.
Commandes (flux principal, customer_id et qty en Integer) :Orders (main flow, customer_id and qty as Integer):
| order_id | customer_id | product | qty |
|---|---|---|---|
| A-1 | 1 | Pen | 2 |
| A-2 | 2 | Ink | 1 |
| A-3 | 9 | Pad | 5 |
| A-4 | 1 | Ink | 3 |
Clients (lookup, customer_id en Integer) ; le client 9 n'existe pas :Customers (lookup, customer_id as Integer); customer 9 does not exist:
| customer_id | name | city |
|---|---|---|
| 1 | Ada | Paris |
| 2 | Grace | Lyon |
| 3 | Alan | Nice |
Produits (lookup, price en Double) :Products (lookup, price as Double):
| product | price |
|---|---|
| Pen | 1.5 |
| Ink | 4.0 |
| Pad | 2.5 |
Commandes (row1) et clients (row2). Clé : la colonne customer_id du lookup reçoit l'expression row1.customer_id ; Unique match, Left Outer Join. Sortie out1 : row1.order_id, row2.name, row2.city, row1.product, row1.qty.
Orders (row1) and customers (row2). Key: the customer_id column of the lookup gets the expression row1.customer_id; Unique match, Left Outer Join. out1 output: row1.order_id, row2.name, row2.city, row1.product, row1.qty.
Left Outer Join : A-3, client inconnu, passe avec null.Left Outer Join: A-3, unknown customer, goes through with null.
.--------+-----+-----+-------+---. | tLogRow_1 | |=-------+-----+-----+-------+--=| |order_id|name |city |product|qty| |=-------+-----+-----+-------+--=| |A-1 |Ada |Paris|Pen |2 | |A-2 |Grace|Lyon |Ink |1 | |A-3 |null |null |Pad |5 | |A-4 |Ada |Paris|Ink |3 | '--------+-----+-----+-------+---'
Inner Join : A-3 disparaît.Inner Join: A-3 disappears.
.--------+-----+-----+-------+---. | tLogRow_1 | |=-------+-----+-----+-------+--=| |order_id|name |city |product|qty| |=-------+-----+-----+-------+--=| |A-1 |Ada |Paris|Pen |2 | |A-2 |Grace|Lyon |Ink |1 | |A-4 |Ada |Paris|Ink |3 | '--------+-----+-----+-------+---'
Inner Join et une seconde sortie unknown (row1.order_id, row1.customer_id) réglée en Catch lookup inner join reject, vers tLogRow_2. tLogRow_1 affiche les trois mêmes lignes, et :
Inner Join and a second output unknown (row1.order_id, row1.customer_id) set to Catch lookup inner join reject, to tLogRow_2. tLogRow_1 prints the same three rows, and:
.--------+-----------. | tLogRow_2 | |=-------+----------=| |order_id|customer_id| |=-------+----------=| |A-3 |9 | '--------+-----------'
Même job, avec les commandes A-1 à A-3 et un lookup où le client 1 figure deux fois : 1, Ada, Paris, puis 1, Ada, London, puis 2, Grace, Lyon. Sortie : order_id, customer_id (de row1), name, city (de row2). Left Outer Join.
Same job, with orders A-1 to A-3 and a lookup where customer 1 appears twice: 1, Ada, Paris, then 1, Ada, London, then 2, Grace, Lyon. Output: order_id, customer_id (from row1), name, city (from row2). Left Outer Join.
Unique match : la dernière ligne chargée.Unique match: the last loaded row.
.--------+-----------+-----+------. | tLogRow_1 | |=-------+-----------+-----+-----=| |order_id|customer_id|name |city | |=-------+-----------+-----+-----=| |A-1 |1 |Ada |London| |A-2 |2 |Grace|Lyon | |A-3 |9 |null |null | '--------+-----------+-----+------'
First match : la première.First match: the first one.
.--------+-----------+-----+-----. | tLogRow_1 | |=-------+-----------+-----+----=| |order_id|customer_id|name |city | |=-------+-----------+-----+----=| |A-1 |1 |Ada |Paris| |A-2 |2 |Grace|Lyon | |A-3 |9 |null |null | '--------+-----------+-----+-----'
All matches : une ligne par correspondance.All matches: one row per match.
.--------+-----------+-----+------. | tLogRow_1 | |=-------+-----------+-----+-----=| |order_id|customer_id|name |city | |=-------+-----------+-----+-----=| |A-1 |1 |Ada |Paris | |A-1 |1 |Ada |London| |A-2 |2 |Grace|Lyon | |A-3 |9 |null |null | '--------+-----------+-----+------'
All rows : chaque commande est jointe à chaque ligne du lookup. Même résultat avec la clé saisie : en All rows, elle est ignorée, ce que donnait un lookup laissé en All rows dans Talaxie 9.0.6.All rows: each order is joined to each lookup row. Same result with the key typed: in All rows, it is ignored, which is what a lookup left in All rows in Talaxie 9.0.6 gave.
.--------+-----------+-----+------. | tLogRow_1 | |=-------+-----------+-----+-----=| |order_id|customer_id|name |city | |=-------+-----------+-----+-----=| |A-1 |1 |Ada |Paris | |A-1 |1 |Ada |London| |A-1 |1 |Grace|Lyon | |A-2 |2 |Ada |Paris | |A-2 |2 |Ada |London| |A-2 |2 |Grace|Lyon | |A-3 |9 |Ada |Paris | |A-3 |9 |Ada |London| |A-3 |9 |Grace|Lyon | '--------+-----------+-----+------'
All matches et Inner Join : les correspondances seulement.All matches and Inner Join: the matches only.
.--------+-----------+-----+------. | tLogRow_1 | |=-------+-----------+-----+-----=| |order_id|customer_id|name |city | |=-------+-----------+-----+-----=| |A-1 |1 |Ada |Paris | |A-1 |1 |Ada |London| |A-2 |2 |Grace|Lyon | '--------+-----------+-----+------'
Unique match ne signale pas le doublon : le modèle contient bien un avertissement, mais en commentaire. Dédoublonnez le lookup (tUniqRow) ou choisissez First match si la ligne gardée compte. Unique match does not report the duplicate: the template does contain a warning, but commented out. Deduplicate the lookup (tUniqRow) or choose First match if the kept row matters.
Clients (row2, clé row1.customer_id) et produits (row3, clé row1.product), en Unique match. Table Var :
Customers (row2, key row1.customer_id) and products (row3, key row1.product), in Unique match. Var table:
| Variable | Type | Expression |
|---|---|---|
| amount | Double | row1.qty * row3.price |
| customer | String | row2.name == null ? "unknown" : row2.name.toUpperCase() |
Sortie : row1.order_id, Var.customer, row1.product, row1.qty, row3.price, Var.amount.
Output: row1.order_id, Var.customer, row1.product, row1.qty, row3.price, Var.amount.
.--------+--------+-------+---+-----+------. | tLogRow_1 | |=-------+--------+-------+---+-----+-----=| |order_id|customer|product|qty|price|amount| |=-------+--------+-------+---+-----+-----=| |A-1 |ADA |Pen |2 |1.5 |3.0 | |A-2 |GRACE |Ink |1 |4.0 |4.0 | |A-3 |unknown |Pad |5 |2.5 |12.5 | |A-4 |ADA |Ink |3 |4.0 |12.0 | '--------+--------+-------+---+-----+------'
Sans le test sur null, A-3 arrêterait le job (NullPointerException) : en jointure externe, toute colonne d'un lookup peut être nulle. De même, row1.qty et row3.price sont des objets (Integer, Double) : un produit inconnu ferait échouer le calcul de Var.amount.
Without the null test, A-3 would stop the job (NullPointerException): in an outer join, any lookup column can be null. Likewise, row1.qty and row3.price are objects (Integer, Double): an unknown product would make the computation of Var.amount fail.
Commandes et clients, comme l'exemple 1. Deux sorties de mêmes colonnes (row1.order_id, row2.name, row2.city) : paris, filtrée par "Paris".equals(row2.city), et others, en Catch output reject. La forme "Paris".equals(…) supporte une ville null (A-3).
Orders and customers, as in example 1. Two outputs with the same columns (row1.order_id, row2.name, row2.city): paris, filtered by "Paris".equals(row2.city), and others, as Catch output reject. The "Paris".equals(…) form copes with a null city (A-3).
.--------+----+-----. | tLogRow_1 | |=-------+----+----=| |order_id|name|city | |=-------+----+----=| |A-1 |Ada |Paris| |A-4 |Ada |Paris| '--------+----+-----' .--------+-----+----. | tLogRow_2 | |=-------+-----+---=| |order_id|name |city| |=-------+-----+---=| |A-2 |Grace|Lyon| |A-3 |null |null| '--------+-----+----'
Une troisième sortie all, sans filtre, vers tLogRow_3 : elle prend chaque ligne, et le rejet ne reçoit plus rien.A third output all, without filter, to tLogRow_3: it takes each row, and the reject gets nothing any more.
.--------+----+----. | tLogRow_2 | |=-------+----+---=| |order_id|name|city| |=-------+----+---=| '--------+----+----' .--------+-----+-----. | tLogRow_3 | |=-------+-----+----=| |order_id|name |city | |=-------+-----+----=| |A-1 |Ada |Paris| |A-2 |Grace|Lyon | |A-3 |null |null | |A-4 |Ada |Paris| '--------+-----+-----'
tLogRow_1 affiche les deux mêmes lignes qu'à gauche. Le Studio ne prévient de ce cas (the output rejection cannot be used) qu'avec la vérification du code activée dans ses préférences, désactivée par défaut ; Talaxie ne le signale pas.tLogRow_1 prints the same two rows as on the left. The Studio warns about this case (the output rejection cannot be used) only with the code check enabled in its preferences, off by default; Talaxie does not report it.
Commandes (row1) et produits (row2, clé row1.product, Unique match, Left Outer Join). Filtre du flux principal : row1.qty >= 2 ; filtre du lookup : row2.price < 3.0. Sortie : order_id, product, qty, row2.price.
Orders (row1) and products (row2, key row1.product, Unique match, Left Outer Join). Main flow filter: row1.qty >= 2; lookup filter: row2.price < 3.0. Output: order_id, product, qty, row2.price.
.--------+-------+---+-----. | tLogRow_1 | |=-------+-------+---+----=| |order_id|product|qty|price| |=-------+-------+---+----=| |A-1 |Pen |2 |1.5 | |A-3 |Pad |5 |2.5 | |A-4 |Ink |3 |null | '--------+-------+---+-----'
A-2 (quantité 1) est écarté par le filtre principal. Pour A-4, Ink est trouvé, mais à 4.0 il ne vérifie pas le filtre du lookup : il compte comme absent. A-2 (quantity 1) is dropped by the main filter. For A-4, Ink is found, but at 4.0 it does not meet the lookup filter: it counts as missing.
Le lookup à doublon de l'exemple 2, filtré par !"London".equals(row2.city). Le filtre s'applique après la correspondance. En All matches, Left Outer Join, la correspondance écartée donne une ligne vide :
The lookup with a duplicate of example 2, filtered by !"London".equals(row2.city). The filter applies after the match. In All matches, Left Outer Join, the dropped match gives an empty row:
.--------+-----------+-----+-----. | tLogRow_1 | |=-------+-----------+-----+----=| |order_id|customer_id|name |city | |=-------+-----------+-----+----=| |A-1 |1 |Ada |Paris| |A-1 |1 |null |null | |A-2 |2 |Grace|Lyon | |A-3 |9 |null |null | '--------+-----------+-----+-----'
En Unique match, la ligne gardée (London, la dernière) est écartée, et Paris n'est pas reprise :In Unique match, the kept row (London, the last one) is dropped, and Paris is not taken instead:
.--------+-----------+-----+----. | tLogRow_1 | |=-------+-----------+-----+---=| |order_id|customer_id|name |city| |=-------+-----------+-----+---=| |A-1 |1 |null |null| |A-2 |2 |Grace|Lyon| |A-3 |9 |null |null| '--------+-----------+-----+----'
En All matches et Inner Join, il ne reste que A-1, Ada, Paris et A-2, Grace, Lyon. Pour choisir parmi les lignes du lookup, filtrez-les avant le tMap (tFilterRow).
In All matches and Inner Join, only A-1, Ada, Paris and A-2, Grace, Lyon remain. To choose among the lookup rows, filter them before the tMap (tFilterRow).
Commandes A-1, FR, A-2, DE, A-3, FR (order_id, country). Un fichier de taux par pays, rates_FR.csv :
Orders A-1, FR, A-2, DE, A-3, FR (order_id, country). One rate file per country, rates_FR.csv:
FR;standard;20.0 FR;reduced;5.5
et rates_DE.csv (19.0 et 7.0). Le tFileInputDelimited (country, rate_name, rate en Double) lit :
and rates_DE.csv (19.0 and 7.0). The tFileInputDelimited (country, rate_name, rate as Double) reads:
context.folder + "/rates_" + globalMap.get("country") + ".csv"
Le tJavaRow recopie chaque ligne et affiche " read " + input_row.country + " " + input_row.rate_name, pour voir les lectures. Lookup row3 : Reload at each row, clé GlobalMap "country" d'expression row1.country, sans clé de jointure (All rows). Sortie : row1.order_id, row3.rate_name, row3.rate ; tLogRow en mode simple.
The tJavaRow copies each row and prints " read " + input_row.country + " " + input_row.rate_name, to see the reads. Lookup row3: Reload at each row, GlobalMap key "country" with expression row1.country, without join key (All rows). Output: row1.order_id, row3.rate_name, row3.rate; tLogRow in basic mode.
read FR standard read FR reduced A-1|standard|20.0 A-1|reduced|5.5 read DE standard read DE reduced A-2|standard|19.0 A-2|reduced|7.0 read FR standard read FR reduced A-3|standard|20.0 A-3|reduced|5.5
Le fichier est relu pour chaque commande, après globalMap.put("country", row1.country). En Reload at each row (cache), avec la clé de jointure row1.country sur country et All matches, FR n'est lu qu'une fois :
The file is read again for each order, after globalMap.put("country", row1.country). In Reload at each row (cache), with the join key row1.country on country and All matches, FR is only read once:
read FR standard read FR reduced A-1|standard|20.0 A-1|reduced|5.5 read DE standard read DE reduced A-2|standard|19.0 A-2|reduced|7.0 A-3|standard|20.0 A-3|reduced|5.5
Lignes A-1, "2", A-2, "two", A-3, "5" (order_id, qty_text en String). Sortie out1 : row1.order_id et qty (Integer) = Integer.valueOf(row1.qty_text), vers un tLogRow simple.
Rows A-1, "2", A-2, "two", A-3, "5" (order_id, qty_text as String). out1 output: row1.order_id and qty (Integer) = Integer.valueOf(row1.qty_text), to a basic tLogRow.
Die on error décoché : la sortie ErrorReject apparaît, on y ajoute order_id (row1.order_id). Le tJavaRow affiche order_id, errorMessage et la première ligne de errorStackTrace. Coché (défaut), le job s'arrête sur A-2 : voir les erreurs.
Die on error unchecked: the ErrorReject output appears, order_id (row1.order_id) is added to it. The tJavaRow prints order_id, errorMessage and the first line of errorStackTrace. Checked (default), the job stops on A-2: see the errors.
A-1|2 ErrorReject: A-2 | For input string: "two" stack: java.lang.NumberFormatException: For input string: "two" A-3|5
A-2 ne va dans aucune autre sortie, et le job finit normalement (code 0). Les colonnes ajoutées à ErrorReject sont recalculées après l'erreur : n'y mettez pas l'expression qui échoue.
A-2 goes to no other output, and the job ends normally (exit code 0). The columns added to ErrorReject are computed again after the error: do not put the failing expression there.
Commandes et clients. Sortie detail (row1.order_id, row2.name, row1.qty) vers tLogRow_1, sortie audit (row1.order_id, matched Boolean = row2.name != null) vers tLogRow_2, en mode simple :
Orders and customers. detail output (row1.order_id, row2.name, row1.qty) to tLogRow_1, audit output (row1.order_id, matched Boolean = row2.name != null) to tLogRow_2, in basic mode:
A-1|Ada|2 A-1|true A-2|Grace|1 A-2|true A-3||5 A-3|false A-4|Ada|3 A-4|true
Chaque ligne va dans les deux sorties, l'une après l'autre, avant la ligne suivante. Each row goes to both outputs, one after the other, before the next row.
Lignes A-1, "2", "2026-11-20" et A-2, "15", "2026-12-01", toutes en String. Sortie : qty (Integer) = row1.qty_text, day (Date, modèle "yyyy-MM-dd") = row1.day. Sans conversion, le job ne compile pas (voir les erreurs). Avec Enable Auto-Conversion of types :
Rows A-1, "2", "2026-11-20" and A-2, "15", "2026-12-01", all String. Output: qty (Integer) = row1.qty_text, day (Date, pattern "yyyy-MM-dd") = row1.day. Without conversion, the job does not compile (see the errors). With Enable Auto-Conversion of types:
.--------+---+----------. | tLogRow_1 | |=-------+---+---------=| |order_id|qty|day | |=-------+---+---------=| |A-1 |2 |2026-11-20| |A-2 |15 |2026-12-01| '--------+---+----------'
Le code généré devient TypeConvert.String2Integer(row1.qty_text) et TypeConvert.String2Date(row1.day, "yyyy-MM-dd") (modèle de la colonne de sortie, sinon "dd-MM-yyyy"), un null restant null. Seule une expression faite d'une seule colonne (row1.x, Var.x) est convertie : row1.qty_text + 1 ne compile toujours pas.
The generated code becomes TypeConvert.String2Integer(row1.qty_text) and TypeConvert.String2Date(row1.day, "yyyy-MM-dd") (pattern of the output column, else "dd-MM-yyyy"), a null staying null. Only an expression made of one single column (row1.x, Var.x) is converted: row1.qty_text + 1 still does not compile.
Flux principal X, 1.5 et Y, 2 ; lookup 1.50, one and a half et 2.00, two (rate en BigDecimal des deux côtés, clé row1.rate). Ignorer les zéros de fin pour BigDecimal coché (défaut) :
Main flow X, 1.5 and Y, 2; lookup 1.50, one and a half and 2.00, two (rate as BigDecimal on both sides, key row1.rate). Ignore trailing zeros for BigDecimal checked (default):
.----+----+--------------. | tLogRow_1 | |=---+----+-------------=| |code|rate|label | |=---+----+-------------=| |X |1.5 |one and a half| |Y |2 |two | '----+----+--------------'
Décoché : 1.5 et 1.50 diffèrent.Unchecked: 1.5 and 1.50 differ.
.----+----+-----. | tLogRow_1 | |=---+----+----=| |code|rate|label| |=---+----+----=| |X |1.5 |null | |Y |2 |null | '----+----+-----'
Exemple 1 (sortie order_id, name, city), le lookup en Store temp data à true, dossier context.folder + "/tmp" :
Example 1 (output order_id, name, city), the lookup with Store temp data set to true, folder context.folder + "/tmp":
.--------+-----+-----. | tLogRow_1 | |=-------+-----+----=| |order_id|name |city | |=-------+-----+----=| |A-1 |Ada |Paris| |A-4 |Ada |Paris| |A-2 |Grace|Lyon | |A-3 |null |null | '--------+-----+-----'
Mêmes lignes, mais dans l'ordre de la clé (clients 1, 1, 2, 9) : le flux principal a été trié sur disque, puis fusionné avec le lookup trié. Les fichiers temporaires sont effacés en fin de job. Retriez après le tMap si l'ordre d'arrivée compte. Same rows, but in key order (customers 1, 1, 2, 9): the main flow was sorted on disk, then merged with the sorted lookup. The temporary files are deleted at the end of the job. Sort again after the tMap if the arrival order matters.
Fichier people.csv, lu avec une ligne d'en-tête et le schéma ID (String), COLUMNS (Dynamic) :people.csv file, read with one header line and the schema ID (String), COLUMNS (Dynamic):
ID;NAME;CITY;AGE 1;Ada;Paris;36 2;Grace;Lyon;45
Sortie : ID = row1.ID, SOURCE = "people.csv", COLUMNS (Dynamic) = row1.COLUMNS, en dernier.
Output: ID = row1.ID, SOURCE = "people.csv", COLUMNS (Dynamic) = row1.COLUMNS, last.
tLogRow_1 +----+------------+-------+-------+-----+ | ID | SOURCE | NAME | CITY | AGE | +----+------------+-------+-------+-----+ | 1 | people.csv | Ada | Paris | 36 | | 2 | people.csv | Grace | Lyon | 45 | +----+------------+-------+-------+-----+
La colonne Dynamic passe telle quelle : elle doit être la dernière, garder son nom dans la sortie, et ne peut servir ni de clé, ni dans un filtre, une variable, une clé GlobalMap ou une autre expression. Le générateur refuse le job sinon (voir les erreurs). Pour lire ses colonnes une à une, voyez tExtractDynamicFields. The Dynamic column goes through as it is: it must be the last one, keep its name in the output, and cannot be used as a key, nor in a filter, a variable, a GlobalMap key or another expression. Otherwise the generator refuses the job (see the errors). To read its columns one by one, see tExtractDynamicFields.
Messages copiés depuis une exécution ; le nom du job est remplacé par MyJob, les chemins et les piles d'appels abrégés (…).
Messages copied from a run; the job name is replaced by MyJob, the paths and stack traces shortened (…).
Job de l'exemple 7, Die on error coché. La ligne A-1 est déjà affichée ; le job s'arrête sur A-2 (code 1) : Job of example 7, Die on error checked. Row A-1 is already printed; the job stops on A-2 (exit code 1):
A-1|2 Exception in component tMap_1 (MyJob) java.lang.NumberFormatException: For input string: "two" at java.base/java.lang.NumberFormatException.forInputString(NumberFormatException.java:67) at java.base/java.lang.Integer.parseInt(Integer.java:662) at java.base/java.lang.Integer.valueOf(Integer.java:989) …
Une NullPointerException vient le plus souvent d'une colonne de lookup nulle (jointure externe) ou d'un Integer nul utilisé dans un calcul : testez null dans l'expression, ou décochez Die on error pour recueillir les lignes en erreur.
A NullPointerException most often comes from a null lookup column (outer join) or a null Integer used in a computation: test null in the expression, or uncheck Die on error to collect the rows in error.
Exemple 9 sans conversion automatique : le job ne compile pas, Talaxie affiche les erreurs de Java avec la ligne générée. Example 9 without automatic conversion: the job does not compile, Talaxie shows the Java errors with the generated line.
Échec de la compilation du job :The job failed to compile: …\MyJob.java:1500: error: incompatible types: String cannot be converted to Integer out1_tmp.qty = row1.qty_text; ^ …\MyJob.java:1501: error: incompatible types: String cannot be converted to Date out1_tmp.day = row1.day; ^ 2 errors
Convertissez dans l'expression (Integer.valueOf(row1.qty_text), TalendDate.parseDate("yyyy-MM-dd", row1.day)) ou cochez Enable Auto-Conversion of types.
Convert in the expression (Integer.valueOf(row1.qty_text), TalendDate.parseDate("yyyy-MM-dd", row1.day)) or check Enable Auto-Conversion of types.
Exemple 6, Reload at each row sans la clé GlobalMap (ce que laissait un job enregistré avec Talaxie 9.0.6) : globalMap.get("country") rend null, le fichier cherché est rates_null.csv. Le tFileInputDelimited signale l'erreur sans arrêter le job, et chaque commande sort sans taux :
Example 6, Reload at each row without the GlobalMap key (what a job saved with Talaxie 9.0.6 was left with): globalMap.get("country") returns null, the file looked for is rates_null.csv. The tFileInputDelimited reports the error without stopping the job, and each order goes out without rate:
[tFileInputDelimited_1] …\data\rates_null.csv (Le fichier spécifié est introuvable) A-1|| [tFileInputDelimited_1] …\data\rates_null.csv (Le fichier spécifié est introuvable) A-2|| [tFileInputDelimited_1] …\data\rates_null.csv (Le fichier spécifié est introuvable) A-3||
En Load once, la même source est lue une seule fois, avant la première commande, quand la clé n'est pas encore dans globalMap : même message, une seule fois, et les mêmes lignes sans taux. Le message vient de Windows, dans sa langue ; la console de Talaxie le précède du composant, entre crochets.
In Load once, the same source is read only once, before the first order, when the key is not yet in globalMap: same message, only once, and the same rows without rate. The message comes from Windows, in its language; the Talaxie console puts the component in front of it, in brackets.
Exemple 12, la colonne Dynamic de sortie nommée OTHERS au lieu de COLUMNS : la génération s'arrête.
Example 12, the output Dynamic column named OTHERS instead of COLUMNS: generation stops.
tMap_1 : Dynamic output must directly map the input container without renaming: out1.OTHERS
Les autres règles donnent des messages de même forme : The Dynamic column must be the last column, Dynamic column cannot be a lookup key, A filter cannot reference a Dynamic column, A Dynamic column cannot be transformed or used in an expression.
The other rules give messages of the same form: The Dynamic column must be the last column, Dynamic column cannot be a lookup key, A filter cannot reference a Dynamic column, A Dynamic column cannot be transformed or used in an expression.
En All rows, les clés sont ignorées : un lookup de mille lignes multiplie le flux par mille. Après avoir saisi une clé, vérifiez le Match Model, surtout dans un job modifié avec Talaxie 9.0.6. In All rows, the keys are ignored: a lookup of a thousand rows multiplies the flow by a thousand. After typing a key, check the Match Model, especially in a job edited with Talaxie 9.0.6.
Catch output reject ne reçoit que si toutes les autres sorties ont un filtre. Une sortie « tout » ajoutée plus tard le rend muet, sans message dans Talaxie (le Studio ne prévient qu'avec la vérification du code activée). Catch output reject only receives if all the other outputs have a filter. An "everything" output added later makes it silent, without message in Talaxie (the Studio warns only with the code check enabled).
Il ne choisit pas parmi les correspondances : en Unique match, il peut écarter la seule gardée ; en All matches et jointure externe, chaque ligne écartée donne une ligne vide (exemple 5). Filtrez le lookup en amont, ou passez en jointure interne. It does not choose among the matches: in Unique match, it can drop the only one kept; in All matches and outer join, each dropped row gives an empty row (example 5). Filter the lookup upstream, or switch to an inner join.
Chaque lookup en Load once tient en mémoire en entier. Ne gardez que les colonnes utiles (tFilterColumns, requête ciblée), filtrez avant le tMap, ou passez en Store temp data en acceptant l'ordre de la clé. Each lookup in Load once is held entirely in memory. Keep only the useful columns (tFilterColumns, targeted query), filter before the tMap, or switch to Store temp data accepting the key order.
Reload at each row relance la source du lookup pour chaque ligne principale. Réservez-le aux grosses tables qu'on interroge par clé ; préférez le cache quand les clés se répètent, et Load once quand le lookup tient en mémoire. Reload at each row runs the lookup source again for each main row. Keep it for large tables queried by key; prefer the cache when the keys repeat, and Load once when the lookup fits in memory.
Écrivez "Paris".equals(x) plutôt que x.equals("Paris"), testez null sur les colonnes de lookup, et mettez dans une variable un calcul repris par plusieurs sorties : il n'est fait qu'une fois.
Write "Paris".equals(x) rather than x.equals("Paris"), test null on lookup columns, and put in a variable a computation used by several outputs: it is done only once.
tXMLMap · le même éditeur pour des documents XMLthe same editor for XML documentstJoin · joindre deux flux sans éditeurjoin two flows without an editortFilterRow · filtrer des lignes par conditionsfilter rows by conditionstFilterColumns · garder ou réordonner des colonneskeep or reorder columnstUniqRow · dédoublonner un lookupdeduplicate a lookuptSortRow · trier un fluxsort a flowtAggregateRow · regrouper et calculer par groupegroup and compute per grouptConvertType · convertir les types d'un fluxconvert the types of a flowtJavaRow · transformer chaque ligne en Javatransform each row in JavatExtractDynamicFields · déplier une colonne Dynamicunfold a Dynamic column