ComposantsComponents

ComposantsComponents › Traitement › ChampsProcessing › Fields

tDenormalizeSortedRow

tDenormalizeSortedRow

Traitement › ChampsProcessing › Fields

Le même regroupement que le tDenormalize, sur un flux déjà trié sur les clés : une suite de lignes qui ont les mêmes valeurs dans leurs autres colonnes devient une ligne, la colonne à dénormaliser jointe avec un séparateur. Chaque groupe sort dès qu'il est complet, sans garder le flux en mémoire. En échange, le composant doit connaître à l'avance le nombre de lignes qu'il va recevoir : c'est à ce compte qu'il sort le dernier groupe. The same grouping as the tDenormalize, on a flow already sorted on the keys: a run of rows that have the same values in their other columns becomes one row, the column to denormalize joined with a delimiter. Each group leaves as soon as it is complete, without keeping the flow in memory. In exchange, the component must know in advance the number of rows it will receive: it is at that count that it outputs the last group.

EntréeInput

Main un flux trié sur les clésone flow sorted on the keys

SortieOutput

Main un flux : une ligne par suite de lignes de même cléone flow: one row per run of rows with the same key

Déclencheurs en sortieOutput triggers

On Component Ok On Component Error Run if

UtilisationUsage

OnSubjobOk row1 (Main) row2 (Main) row3 (Main) tFileRowCount_1 tFileInputDelimited_1 tSortRow_1 tDenormalizeSortedRow_1 tLogRow_1

