Grep un grand nombre de modèles à partir d'un fichier énorme

J'ai un fichier qui augmente d'environ 200 000 lignes par jour, et il est formé de blocs de trois lignes en tant que tels:

1358726575123       # key
    Joseph Muller   # name
    carpenter       # job
9973834728345
    Andres Smith
    student
7836472098652
    Mariah Anthony
    dentist

Maintenant, j'ai un autre fichier à partir duquel j'extrais environ 10 000 modèles de clés, tels que 1358726575123. Ensuite, je lance une forboucle avec ces modèles et je dois les comparer avec le premier fichier. Si le fichier ne contient pas un tel modèle, j'enregistre le modèle dans un troisième fichier pour un traitement ultérieur:

for number in $(grep -o '[0-9]\{12\}' file2); do  # finds about 10.000 keys
     if ! grep -q ^$number$ file1; then           # file1 is a huge file
         printf "$number\n" >>file3               # we'll process file3 later
     fi
done

L'exemple de code récupère un énorme fichier 10 000 fois et j'exécute cette boucle environ une fois par minute, pendant toute la journée .

Étant donné que l'énorme fichier continue de croître, que puis-je faire pour accélérer tout cela et économiser du processeur? Je me demande si le tri du fichier par sa clé (si oui, comment?) Ou l'utilisation d'une base de données au lieu de texte brut aiderait ...

Cette réponse est basée sur la awkréponse postée par potong ..
Elle est deux fois plus rapide que la commméthode (sur mon système), pour les mêmes 6 millions de lignes dans le fichier principal et 10 mille clés ... (maintenant mis à jour pour utiliser FNR, NR)

Bien qu'il awksoit plus rapide que votre système actuel, et vous donnera à vous et à vos ordinateurs un peu de répit, sachez que lorsque le traitement des données est aussi intense que vous l'avez décrit, vous obtiendrez les meilleurs résultats globaux en passant à une base de données dédiée; par exemple. SQlite, MySQL ...

awk '{ if (/^[^0-9]/) { next }              # Skip lines which do not hold key values
       if (FNR==NR) { main[$0]=1 }          # Process keys from file "mainfile"
       else if (main[$0]==0) { keys[$0]=1 } # Process keys from file "keys"
     } END { for(key in keys) print key }' \
       "mainfile" "keys" >"keys.not-in-main"

# For 6 million lines in "mainfile" and 10 thousand keys in "keys"

# The awk  method
# time:
#   real    0m14.495s
#   user    0m14.457s
#   sys     0m0.044s

# The comm  method
# time:
#   real    0m27.976s
#   user    0m28.046s
#   sys     0m0.104s

Le problème, bien sûr, est que vous exécutez grep sur le gros fichier 10 000 fois. Vous ne devez lire les deux fichiers qu'une seule fois. Si vous voulez rester en dehors des langages de script, vous pouvez le faire de cette façon:

1. Extraire tous les numéros du fichier 1 et les trier
2. Extraire tous les numéros du fichier 2 et les trier
3. Exécuter commsur les listes triées pour obtenir ce qui n'est que sur la deuxième liste

Quelque chose comme ça:

$ grep -o '^[0-9]\{12\}$' file1 | sort -u -o file1.sorted
$ grep -o  '[0-9]\{12\}'  file2 | sort -u -o file2.sorted
$ comm -13 file1.sorted file2.sorted > file3

Tu vois man comm.

Si vous pouviez tronquer le gros fichier tous les jours (comme un fichier journal), vous pourriez garder un cache de numéros triés et n'auriez pas besoin de l'analyser en entier à chaque fois.

Oui, utilisez certainement une base de données. Ils sont faits exactement pour des tâches comme celle-ci.

Cela pourrait fonctionner pour vous:

 awk '/^[0-9]/{a[$0]++}END{for(x in a)if(a[x]==1)print x}' file{1,2} >file3

ÉDITER:

Script modifié pour permettre les doublons et les clés inconnues dans les deux fichiers, produit toujours des clés à partir du premier fichier non présentes dans le second:

 awk '/^[0-9]/{if(FNR==NR){a[$0]=1;next};if($0 in a){a[$0]=2}}END{for(x in a)if(a[x]==1)print x}' file{1,2} >file3

Avec autant de données, vous devriez vraiment passer à une base de données. En attendant, une chose que vous devez faire pour obtenir des performances décentes est de ne pas rechercher file1séparément chaque clé. Exécutez-en un greppour extraire toutes les clés non exclues à la fois. Étant donné que cela greprenvoie également les lignes qui ne contiennent pas de clé, filtrez-les.

grep -o '[0-9]\{12\}' file2 |
grep -Fxv -f - file1 |
grep -vx '[0-9]\{12\}' >file3

