Ich habe zwei Dateien A- nodes_to_deleteund B- nodes_to_keep. Jede Datei hat viele Zeilen mit numerischen IDs.

Ich möchte die Liste der numerischen IDs haben, die in, nodes_to_deleteaber NICHT in sind nodes_to_keep, z .

Dies in einer PostgreSQL-Datenbank zu tun, ist unangemessen langsam. Gibt es eine gute Möglichkeit, dies mit Linux CLI-Tools in Bash zu tun?

UPDATE: Dies scheint ein Pythonic-Job zu sein, aber die Dateien sind wirklich sehr, sehr groß. Ich habe einige ähnliche Probleme gelöst mit uniq, sortund einige Mengenlehre Techniken. Dies war ungefähr zwei oder drei Größenordnungen schneller als die Datenbankäquivalente.

Der Befehl comm macht das.

Jemand hat mir vor ein paar Monaten gezeigt, wie man genau das macht, und dann konnte ich es eine Weile nicht finden ... und beim Schauen bin ich auf Ihre Frage gestoßen. Hier ist es :

set_union () {
   sort $1 $2 | uniq
}

set_difference () {
   sort $1 $2 $2 | uniq -u
}

set_symmetric_difference() {
   sort $1 $2 | uniq -u
}

Verwendung comm- Es werden zwei sortierte Dateien Zeile für Zeile verglichen.

Die kurze Antwort auf Ihre Frage

Dieser Befehl gibt Zeilen zurück, die nur für deleteNodes und nicht für keepNodes gelten.

comm -1 -3 <(sort keepNodes) <(sort deleteNodes)

Beispieleinrichtung

Erstellen wir die Dateien mit dem Namen keepNodesund deleteNodesund verwenden sie als unsortierte Eingabe für den commBefehl.

$ cat > keepNodes <(echo bob; echo amber;)
$ cat > deleteNodes <(echo bob; echo ann;)

Wenn Sie comm ohne Argumente ausführen, werden standardmäßig 3 Spalten mit diesem Layout gedruckt:

lines_unique_to_FILE1
    lines_unique_to_FILE2
        lines_which_appear_in_both

Führen Sie in unseren obigen Beispieldateien comm ohne Argumente aus. Beachten Sie die drei Spalten.

$ comm <(sort keepNodes) <(sort deleteNodes)
amber
    ann
        bob

Spaltenausgabe unterdrücken

Unterdrücke Spalte 1, 2 oder 3 mit -N; Beachten Sie, dass beim Ausblenden einer Spalte das Leerzeichen kleiner wird.

$ comm -1 <(sort keepNodes) <(sort deleteNodes)
ann
    bob
$ comm -2 <(sort keepNodes) <(sort deleteNodes)
amber
    bob
$ comm -3 <(sort keepNodes) <(sort deleteNodes)
amber
    ann
$ comm -1 -3 <(sort keepNodes) <(sort deleteNodes)
ann
$ comm -2 -3 <(sort keepNodes) <(sort deleteNodes)
amber
$ comm -1 -2 <(sort keepNodes) <(sort deleteNodes)
bob

Sortieren ist wichtig!

Wenn Sie comm ausführen, ohne die Datei zuerst zu sortieren, schlägt dies ordnungsgemäß mit einer Meldung fehl, welche Datei nicht sortiert ist.

comm: file 1 is not in sorted order

comm wurde speziell für diese Art von Anwendungsfall entwickelt, erfordert jedoch sortierte Eingaben.

awkist wohl ein besseres Werkzeug dafür, da es ziemlich einfach ist, Mengenunterschiede zu finden, dies nicht erfordert sortund zusätzliche Flexibilität bietet.

awk 'NR == FNR { a[$0]; next } !($0 in a)' nodes_to_keep nodes_to_delete

Vielleicht möchten Sie zum Beispiel nur den Unterschied in Zeilen finden, die nicht negative Zahlen darstellen:

awk -v r='^[0-9]+$' 'NR == FNR && $0 ~ r {
    a[$0]
    next
} $0 ~ r && !($0 in a)' nodes_to_keep nodes_to_delete

Vielleicht brauchen Sie einen besseren Weg, um es in Postgres zu tun. Ich kann ziemlich wetten, dass Sie keinen schnelleren Weg finden, dies mit Flatfiles zu tun. Sie sollten in der Lage sein, einen einfachen inneren Join durchzuführen und davon auszugehen, dass beide ID-Spalten indiziert sind, was sehr schnell sein sollte.

Dies unterscheidet sich also geringfügig von den anderen Antworten. Ich kann nicht sagen, dass ein C ++ - Compiler genau ein "Linux CLI-Tool" ist, aber das Ausführen g++ -O3 -march=native -o set_diff main.cpp(mit dem folgenden Code main.cppkann den Trick machen):

#include<algorithm>
#include<iostream>
#include<iterator>
#include<fstream>
#include<string>
#include<unordered_set>

using namespace std;

int main(int argc, char** argv) {
    ifstream keep_file(argv[1]), del_file(argv[2]);
    unordered_multiset<string> init_lines{istream_iterator<string>(keep_file), istream_iterator<string>()};
    string line;
    while (getline(del_file, line)) {
        init_lines.erase(line);
    }
    copy(init_lines.begin(),init_lines.end(), ostream_iterator<string>(cout, "\n"));
}

Zur Verwendung einfach ausführen set_diff B A( nicht A B , da Bist nodes_to_keep) und der resultierende Unterschied wird auf stdout gedruckt.

Beachten Sie, dass ich auf einige bewährte Methoden für C ++ verzichtet habe, um den Code einfacher zu halten.

Es könnten viele zusätzliche Geschwindigkeitsoptimierungen vorgenommen werden (zum Preis von mehr Speicher). mmapwäre auch besonders nützlich für große Datenmengen, aber das würde den Code viel komplizierter machen.

Da Sie erwähnt haben, dass die Datenmengen groß sind, hielt ich das Lesen nodes_to_deleteeiner Zeile gleichzeitig für eine gute Idee, um den Speicherverbrauch zu reduzieren. Der im obigen Code verfolgte Ansatz ist nicht besonders effizient, wenn sich viele Dupes in Ihrem befinden nodes_to_delete. Auch die Ordnung bleibt nicht erhalten.

Etwas, das einfacher zu kopieren und einzufügen ist bash(dh die Erstellung von überspringt main.cpp):

g++ -O3 -march=native -xc++ -o set_diff - <<EOF
#include<algorithm>
#include<iostream>
#include<iterator>
#include<fstream>
#include<string>
#include<unordered_set>

using namespace std;

int main(int argc, char** argv) {
        ifstream keep_file(argv[1]), del_file(argv[2]);
        unordered_multiset<string> init_lines{istream_iterator<string>(keep_file), istream_iterator<string>()};
        string line;
        while (getline(del_file, line)) {
                init_lines.erase(line);
        }
        copy(init_lines.begin(),init_lines.end(), ostream_iterator<string>(cout, "\n"));
}
EOF