À chaque ligne, le composant compare ses clés à celles de la ligne précédente : si elles changent, le groupe précédent sort. Quand le compteur de lignes atteint le Nombre de lignes en entrée, le groupe en cours sort aussi. Comme pour le tDenormalize, toute colonne d'entrée qui n'est pas dans la table À dénormaliser est une clé. At each row, the component compares its keys with those of the previous row: if they change, the previous group leaves. When the row counter reaches the Input rows count, the current group leaves too. As for the tDenormalize, every input column that is not in the To denormalize table is a key.

  1. Triez le flux sur les clés (tSortRow, ORDER BY d'une requête…), puis reliez-le au tDenormalizeSortedRow. Sort the flow on the keys (tSortRow, ORDER BY of a query…), then connect it to the tDenormalizeSortedRow.
  2. Modifier le schéma : les colonnes de l'entrée, sous les mêmes noms ; chaque colonne à dénormaliser en String. Edit schema: the input columns, under the same names; each column to denormalize as String.
  3. Écrivez le Nombre de lignes en entrée, une expression Java : un nombre, ou une variable remplie dans un sous-job précédent, comme le COUNT d'un tFileRowCount. Write the Input rows count, a Java expression: a number, or a variable filled in a previous subjob, like the COUNT of a tFileRowCount.
  4. Remplissez À dénormaliser comme pour le tDenormalize. Fill To denormalize as for the tDenormalize.

ParamètresSettings

Tous dans les Paramètres simples ; le nom technique, en gris, est celui du paramètre dans le fichier du job. All in the Basic settings; the technical name, in grey, is the parameter name in the job file.

ParamètreSetting DéfautDefault VisibleShown Description
SchémaSchemaSCHEMA videempty ToujoursAlways Les colonnes de sortie, sous les noms de l'entrée : toutes les clés, et les colonnes dénormalisées en String (le code généré y range un texte ; il n'y a pas de sortie List comme avec le tDenormalize). The output columns, under the input names: all the keys, and the denormalized columns as String (the generated code stores a text there; there is no List output as with the tDenormalize).
Nombre de lignes en entréeInput rows countROW_COUNT videempty ToujoursAlways Expression Java, évaluée à chaque ligne : le nombre exact de lignes que le composant reçoit. À la ligne qui porte ce numéro, le groupe en cours sort. Trop grand, le dernier groupe est perdu ; trop petit, les lignes suivantes le sont (voir exemples). Vide, le job ne compile pas. Java expression, evaluated at each row: the exact number of rows the component receives. At the row with this number, the current group leaves. Too large, the last group is lost; too small, the following rows are (see examples). Empty, the job does not compile.
À dénormaliserTo denormalizeDENORMALIZE_COLUMNS videempty ToujoursAlways Une ligne par colonne à joindre : Colonne, Séparateur (";", placé entre les valeurs) et Fusionner les valeurs identiques (décoché : une valeur déjà vue dans le groupe n'est pas reprise). Les valeurs gardent leur ordre d'arrivée ; une nulle s'écrit null ; une date suit le modèle de sa colonne d'entrée. One line per column to join: Column, Delimiter (";", placed between the values) and Merge same value (unchecked: a value already seen in the group is not taken again). The values keep their order of arrival; a null is written null; a date follows the pattern of its input column.

Sous la table, l'onglet affiche une note : Avertissement : ce composant peut changer le comportement en entrée. Under the table, the tab shows a note: Warning: This component may change input behavior.

Variable globaleGlobal variable

NB_LINE (Integer, disponible après le composant) : le nombre de lignes sorties, c'est-à-dire de groupes. NB_LINE (Integer, available after the component): the number of rows sent, that is of groups.

((Integer) globalMap.get("tDenormalizeSortedRow_1_NB_LINE"))

ExemplesExamples

Sauf mention contraire, un tFixedFlowInput envoie cinq lignes au tDenormalizeSortedRow, suivi d'un tLogRow en mode basique ; À dénormaliser : name, séparateur ";". Un tJava relié par On Subjob Ok affiche NB_LINE. Sorties copiées depuis une exécution des jobs dans Talaxie (Java 21). Unless stated otherwise, a tFixedFlowInput sends five rows to the tDenormalizeSortedRow, followed by a tLogRow in basic mode; To denormalize: name, delimiter ";". A tJava connected with On Subjob Ok prints NB_LINE. Outputs copied from a run of the jobs in Talaxie (Java 21).

Flux triéSorted flow

Entrée, triée sur cityInput, sorted on city

cityString nameString
LyonGrace
LyonLinus
ParisAda
ParisAlan
ParisAda

Nombre de lignes en entrée : 5. Input rows count: 5.

SortieOutput

Lyon|Grace;Linus
Paris|Ada;Alan;Ada
tDenormalizeSortedRow_1_NB_LINE = 2

Avec Fusionner les valeurs identiques : With Merge same value:

Lyon|Grace;Linus
Paris|Ada;Alan
tDenormalizeSortedRow_1_NB_LINE = 2

Flux non triéUnsorted flow

Les mêmes lignes dans l'ordre Paris Ada, Lyon Grace, Paris Alan, Lyon Linus, Paris Ada. La ville change à chaque ligne : chaque ligne forme son propre groupe et rien n'est joint, sans aucun message. The same rows in the order Paris Ada, Lyon Grace, Paris Alan, Lyon Linus, Paris Ada. The city changes at every row: each row makes its own group and nothing is joined, without any message.

Paris|Ada
Lyon|Grace
Paris|Alan
Lyon|Linus
Paris|Ada
tDenormalizeSortedRow_1_NB_LINE = 5

Fichier trié par un tSortRowFile sorted by a tSortRow

Le fichier people.csv (sans en-tête) contient Paris;Ada, Lyon;Grace, Paris;Alan, Lyon;Linus, Paris;Edsger. Un tFileRowCount le compte, puis, par On Subjob Ok, un tFileInputDelimited le lit et un tSortRow le trie sur city (alpha, asc). Nombre de lignes en entrée : The people.csv file (without a header) holds Paris;Ada, Lyon;Grace, Paris;Alan, Lyon;Linus, Paris;Edsger. A tFileRowCount counts it, then, with On Subjob Ok, a tFileInputDelimited reads it and a tSortRow sorts it on city (alpha, asc). Input rows count:

((Integer) globalMap.get("tFileRowCount_1_COUNT"))
Lyon|Grace;Linus
Paris|Ada;Alan;Edsger
tDenormalizeSortedRow_1_NB_LINE = 2

Le tri garde l'ordre d'arrivée des lignes d'une même ville. The sort keeps the order of arrival of the rows of a same city.

Un nombre de lignes fauxA wrong row count

Trop grand : 10Too large: 10

Flux trié de cinq lignes. Le compteur n'atteint jamais 10 : le groupe Paris ne sort pas, et le job se termine normalement. Sorted flow of five rows. The counter never reaches 10: the Paris group does not leave, and the job ends normally.

Lyon|Grace;Linus
tDenormalizeSortedRow_1_NB_LINE = 1

Trop petit : 3Too small: 3

À la 3e ligne, Lyon sort (la ville change), puis Paris avec le seul Ada reçu. Les lignes 4 et 5 ne sortent jamais. At the 3rd row, Lyon leaves (the city changes), then Paris with the only Ada received. Rows 4 and 5 never leave.

Lyon|Grace;Linus
Paris|Ada
tDenormalizeSortedRow_1_NB_LINE = 2

Vide (défaut)Empty (default)

Le job ne compile pas (chemin abrégé, nom du job remplacé par MyJob) : The job does not compile (path shortened, job name replaced with MyJob):

MyJob.java:1201: error: illegal start of expression
if( currentRowIndex_tDenormalizeSortedRow_1  ==  ){
                                                 ^
1 error

Deux colonnes, des nullesTwo columns, nulls

Schéma team, member, skill ; six lignes triées sur team : A Ada java, A Alan java, A null rust, B Grace cobol, B Grace null, null Linus c. À dénormaliser : member avec ",", skill avec "|" et fusion ; nombre de lignes 6. Deux clés nulles sont égales ; la dernière ligne, qui ouvre un groupe et atteint le compte, fait sortir les deux derniers groupes ensemble. Schema team, member, skill; six rows sorted on team: A Ada java, A Alan java, A null rust, B Grace cobol, B Grace null, null Linus c. To denormalize: member with ",", skill with "|" and merge; row count 6. Two null keys are equal; the last row, which opens a group and reaches the count, makes the last two groups leave together.

A|Ada,Alan,null|java|rust
B|Grace,Grace|cobol|null
|Linus|c
tDenormalizeSortedRow_1_NB_LINE = 3

Pièges et conseilsPitfalls and tips

Des lignes perdues sans messageRows lost without a message

Un nombre de lignes faux ne provoque aucune erreur : le dernier groupe, ou les dernières lignes, manquent simplement (exemples). Vérifiez après coup que NB_LINE est cohérent, ou que le total des lignes reçues par le composant suivant est celui attendu. A wrong row count raises no error: the last group, or the last rows, are simply missing (examples). Check afterwards that NB_LINE is consistent, or that the total of rows received by the next component is the expected one.

Trié sur toutes les clésSorted on all the keys

Le composant ne trie pas et ne vérifie pas le tri : un flux non trié donne autant de groupes que de changements de clé (exemple). Avec plusieurs clés, triez sur toutes les colonnes qui ne sont pas dénormalisées ; une colonne en plus dans l'entrée (un identifiant) est aussi une clé et casse les groupes. The component does not sort and does not check the sort: an unsorted flow gives as many groups as key changes (example). With several keys, sort on all the columns that are not denormalized; an extra column in the input (an identifier) is a key too and breaks the groups.

D'où tirer le nombre de lignesWhere to take the row count from

Il doit être connu avant la première ligne : un tFileRowCount dans un sous-job précédent (retirez la ligne d'en-tête : … - 1), une requête COUNT(*), ou le NB_LINE d'un composant d'un sous-job précédent. Le NB_LINE d'un composant du même flux, comme le tSortRow, n'est rempli qu'à sa fin : il est encore nul quand les lignes arrivent. It must be known before the first row: a tFileRowCount in a previous subjob (remove the header line: … - 1), a COUNT(*) query, or the NB_LINE of a component of a previous subjob. The NB_LINE of a component of the same flow, like the tSortRow, is only filled at its end: it is still null when the rows arrive.

« null » dans le texte“null” in the text

Comme avec le tDenormalize, une valeur nulle devient le mot null dans la colonne jointe, fusion ou non. Filtrez ou remplacez les nulles avant le composant. As with the tDenormalize, a null value becomes the word null in the joined column, merged or not. Filter or replace the nulls before the component.

Lequel choisirWhich one to choose

Le tDenormalize n'a besoin ni du tri ni du nombre de lignes, mais garde tout le flux en mémoire et perd l'ordre. Le tDenormalizeSortedRow convient aux gros volumes déjà triés, et garde l'ordre du tri. The tDenormalize needs neither the sort nor the row count, but keeps the whole flow in memory and loses the order. The tDenormalizeSortedRow suits large volumes already sorted, and keeps the sort order.

Un tri suffisantA sufficient sort

Seule compte la contiguïté : les lignes d'un même groupe doivent se suivre. L'ordre des groupes entre eux, croissant ou non, est libre. Only contiguity matters: the rows of a same group must follow each other. The order of the groups between them, ascending or not, is free.

Voir aussiSee also