Sélectionnez les lignes du fichier texte dont les identifiants sont répertoriés dans un autre fichier

J'utilise beaucoup de tri grek awk dans mon shell Unix pour travailler avec des fichiers texte de colonne de taille moyenne (environ 10 à 100 millions de lignes) séparés par des tabulations. À cet égard, le shell Unix est ma feuille de calcul.

Mais j'ai un gros problème, c'est la sélection des enregistrements en fonction d'une liste d'ID.

Ayant un table.csvfichier au format id\tfoo\tbar...et un ids.csvfichier avec la liste des identifiants, sélectionnez uniquement les enregistrements table.csvdont l'identifiant est présent dans ids.csv.

type de /programming/13732295/extract-all-lines-from-text-file-based-on-a-given-list-of-ids mais avec shell, pas perl.

grep -Fproduit évidemment des faux positifs si les identifiants sont de largeur variable. joinest un utilitaire que je ne pourrais jamais comprendre. Tout d'abord, cela nécessite un tri alphabétique (mes fichiers sont généralement triés numériquement), mais même dans ce cas, je ne peux pas le faire fonctionner sans me plaindre d'un ordre incorrect et sans sauter certains enregistrements. Donc je n'aime pas ça. grep -f par rapport au fichier avec ^id\t-s est très lent lorsque le nombre d'identifiants est élevé. awkest encombrant.

Existe-t-il de bonnes solutions pour cela? Des outils spécifiques pour les fichiers séparés par des tabulations? Des fonctionnalités supplémentaires seront également les bienvenues.

UPD: corrigé sort->join

Je suppose que vous grep -fne vouliez pas dire cela, grep -Fmais vous avez en fait besoin d'une combinaison des deux et -w:

grep -Fwf ids.csv table.csv

La raison pour laquelle vous obtenez des faux positifs est (je suppose, vous ne l'avez pas expliqué) car si un identifiant peut être contenu dans un autre, les deux seront imprimés. -wsupprime ce problème et -Fs'assure que vos modèles sont traités comme des chaînes et non comme des expressions régulières. De man grep:

   -F, --fixed-strings
          Interpret PATTERN as a  list  of  fixed  strings,  separated  by
          newlines,  any  of  which is to be matched.  (-F is specified by
          POSIX.)
   -w, --word-regexp
          Select  only  those  lines  containing  matches  that form whole
          words.  The test is that the matching substring must  either  be
          at  the  beginning  of  the  line,  or  preceded  by  a non-word
          constituent character.  Similarly, it must be either at the  end
          of  the  line  or  followed by a non-word constituent character.
          Word-constituent  characters  are  letters,  digits,   and   the
          underscore.

   -f FILE, --file=FILE
          Obtain  patterns  from  FILE,  one  per  line.   The  empty file
          contains zero patterns, and therefore matches nothing.   (-f  is
          specified by POSIX.)

Si vos faux positifs sont dus au fait qu'un ID peut être présent dans un champ non-ID, parcourez votre fichier à la place:

while read pat; do grep -w "^$pat" table.csv; done < ids.csv

ou, plus rapidement:

xargs -I {} grep "^{}" table.csv < ids.csv

Personnellement, je le ferais perlcependant:

perl -lane 'BEGIN{open(A,"ids.csv"); while(<A>){chomp; $k{$_}++}} 
            print $_ if defined($k{$F[0]}); ' table.csv

L' joinutilitaire est ce que vous voulez. Il nécessite que les fichiers d'entrée soient triés lexicalement.

En supposant que votre shell est bash ou ksh:

join -t $'\t' <(sort ids.csv) <(sort table.csv)

Sans avoir besoin de trier, la solution habituelle awk est

awk -F '\t' 'NR==FNR {id[$1]; next} $1 in id' ids.csv table.csv

Les réponses à cette question SO m'ont aidé à contourner les problèmes avec join. Essentiellement, lorsque vous triez le fichier en vue de l'envoyer à la jointure, vous devez vous assurer que vous triez en fonction de la colonne sur laquelle vous vous joignez. Donc, si c'est le premier, vous devez lui dire quel est le caractère séparateur dans le fichier et que vous voulez qu'il trie sur le premier champ (et seulement le premier champ). Sinon, si le premier champ a des largeurs variables (par exemple), vos séparateurs et éventuellement d'autres champs peuvent commencer à affecter l'ordre de tri.

Donc, utilisez l'option -t de tri pour spécifier votre caractère de séparation, et utilisez l'option -k pour spécifier le champ (en vous rappelant que vous avez besoin d'un champ de début et de fin - même s'il est le même - ou il triera à partir de ce caractère à la fin de la ligne).

Donc, pour un fichier séparé par des tabulations comme dans cette question, ce qui suit devrait fonctionner (avec merci à la réponse de glenn pour la structure):

join -t$'\t' <(sort -d ids.csv) <(sort -d -t$'\t' -k1,1 table.csv) > output.csv

(Pour référence, l'indicateur -d signifie le tri par dictionnaire. Vous pouvez également utiliser l'indicateur -b pour ignorer les espaces principaux, voir man sortet man join).

À titre d'exemple plus général, supposons que vous joignez deux fichiers séparés par des virgules - input1.csvsur la troisième colonne et input2.csvsur la quatrième. Vous pourriez utiliser

join -t, -1 3 -2 4 <(sort -d -t, -k3,3 input2.csv) <(sort -d -t, -k4,4 input2.csv) > output.csv

Ici, les options -1et -2spécifient les champs à joindre respectivement dans les premier et deuxième fichiers d'entrée.

Vous pouvez également utiliser ruby ​​pour faire quelque chose de similaire:

ruby -pe 'File.open("id.csv").each { |i| puts i if i =~ /\$\_/ }' table.csv