Grep enorme numero di modelli da un enorme file

Ho un file che cresce di circa 200.000 righe al giorno ed è tutto formato con blocchi di tre righe come tali:

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

Ora, ho un altro file da cui estraggo circa 10.000 schemi chiave, come 1358726575123. Quindi eseguo un forciclo con questi modelli e devo verificarli con il primo file. Se il file non contiene tale modello, lo salvo in un terzo file per ulteriore elaborazione:

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

Il codice di esempio utilizza un file enorme 10.000 volte, e eseguo questo ciclo circa una volta al minuto, per tutto il giorno .

Dato che l'enorme file continua a crescere, cosa posso fare per rendere tutto più veloce e risparmiare un po 'di CPU? Mi chiedo se l'ordinamento del file in qualche modo tramite la sua chiave (se sì, come?) O l'utilizzo di un db invece del semplice testo aiuterebbe ...

Questa risposta si basa sulla awkrisposta pubblicata da potong ..
È due volte più veloce del commmetodo (sul mio sistema), per gli stessi 6 milioni di righe nel file principale e 10 mila chiavi ... (ora aggiornato per usare FNR, NR)

Sebbene awksia più veloce del tuo sistema attuale e fornirà a te e al tuo computer un po 'di respiro, tieni presente che quando l'elaborazione dei dati è intensa come hai descritto, otterrai i migliori risultati complessivi passando a un database dedicato; per esempio. 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

Il problema, ovviamente, è che esegui grep sul file di grandi dimensioni 10.000 volte. Dovresti leggere entrambi i file una sola volta. Se vuoi rimanere fuori dai linguaggi di scripting, puoi farlo in questo modo:

1. Estrarre tutti i numeri dal file 1 e ordinarli
2. Estrai tutti i numeri dal file 2 e ordinali
3. Esegui commsugli elenchi ordinati per ottenere ciò che è solo sul secondo elenco

Qualcosa come questo:

$ 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

Vedere man comm.

Se potessi troncare il file di grandi dimensioni ogni giorno (come un file di registro) potresti conservare una cache di numeri ordinati e non dovrai analizzarlo ogni volta.

Sì, sicuramente utilizzare un database. Sono fatti esattamente per compiti come questo.

Questo potrebbe funzionare per te:

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

MODIFICARE:

Lo script modificato per consentire duplicati e chiavi sconosciute in entrambi i file, produce ancora chiavi dal primo file non presenti nel secondo:

 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

Con così tanti dati, dovresti davvero passare a un database. Nel frattempo, una cosa che devi fare per avvicinarti a prestazioni decenti è non cercare file1separatamente ogni tasto. Esegui un singolo grepper estrarre contemporaneamente tutte le chiavi non escluse. Dal momento che greprestituisce anche righe che non contengono una chiave, filtrale via.

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

( -Fxsignifica cercare intere righe, letteralmente. -f -significa leggere un elenco di schemi dall'input standard.)

Mi permetta di rinforzare ciò che gli altri hanno detto: "Portati in un database!"

Esistono binari MySQL disponibili gratuitamente per la maggior parte delle piattaforme.

Perché non SQLite? È basato sulla memoria, carica un file flat quando lo avvii, quindi chiudendolo quando hai finito. Ciò significa che se il computer si arresta in modo anomalo o il processo SQLite si interrompe, lo stesso vale per tutti i dati.

Il tuo problema sembra solo un paio di righe di SQL e verrà eseguito in millisecondi!

Dopo aver installato MySQL (che consiglio su altre scelte), sborserei $ 40 per il Cookbook SQL O'Reilly di Anthony Molinaro, che ha molti schemi di problemi, a partire da SELECT * FROM tablequery semplici e passando attraverso aggregati e join multipli.

Non sono sicuro se questo è l'output esatto che stai cercando, ma probabilmente il modo più semplice è:

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

Puoi anche usare:

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

Ognuno di questi crea un file di pattern temporaneo che viene utilizzato per estrarre i numeri dal file di grandi dimensioni ( file1).

Sono pienamente d'accordo che tu ottenga un database (MySQL è abbastanza facile da usare). Fino a quando non riuscirai a farlo funzionare, mi piace la commsoluzione di Angus , ma così tante persone ci stanno provando grepe sbagliano che pensavo di mostrare il (o almeno un) modo corretto di farlo grep.

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

Il primo grepottiene le chiavi. Il terzo grep(nel <(...)) prende tutte le chiavi usate nel file grande e lo <(...)passa come un file come argomento a -fnel secondo grep. Ciò fa sì che il secondo greplo utilizzi come un elenco di righe corrispondenti. Quindi utilizza questo per abbinare il suo input (l'elenco delle chiavi) dalla pipe (prima grep) e stampa tutte le chiavi estratte dal file delle chiavi e non ( -v) il file grande.

Ovviamente puoi farlo con i file temporanei di cui devi tenere traccia e ricordare di eliminare:

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

Questo stampa tutte le linee in allkeyscui non appaiono usedkeys.

Il file di chiavi non cambia? Quindi dovresti evitare di cercare più volte le voci precedenti.

Con tail -fte puoi ottenere l'output di un file in crescita.

tail -f growingfile | grep -f keyfile 

grep -f legge i pattern da un file, una riga come pattern.

Non avevo intenzione di pubblicare la mia risposta perché pensavo che una tale quantità di dati non dovesse essere elaborata con uno script di shell e la risposta giusta per utilizzare un database era già stata fornita. Ma da ora ci sono altri 7 approcci ...

Legge il primo file in memoria, quindi greps il secondo file per i numeri e controlla se i valori sono memorizzati. Dovrebbe essere più veloce di più greps, se hai memoria sufficiente per caricare l'intero file, cioè.

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

Sono d'accordo con @ jan-steinman che dovresti usare un database per questo tipo di attività. Ci sono molti modi per hackerare insieme una soluzione con uno script di shell come mostrano le altre risposte, ma farlo in questo modo porterà a molta sofferenza se intendi utilizzare e mantenere il codice per un periodo di tempo superiore a solo un progetto usa e getta di un giorno.

Supponendo che tu sia su una scatola Linux, molto probabilmente hai Python installato per impostazione predefinita che include la libreria sqlite3 a partire da Python v2.5. Puoi controllare la tua versione di Python con:

% python -V
Python 2.7.2+

Consiglio di utilizzare la libreria sqlite3 perché è una soluzione basata su file semplice per tutte le piattaforme (incluso all'interno del browser Web!) E non richiede l'installazione di un server. Essenzialmente configurazione zero e manutenzione zero.

Di seguito è riportato un semplice script Python che analizzerà il formato file che hai fornito come esempio e quindi esegue una semplice query "seleziona tutto" e restituisce tutto ciò che è archiviato nel database.

#!/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

Sì, questo significa che dovrai imparare un po 'di SQL , ma ne varrà la pena nel lungo periodo. Inoltre, invece di analizzare i file di registro, forse potresti scrivere i dati direttamente nel tuo database sqlite.