( -Fxsignifie littéralement rechercher des lignes entières. -f -signifie lire une liste de modèles à partir d'une entrée standard.)

Permettez-moi de renforcer ce que les autres ont dit: "Accédez à une base de données!"

Des binaires MySQL sont disponibles gratuitement pour la plupart des plateformes.

Pourquoi pas SQLite? Il est basé sur la mémoire, charge un fichier plat lorsque vous le démarrez, puis le ferme lorsque vous avez terminé. Cela signifie que si votre ordinateur tombe en panne ou que le processus SQLite disparaît, il en va de même pour toutes les données.

Votre problème ne ressemble qu'à quelques lignes de SQL et s'exécutera en millisecondes!

Après avoir installé MySQL (que je recommande par rapport à d'autres choix), je débourserais 40 $ pour le livre de recettes SQL d'O'Reilly par Anthony Molinaro, qui présente de nombreux modèles de problèmes, commençant par des SELECT * FROM tablerequêtes simples et passant par des agrégats et plusieurs jointures.

Je ne sais pas si c'est la sortie exacte que vous recherchez, mais probablement le moyen le plus simple est:

grep -o '[0-9]\{12\}' file2 | sed 's/.*/^&$/' > /tmp/numpatterns.grep
grep -vf /tmp/numpatterns.grep file1 > file3
rm -f /tmp/numpatterns.grep

Vous pouvez également utiliser:

sed -ne '/.*\([0-9]\{12\}.*/^\1$/p' file2 > /tmp/numpatterns.grep
grep -vf /tmp/numpatterns.grep file1 > file3
rm -f /tmp/numpatterns.grep

Chacun d'eux crée un fichier de motif temporaire qui est utilisé pour extraire les nombres du grand fichier ( file1).

Je suis entièrement d'accord avec vous pour obtenir une base de données (MySQL est assez facile à utiliser). Jusqu'à ce que vous exécutiez cela, j'aime la commsolution d'Angus , mais tellement de gens essaient grepet se trompent que je pensais montrer la (ou au moins une) bonne façon de le faire grep.

grep -o '[0-9]\{12\}' keyfile | grep -v -f <(grep -o '^[0-9]\{12\}' bigfile) 

Le premier greprécupère les clés. Le troisième grep(dans le <(...)) prend toutes les clés utilisées dans le gros fichier, et le <(...)passe comme un fichier comme argument -fdans le deuxième grep. Cela oblige le second grepà l'utiliser comme une liste de lignes à faire correspondre. Il l'utilise ensuite pour faire correspondre son entrée (la liste des clés) à partir du canal (en premier grep), et imprime toutes les clés extraites du fichier de clés et non ( -v) le gros fichier.

Bien sûr, vous pouvez le faire avec des fichiers temporaires dont vous devez garder la trace et ne pas oublier de supprimer:

grep -o '[0-9]\{12\}'  keyfile >allkeys
grep -o '^[0-9]\{12\}' bigfile >usedkeys
grep -v -f usedkeys allkeys

Cela imprime toutes les lignes allkeysqui n'apparaissent pas dans usedkeys.

Le fichier clé ne change pas? Ensuite, vous devez éviter de rechercher encore et encore les anciennes entrées.

Avec tail -fvous pouvez obtenir la sortie d'un fichier en pleine croissance.

tail -f growingfile | grep -f keyfile 

grep -f lit les motifs dans un fichier, une ligne comme motif.

N'allait pas publier ma réponse parce que je pensais qu'une telle quantité de données ne devrait pas être traitée avec un script shell, et la bonne réponse pour utiliser une base de données était déjà donnée. Mais depuis maintenant, il existe 7 autres approches ...

Lit le premier fichier en mémoire, puis recherche le deuxième fichier pour les nombres et vérifie si les valeurs sont stockées en mémoire. Cela devrait être plus rapide que plusieurs greps, si vous avez suffisamment de mémoire pour charger le fichier entier, c'est-à-dire.

declare -a record
while read key
do
    read name
    read job
    record[$key]="$name:$job"
done < file1

for number in $(grep -o '[0-9]\{12\}' file2)
do
    [[ -n ${mylist[$number]} ]] || echo $number >> file3
done

Je suis d'accord avec @ jan-steinman que vous devez utiliser une base de données pour ce type de tâche. Il existe de nombreuses façons de pirater une solution avec un script shell comme le montrent les autres réponses, mais le faire de cette façon entraînera beaucoup de misère si vous allez utiliser et maintenir le code pendant une durée supérieure à juste un projet jetable d'une journée.

En supposant que vous êtes sur une boîte Linux, vous avez probablement installé Python par défaut qui inclut la bibliothèque sqlite3 à partir de Python v2.5. Vous pouvez vérifier votre version Python avec:

% python -V
Python 2.7.2+

Je recommande d'utiliser la bibliothèque sqlite3 car c'est une solution simple basée sur des fichiers qui existe pour toutes les plateformes (y compris à l'intérieur de votre navigateur Web!) Et qui ne nécessite pas l'installation d'un serveur. Essentiellement zéro configuration et zéro entretien.

Vous trouverez ci-dessous un simple script python qui analysera le format de fichier que vous avez donné en exemple, puis effectue une simple requête "tout sélectionner" et génère tout ce qu'il a stocké dans la base de données.

#!/usr/bin/env python

import sqlite3
import sys

dbname = '/tmp/simple.db'
filename = '/tmp/input.txt'
with sqlite3.connect(dbname) as conn:
    conn.execute('''create table if not exists people (key integer primary key, name text, job text)''')
    with open(filename) as f:
        for key in f:
            key = key.strip()
            name = f.next().strip()
            job = f.next().strip()
            try:
                conn.execute('''insert into people values (?,?,?)''', (key, name, job))
            except sqlite3.IntegrityError:
                sys.stderr.write('record already exists: %s, %s, %s\n' % (key, name, job))
    cur = conn.cursor()

    # get all people
    cur.execute('''select * from people''')
    for row in cur:
        print row

    # get just two specific people
    person_list = [1358726575123, 9973834728345]
    cur.execute('''select * from people where key in (?,?)''', person_list)
    for row in cur:
        print row

    # a more general way to get however many people are in the list
    person_list = [1358726575123, 9973834728345]
    template = ','.join(['?'] * len(person_list))
    cur.execute('''select * from people where key in (%s)''' % (template), person_list)
    for row in cur:
        print row

Oui, cela signifie que vous devrez apprendre du SQL , mais cela en vaudra la peine à long terme. De plus, au lieu d'analyser vos fichiers journaux, vous pouvez peut-être écrire des données directement dans votre base de données sqlite.