Discussion :

[Bouga74]

Bonjour à tous,

Je souhaite comparer les enregistrements d'une table et voir s'il y a des doublons probables (que j'identifie a l'aide de fonctions faites maison).

Donc j'utilise 2 tInputMysql que je relis a un tMap dans lequel j'appel les fonctions que j'ai créé afin de comparer ces enregistrements.

J'aimerais que lorsque un doublon est trouver, l'itération sur ma table passe a l'enregistrement suivant. Je n'utilise pas de tUniqRow, mes fonctions faisants un certains nombre de transformations sur les données avant de les comparer.

Voici un exemple pour être plus clair :
id - nom1 - nom 2
1 - test1 - tst1
2 - test2 - tst2
3 - test3 - tst2
4 - test1 - tst1
5 - test1 - tst1

Voici un exemple de ce que je fais en ce moment dans mon tMap :
Comparaison 1 et 2 : faux;
Comparaison 1 et 3 : faux;
Comparaison 1 et 4 : vrai ==> enregistrement en base;
Comparaison 1 et 5 : vrai ==> enregistrement en base;

Comparaison 2 et 3 : vrai ==> enregistrement en base;
Comparaison 2 et 4 : faux;
Comparaison 2 et 5 : faux;

Comparaison 3 et 4 : faux;
Comparaison 3 et 5 : faux;

Comparaison 4 et 5 : vrai ==> enregistrement en base




J'aimerais obtenir le schéma suivant :
Comparaison 1 et 2 : faux;
Comparaison 1 et 3 : faux;
Comparaison 1 et 4 : vrai ==> enregistrement en base; (pas de comparaison entre 1 et 5)

Comparaison 2 et 3 : vrai ==> enregistrement en base; (pas de comparaison 2 et 4, ni 2 et 5)

Comparaison 3 et 4 : faux;
Comparaison 3 et 5 : faux;



Quelqu'un aurait-il une idée de solution pour résoudre ce probleme ?
Y a t il un autre composant a utiliser pour faire cela ?

Mon fichier est composé de plusieurs centaines de millier de lignes, et ma solution me pousse a traiter encore les données en sortie pour pouvoir garder uniquement le premier enregistrement par id (Donc un traitement extremement long).

Merci d'avance !

[bbl22]

bjr,

tu pourrai utiliser la fonction update or insert dans un tbaseOutput, ou faire d'abord un update dans un tbaseRow(tMsqlRow), sachant que avec un update tu peux faire des LEFT JOIN et des conditions.

bon courage

[CyberChouan]

Fonctionnellement, ton traitement paraît difficile à réaliser, pour des raisons d'occupation mémoire.

Tu veux comparer chaque enregistrement à tous les suivants. Donc, lorsque tu traites le premier enregistrement, tu dois déjà connaître tous les suivants.

Cela impose d'avoir dans un premier temps monté l'ensemble de tes données en mémoire... Sur des centaines de milliers de lignes, ça peut être problématique.

La solution peut effectivement être la jointure dans le tMap, avec l'option "effectuer la jointure sur disque" : la jointure étant faite sur le disque dur, le problème éventuel de saturation mémoire disparait.

Le problème étant que cette solution a un coût en terme de performances, qui sont dégradées.

N'as-tu donc pas moyen de revoir la conception de tes traitements en amont, pour traiter ce problème dès l'origine (avec des clauses WHERE évoluées dans le SELECT en base, par exemple) ?...

[Bouga74]

Merci à tous les 2 pour vos idées.

Je vais regarder au niveau du tMysqlRow.

Pour traiter cela en amont, je ne vois pas trop comment faire. Un select n'y changerai rien, vu que je dois analyser les comptes 1 par 1 avec tous les autres comptes.

Pour avancé, j'ai fais 2 jobs.
Un job père qui lit le fichier source et pour chaque ligne, appel le job fils.
Le job fils, qui recupere les données du père, lit de nouveau le fichier source et controle que l'id provenant du pere n'est pas deja dans la table de mes doublons. Le job fils effectue egalement les comparaisons et enregistre en base les doublons.
(copies d'écran en pièce jointe)

Le petit soucis que j'ai ... 1.6 rows/sec (5300 seconde que je regarde tourner tout ca :s. Et c'est loin d'être finis...)

[CyberChouan]

Le petit soucis que j'ai ... 1.6 rows/sec (5300 seconde que je regarde tourner tout ca :s. Et c'est loin d'être finis...)

Ca c'est parce que tu as activé toutes les traces, avec l'analyse "en direct" sur ton job de son exécution.

Ces traces "temps réel" sont très très gourmandes en temps de calcul : supprime-les (remplace-les par de véritables logs) et tu devrais revenir à des vitesses de traitement correctes.

[Bouga74]

Non non je parlais d'une exécution normal, sans traces.
Avec les traces, j'arrive a un joli 0,6 row/s .

En fait, le mieux que je vois, ca serait de récupérer tous les comptes dans ma base, les mettre dans un tableau et ensuite de passer ce tableau à une fonction d'une routine pour y faire tous les traitements.

C'est possible de faire quelque chose comme ca avec Talend ?

[bbl22]

bjr, une idée, faire un tmsqlInput, et gérer les variables de context, ensuite tu fais ta boucle dans un tjavaflex, puis tout récupérer dans le output.
dans ton tjavaflex tu gères tes variables.

MsqlInput==>TflowtoIterate ==>tjavaflex==>MsqlOutput.

bpn courage

[Bouga74]

Merci pour l'idée.

Finalement (n'étant pas très à l'aise avec les variable de contexte) je suis passé par une autre solution faisant appel a un tMysqlInput, qui envoi toutes les données dans un tJavaFlex.
Je cré mon tableau dans la boucle et, quand il est remplit, j'appel ma fonction. J'execute mes requete directement dans celle ci.

Le traitement est long mais finalement je pense que je ne peux pas faire tellement mieux.

A+