Fusionner / trier efficacement / un grand nombre unique de fichiers texte

J'essaie un naïf:

$ cat * | sort -u > /tmp/bla.txt

qui échoue avec:

-bash: /bin/cat: Argument list too long

Donc, pour éviter une solution idiote comme (crée un énorme fichier temporaire):

$ find . -type f -exec cat {} >> /tmp/unsorted.txt \;
$ cat /tmp/unsorted.txt | sort -u > /tmp/bla.txt

Je pensais que je pouvais traiter les fichiers un par un en utilisant (cela devrait réduire la consommation de mémoire et être plus proche d'un mécanisme de streaming):

$ cat proc.sh
#!/bin/sh
old=/tmp/old.txt
tmp=/tmp/tmp.txt
cat $old "$1" | sort -u > $tmp
mv $tmp $old

Suivi ensuite par:

$ touch /tmp/old.txt
$ find . -type f -exec /tmp/proc.sh {} \;

Existe-t-il un remplacement plus simple de style Unix pour: cat * | sort -ulorsque le nombre de fichiers atteint MAX_ARG? Il est difficile d'écrire un petit script shell pour une tâche aussi courante.

Avec GNU sort, et un shell où printfest intégré (tous ceux de type POSIX de nos jours sauf quelques variantes de pdksh):

printf '%s\0' * | sort -u --files0-from=- > output

Maintenant, un problème avec cela est que parce que les deux composants de ce pipeline sont exécutés simultanément et indépendamment, au moment où celui de gauche développe le *glob, le droit peut avoir outputdéjà créé le fichier, ce qui pourrait poser problème (peut-être pas avec -uici) comme ce outputserait à la fois un fichier d'entrée et de sortie, vous voudrez peut-être que la sortie aille dans un autre répertoire ( > ../outputpar exemple), ou assurez-vous que le glob ne correspond pas au fichier de sortie.

Une autre façon de le résoudre dans ce cas est de l'écrire:

printf '%s\0' * | sort -u --files0-from=- -o output

De cette façon, il sorts'ouvre outputpour l'écriture et (dans mes tests), il ne le fera pas avant d'avoir reçu la liste complète des fichiers (tant de temps après que le glob ait été développé). Cela évitera également de vous encombrer outputsi aucun des fichiers d'entrée n'est lisible.

Une autre façon de l'écrire avec zshoubash

sort -u --files0-from=<(printf '%s\0' *) -o output

Cela utilise la substitution de processus (où <(...)est remplacé par un chemin de fichier qui se réfère à la fin de lecture du canal d' printfécriture). Cette fonctionnalité vient de ksh, mais kshinsiste pour rendre l'expansion d' <(...)un argument séparé à la commande afin que vous ne puissiez pas l'utiliser avec la --option=<(...)syntaxe. Cela fonctionnerait cependant avec cette syntaxe:

sort -u --files0-from <(printf '%s\0' *) -o output

Notez que vous verrez une différence avec les approches qui alimentent la sortie de catsur les fichiers dans les cas où il y a des fichiers qui ne se terminent pas par un caractère de nouvelle ligne:

$ printf a > a
$ printf b > b
$ printf '%s\0' a b | sort -u --files0-from=-
a
b
$ printf '%s\0' a b | xargs -r0 cat | sort -u
ab

Notez également que sorttrie en utilisant l'algorithme de classement dans les paramètres régionaux ( strcollate()), et sort -usignale une de chaque ensemble de lignes qui trient la même chose par cet algorithme, pas des lignes uniques au niveau de l'octet. Si vous ne vous souciez que des lignes uniques au niveau de l'octet et ne vous souciez pas tellement de l'ordre dans lequel elles sont triées, vous souhaiterez peut-être fixer les paramètres régionaux à C où le tri est basé sur les valeurs d'octets ( memcmp(); cela accélérerait probablement les choses de manière significative):

printf '%s\0' * | LC_ALL=C sort -u --files0-from=- -o output

Un correctif simple, fonctionne au moins dans Bash, car il printfest intégré, et les limites des arguments de la ligne de commande ne s'appliquent pas:

printf "%s\0" * | xargs -0 cat | sort -u > /tmp/bla.txt

( echo * | xargsfonctionnerait également, sauf pour la gestion des noms de fichiers avec des espaces blancs, etc.)

find . -maxdepth 1 -type f ! -name ".*" -exec cat {} + | sort -u -o /path/to/sorted.txt

Cela va concaténer tous les fichiers réguliers non cachés dans le répertoire courant et trier leur contenu combiné (tout en supprimant les lignes dupliquées) dans le fichier /path/to/sorted.txt.

L'efficacité est un terme relatif, vous devez donc vraiment spécifier quel facteur vous souhaitez minimiser; cpu, mémoire, disque, temps, etc. Pour les besoins de l'argument, je vais supposer que vous vouliez minimiser l'utilisation de la mémoire et êtes prêt à passer plus de cycles de cpu pour y parvenir. Des solutions comme celle de Stéphane Chazelas fonctionnent bien

sort -u --files0-from <(printf '%s\0' *) > ../output

mais ils supposent que les fichiers texte individuels ont un haut degré d'unicité pour commencer. Si ce n'est pas le cas, c'est-à-dire si après

sort -u < sample.txt > sample.srt

sample.srt est plus de 10% plus petit que sample.txt, vous économiserez alors de la mémoire en supprimant les doublons dans les fichiers avant de fusionner. Vous économiserez également davantage de mémoire en ne chaînant pas les commandes, ce qui signifie que les résultats de différents processus n'ont pas besoin d'être en mémoire en même temps.

find /somedir -maxdepth 1 type f -exec sort -u -o {} {} \;
sort -u --files0-from <(printf '%s\0' *) > ../output

Comme @ilkkachu, mais le chat (1) n'est pas nécessaire:

printf "%s\0" * | xargs -0 sort -u

De plus, si les données sont si longues, vous voudrez peut-être utiliser l'option sort (1) --parallel = N

Lorsque N est le nombre de CPU que votre ordinateur possède