Existe-t-il un moyen de modifier un fichier sur place?

J'ai un fichier assez volumineux (35 Go), et j'aimerais filtrer ce fichier in situ (c'est-à-dire que je n'ai pas assez d'espace disque pour un autre fichier), en particulier je veux grep et ignorer certains modèles - faire cela sans utiliser un autre fichier?

Disons que je veux filtrer toutes les lignes contenant foo:par exemple ...

Au niveau des appels système, cela devrait être possible. Un programme peut ouvrir votre fichier cible en écriture sans le tronquer et commencer à écrire ce qu'il lit à partir de stdin. Lors de la lecture de EOF, le fichier de sortie peut être tronqué.

Puisque vous filtrez les lignes depuis l'entrée, la position d'écriture du fichier de sortie doit toujours être inférieure à la position de lecture. Cela signifie que vous ne devriez pas corrompre votre entrée avec la nouvelle sortie.

Cependant, trouver un programme qui fait cela est le problème. dd(1)a l'option conv=notruncqui ne tronque pas le fichier de sortie à l'ouverture, mais ne tronque pas non plus à la fin, laissant le contenu du fichier d'origine après le contenu de grep (avec une commande similaire grep pattern bigfile | dd of=bigfile conv=notrunc)

Comme il est très simple du point de vue des appels système, j’ai écrit un petit programme et l’ai testé sur un petit système de fichiers en boucle (1 Mo). Il a fait ce que vous vouliez, mais vous voulez vraiment le tester d'abord avec d'autres fichiers. Il y aura toujours des risques à écraser un fichier.

écraser.c

/* This code is placed in the public domain by camh */

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>

int main(int argc, char **argv)
{
        int outfd;
        char buf[1024];
        int nread;
        off_t file_length;

        if (argc != 2) {
                fprintf(stderr, "usage: %s <output_file>\n", argv[0]);
                exit(1);
        }
        if ((outfd = open(argv[1], O_WRONLY)) == -1) {
                perror("Could not open output file");
                exit(2);
        }
        while ((nread = read(0, buf, sizeof(buf))) > 0) {
                if (write(outfd, buf, nread) == -1) {
                        perror("Could not write to output file");
                        exit(4);
                }
        }
        if (nread == -1) {
                perror("Could not read from stdin");
                exit(3);
        }
        if ((file_length = lseek(outfd, 0, SEEK_CUR)) == (off_t)-1) {
                perror("Could not get file position");
                exit(5);
        }
        if (ftruncate(outfd, file_length) == -1) {
                perror("Could not truncate file");
                exit(6);
        }
        close(outfd);
        exit(0);
}

Vous l'utiliseriez comme:

grep pattern bigfile | overwrite bigfile

Je poste surtout ceci pour que les autres puissent commenter avant de l'essayer. Peut-être que quelqu'un d'autre connait un programme qui fait quelque chose de similaire qui est plus testé.

Vous pouvez utiliser sedpour éditer des fichiers sur place (mais cela crée un fichier temporaire intermédiaire):

Pour supprimer toutes les lignes contenant foo:

sed -i '/foo/d' myfile

Pour garder toutes les lignes contenant foo:

sed -i '/foo/!d' myfile

Je suppose que votre commande de filtre est ce que j'appellerai un filtre de réduction de préfixe , qui a la propriété que l'octet N dans la sortie n'est jamais écrit avant d'avoir lu au moins N octets d'entrée. grepa cette propriété (tant qu’il ne fait que filtrer et ne pas faire d’autres choses comme ajouter des numéros de ligne pour les correspondances). Avec un tel filtre, vous pouvez écraser l’entrée au fur et à mesure. Bien sûr, vous devez vous assurer de ne commettre aucune erreur, car la partie écrasée au début du fichier sera perdue à jamais.

La plupart des outils Unix permettent seulement d'ajouter ou de tronquer un fichier, sans possibilité de l'écraser. La seule exception dans la boîte à outils standard est celle à ddlaquelle on peut dire de ne pas tronquer son fichier de sortie. Le plan consiste donc à filtrer la commande en dd conv=notrunc. Cela ne change pas la taille du fichier, nous allons donc aussi saisir la longueur du nouveau contenu et tronquer le fichier à cette longueur (à nouveau avec dd). Notez que cette tâche est intrinsèquement non robuste - si une erreur se produit, vous êtes seul.

export LC_ALL=C
n=$({ grep -v foo <big_file |
      tee /dev/fd/3 |
      dd of=big_file conv=notrunc; } 3>&1 | wc -c)
dd if=/dev/null of=big_file bs=1 seek=$n

Vous pouvez écrire en gros équivalent Perl. Voici une mise en œuvre rapide qui n'essaie pas d'être efficace. Bien sûr, vous pouvez également effectuer votre filtrage initial directement dans cette langue.

grep -v foo <big_file | perl -e '
  close STDOUT;
  open STDOUT, "+<", $ARGV[0] or die;
  while (<STDIN>) {print}
  truncate STDOUT, tell STDOUT or die
' big_file

Avec n'importe quel shell Bourne-like:

{
  cat < bigfile | grep -v to-exclude
  perl -e 'truncate STDOUT, tell STDOUT'
} 1<> bigfile

Pour une raison quelconque, il semble que les gens ont tendance à oublier cet opérateur de redirection lecture + écriture de 40 ans¹ et standard .

Nous ouvrons bigfileen lecture en mode écriture + et (ce qui est le plus important ici) sans troncature sur stdouttout bigfileest ouvert (séparément) sur cat« s stdin. Après grepa été terminé, et s'il a supprimé certaines lignes et qu'il stdoutpointe maintenant quelque part à l'intérieur bigfile, nous devons nous débarrasser de ce qui est au-delà de ce point. D'où la perlcommande qui tronque le fichier ( truncate STDOUT) à la position actuelle (telle que retournée par tell STDOUT).

( catc'est pour GNU grepqui se plaint sinon si stdin et stdout pointent sur le même fichier).

^{¹ Eh bien, bien qu’il <>soit dans le shell Bourne depuis le début à la fin des années 70, il était initialement non documenté et n’a pas été correctement mis en œuvre . Ce n’était pas dans l’implémentation initiale ashde 1989 et, bien qu’il s’agisse d’un shopérateur de redirection POSIX (depuis le début des années 90, POSIX shétant basé sur ksh88qui l’a toujours eu), il n’a pas été ajouté à FreeBSD, shpar exemple, avant 2000, donc de manière transférable . vieux est probablement plus précis. Notez également que le descripteur de fichier par défaut, lorsqu'il n'est pas spécifié, se trouve <>dans tous les shells, sauf qu'il ksh93est passé de 0 à 1 dans ksh93t + en 2010 (rupture de la compatibilité avec les versions antérieures et de la conformité POSIX).}

Même s’il s’agit d’une question ancienne, il me semble que c’est une question éternelle et qu’une solution plus générale et plus claire que celle suggérée jusqu’à présent est disponible. Le crédit est dû: Je ne suis pas sûr que je l'aurais trouvé sans tenir compte de la mention de Stéphane Chazelas sur l' <>opérateur de mise à jour.

L’ouverture d’un fichier à mettre à jour dans un shell Bourne est d’une utilité limitée. Le shell ne vous donne aucun moyen de rechercher sur un fichier, ni de définir sa nouvelle longueur (si elle est plus courte que l’ancien). Mais on y résout facilement, si facilement que je suis surpris que ce ne soit pas un utilitaire standard de Windows /usr/bin.

Cela marche:

$ grep -n foo T
8:foo
$ (exec 4<>T; grep foo T >&4 && ftruncate 4) && nl T; 
     1  foo

De même que cela (astuce à Stéphane):

$ { grep foo T && ftruncate; } 1<>T  && nl T; 
     1  foo

(J'utilise GNU grep. Peut-être que quelque chose a changé depuis qu'il a écrit sa réponse.)

Sauf que vous n'avez pas / usr / bin / ftruncate . Pour une douzaine de lignes de C, vous pouvez, voir ci-dessous. Cet utilitaire ftruncate tronque un descripteur de fichier arbitraire à une longueur arbitraire, par défaut à la sortie standard et à la position actuelle.

La commande ci-dessus (1er exemple)

• ouvre le descripteur de fichier 4 sur Tpour la mise à jour. Comme avec open (2), ouvrir le fichier de cette façon positionne le décalage actuel à 0.
• grep traite ensuite Tnormalement et le shell redirige sa sortie Tvia le descripteur 4.
• ftruncate appelle ftruncate (2) sur le descripteur 4, en fixant la longueur à la valeur de l'offset actuel (exactement là où grep l'a laissé).

Le sous-shell se ferme alors, fermant le descripteur 4. Voici ftruncate :

#include <err.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int
main( int argc, char *argv[] ) {
  off_t i, fd=1, len=0;
  off_t *addrs[2] = { &fd, &len };

  for( i=0; i < argc-1; i++ ) {
    if( sscanf(argv[i+1], "%lu", addrs[i]) < 1 ) {
      err(EXIT_FAILURE, "could not parse %s as number", argv[i+1]);
    }
  }

  if( argc < 3 && (len = lseek(fd, 0, SEEK_CUR)) == -1 ) {
    err(EXIT_FAILURE, "could not ftell fd %d as number", (int)fd);
  }


  if( 0 != ftruncate((int)fd, len) ) {
    err(EXIT_FAILURE, argc > 1? argv[1] : "stdout");
  }

  return EXIT_SUCCESS;
}

NB, ftruncate (2) est non-portable lorsqu'il est utilisé de cette façon. Pour une généralité absolue, lisez le dernier octet écrit, rouvrez le fichier O_WRONLY, recherchez, écrivez l'octet et fermez-le.

Étant donné que la question a 5 ans, je vais dire que cette solution est non évidente. Il profite d’ exec pour ouvrir un nouveau descripteur et l’ <>opérateur, qui sont tous les deux arcanes. Je ne peux pas penser à un utilitaire standard qui manipule un inode par descripteur de fichier. (La syntaxe pourrait être ftruncate >&4, mais je ne suis pas sûr que ce soit une amélioration.) Elle est considérablement plus courte que la réponse compétente et exploratoire de camh. C'est un peu plus clair que celui de Stéphane, OMI, à moins que vous n'aimiez plus Perl que moi. J'espère que quelqu'un le trouvera utile.

Une autre façon de faire la même chose serait une version exécutable de lseek (2) qui rapporte le décalage actuel; la sortie pourrait être utilisée pour / usr / bin / truncate , fourni par certains Linuxi.

ed est probablement le bon choix pour éditer un fichier sur place:

ed my_big_file << END_OF_ED_COMMANDS
g/foo:/d
w
q 
END_OF_ED_COMMANDS

Vous pouvez utiliser un descripteur de fichier bash en lecture / écriture pour ouvrir votre fichier (pour l'écraser in situ), puis sedet truncate... mais bien sûr, ne laissez jamais vos modifications dépasser le nombre de données lues jusqu'à présent. .

Voici le script (utilise: bash variable $ BASHPID)

# Create a test file
  echo "going abc"  >junk
  echo "going def" >>junk
  echo "# ORIGINAL file";cat junk |tee >( wc=($(wc)); echo "# ${wc[0]} lines, ${wc[2]} bytes" ;echo )
#
# Assign file to fd 3, and open it r/w
  exec 3<> junk  
#
# Choose a unique filename to hold the new file size  and the pid 
# of the semi-asynchrounous process to which 'tee' streams the new file..  
  [[ ! -d "/tmp/$USER" ]] && mkdir "/tmp/$USER" 
  f_pid_size="/tmp/$USER/pid_size.$(date '+%N')" # %N is a GNU extension: nanoseconds
  [[ -f "$f_pid_size" ]] && { echo "ERROR: Work file already exists: '$f_pid_size'" ;exit 1 ; }
#
# run 'sed' output to 'tee' ... 
#  to modify the file in-situ, and to count the bytes  
  <junk sed -e "s/going //" |tee >(echo -n "$BASHPID " >"$f_pid_size" ;wc -c >>"$f_pid_size") >&3
#
#@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
# The byte-counting process is not a child-process, 
# so 'wait' doesn't work... but wait we must...  
  pid_size=($(cat "$f_pid_size")) ;pid=${pid_size[0]}  
  # $f_pid_size may initially contain only the pid... 
  # get the size when pid termination is assured
  while [[ "$pid" != "" ]] ; do
    if ! kill -0 "$pid" 2>/dev/null; then
       pid=""  # pid has terminated. get the byte count
       pid_size=($(cat "$f_pid_size")) ;size=${pid_size[1]}
    fi
  done
  rm "$f_pid_size"
#@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
#
  exec 3>&- # close fd 3.
  newsize=$(cat newsize)
  echo "# MODIFIED file (before truncating)";cat junk |tee >( wc=($(wc)); echo "# ${wc[0]} lines, ${wc[2]} bytes" ;echo )  cat junk
#
 truncate -s $newsize junk
 echo "# NEW (truncated) file";cat junk |tee >( wc=($(wc)); echo "# ${wc[0]} lines, ${wc[2]} bytes" ;echo )  cat junk
#
exit

Voici la sortie de test

# ORIGINAL file
going abc
going def
# 2 lines, 20 bytes

# MODIFIED file (before truncating)
abc
def
c
going def
# 4 lines, 20 bytes

# NEW (truncated) file
abc
def
# 2 lines, 8 bytes

Je mapperais le fichier en mémoire, je mettrais tout en place en utilisant des pointeurs sur la mémoire nue, puis remapperais le fichier et le tronquer.

Pas exactement in situ mais - cela pourrait être utile dans des circonstances similaires.
Si l'espace disque pose problème, commencez par compresser le fichier (car il s'agit de texte, cela donnera une réduction considérable), puis utilisez sed (ou grep, ou autre chose) de la manière habituelle au milieu d'un pipeline de décompression / compression.

# Reduce size from ~35Gb to ~6Gb
$ gzip MyFile

# Edit file, creating another ~6Gb file
$ gzip -dc <MyFile.gz | sed -e '/foo/d' | gzip -c >MyEditedFile.gz

Pour aider ceux qui recherchent cette question dans Google, la bonne solution consiste à cesser de chercher des fonctionnalités de shell obscures qui risquent de corrompre votre fichier pour un gain de performances négligeable, et d'utiliser plutôt une variante de ce modèle:

grep "foo" file > file.new && mv file.new file

Ce n'est que dans la situation extrêmement rare où, pour une raison quelconque, que cela n'est pas réalisable, que vous considériez sérieusement l'une des autres réponses de cette page (bien qu'elles soient certainement intéressantes à lire). Je concéderai que le casse-tête de l'OP qui consiste à ne pas disposer d'espace disque pour créer un deuxième fichier est exactement une telle situation. Même dans ce cas, il existe d’autres options, telles que fournies par @Ed Randall et @Basile Starynkevitch.

echo -e "$(grep pattern bigfile)" >bigfile