Czy istnieje sposób na zmodyfikowanie pliku w miejscu?

Mam dość duży plik (35 GB) i chciałbym filtrować ten plik in situ (tzn. Nie mam wystarczającej ilości miejsca na inny plik), a konkretnie chcę grepować i ignorować niektóre wzorce - czy istnieje sposób na zrobić to bez użycia innego pliku?

Powiedzmy, że chcę odfiltrować wszystkie wiersze zawierające foo:na przykład ...

Na poziomie wywołania systemowego powinno to być możliwe. Program może otworzyć plik docelowy do pisania bez obcinania go i rozpocząć zapisywanie tego, co czyta ze standardowego wejścia. Podczas odczytu EOF plik wyjściowy można obciąć.

Ponieważ filtrujesz linie z wejścia, pozycja zapisu pliku wyjściowego powinna zawsze być mniejsza niż pozycja odczytu. Oznacza to, że nie powinieneś uszkadzać danych wejściowych nowym wyjściem.

Problemem jest jednak znalezienie programu, który to robi. dd(1)ma opcję conv=notrunc, która nie obcina pliku wyjściowego przy otwartym, ale również nie obcina na końcu, pozostawiając oryginalną zawartość pliku po zawartości grep (przy pomocy polecenia podobnego grep pattern bigfile | dd of=bigfile conv=notrunc)

Ponieważ jest to bardzo proste z perspektywy wywołań systemowych, napisałem mały program i przetestowałem go na małym (1MiB) systemie plików z pełną pętlą zwrotną. Zrobił to, co chciałeś, ale naprawdę chcesz najpierw przetestować to z innymi plikami. Zastąpienie pliku zawsze będzie ryzykowne.

overwrite.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);
}

Użyłbyś go jako:

grep pattern bigfile | overwrite bigfile

Przeważnie publikuję to, aby inni mogli komentować, zanim spróbujesz. Być może ktoś inny wie o programie, który robi coś podobnego, co jest bardziej testowane.

Możesz użyć seddo edycji plików w miejscu (ale to tworzy pośredni plik tymczasowy):

Aby usunąć wszystkie wiersze zawierające foo:

sed -i '/foo/d' myfile

Aby zachować wszystkie wiersze zawierające foo:

sed -i '/foo/!d' myfile

Zakładam, że twoje polecenie filter jest tym, co nazywam filtrem zmniejszającym przedrostek , który ma właściwość polegającą na tym, że bajt N w danych wyjściowych nigdy nie jest zapisywany przed odczytaniem co najmniej N bajtów danych wejściowych. grepma tę właściwość (o ile tylko filtruje i nie wykonuje innych czynności, takich jak dodawanie numerów wierszy dla dopasowań). Za pomocą takiego filtra możesz nadpisywać wprowadzane dane. Oczywiście musisz być pewien, że nie popełnisz błędu, ponieważ nadpisana część na początku pliku zostanie utracona na zawsze.

Większość narzędzi uniksowych daje jedynie opcję dołączenia do pliku lub obcięcia go, bez możliwości zastąpienia go. Jedynym wyjątkiem w standardowym zestawie narzędzi jest to dd, że można powiedzieć, aby nie obcinał swojego pliku wyjściowego. Zatem plan polega na przefiltrowaniu polecenia dd conv=notrunc. Nie zmienia to rozmiaru pliku, więc pobieramy również długość nowej zawartości i skracamy plik do tej długości (ponownie za pomocą dd). Pamiętaj, że to zadanie z natury nie jest niezawodne - jeśli wystąpi błąd, jesteś sam.

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

Możesz napisać szorstki odpowiednik Perla. Oto szybkie wdrożenie, które nie próbuje być skuteczne. Oczywiście możesz również przeprowadzić wstępne filtrowanie bezpośrednio w tym języku.

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

Z każdą powłoką podobną do Bourne'a:

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

Z jakiegoś powodu wydaje się, że ludzie zapominają o tym 40-latku¹ i standardowym operatorze przekierowania odczytu i zapisu.

Otwieramy bigfilew trybie odczytu i zapisu + (co najważniejsze tutaj) bez obcięcia na stdoutczas bigfilejest otwarty (osobno) na cat„s stdin. Po grepzakończeniu i jeśli usunął niektóre linie, stdoutteraz wskazuje gdzieś wewnątrz bigfile, musimy pozbyć się tego, co jest poza tym punktem. Stąd perlpolecenie, które obcina plik ( truncate STDOUT) w bieżącej pozycji (zwróconej przez tell STDOUT).

( catdotyczy GNU, grepktóry w przeciwnym razie narzeka, jeśli stdin i stdout wskazują ten sam plik).

^{¹ Cóż, chociaż <>znajdował się w powłoce Bourne'a od początku lat siedemdziesiątych, początkowo był nieudokumentowany i nie został właściwie zaimplementowany . Nie było to w oryginalnej implementacji ashz 1989 roku i chociaż jest to shoperator przekierowywania POSIX (od wczesnych lat 90., ponieważ shoparty jest na POSIX, ksh88który zawsze go miał), nie został dodany do FreeBSD shna przykład do 2000 roku, więc przenośnie 15 lat stary jest prawdopodobnie dokładniejszy. Zauważ też, że domyślny deskryptor pliku, gdy nie jest określony, znajduje się <>we wszystkich powłokach, z wyjątkiem tego, że w 2010 r ksh93. Zmienił się z 0 na 1 w ksh93t + (łamanie kompatybilności wstecznej i zgodności z POSIX)}

Chociaż jest to stare pytanie, wydaje mi się, że jest to pytanie odwieczne i dostępne jest bardziej ogólne, jaśniejsze rozwiązanie, niż dotychczas sugerowano. Kredyt tam, gdzie należny jest kredyt: nie jestem pewien, czy wymyśliłbym to bez wzmianki o Stéphane Chazelas o <>operatorze aktualizacji.

Otwarcie pliku do aktualizacji w powłoce Bourne'a ma ograniczone zastosowanie. Powłoka nie umożliwia wyszukiwania pliku ani ustawiania jego nowej długości (jeśli jest krótsza niż stara). Ale łatwo to naprawić, więc jestem zaskoczony, że nie jest to standardowe narzędzie /usr/bin.

To działa:

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

Podobnie jak to (czapka dla Stéphane'a):

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

(Używam GNU grep. Być może coś się zmieniło, odkąd napisał swoją odpowiedź).

Tyle że nie masz / usr / bin / ftruncate . Aby zobaczyć kilkadziesiąt linii C, możesz zobaczyć poniżej. To narzędzie ftruncate obcina dowolny deskryptor pliku do dowolnej długości, domyślnie ustawiając standardowe wyjście i bieżącą pozycję.

Powyższe polecenie (pierwszy przykład)

• otwiera deskryptor pliku 4 w Tcelu aktualizacji. Podobnie jak w przypadku open (2), otwarcie pliku w ten sposób ustawia bieżące przesunięcie na 0.
• grep następnie przetwarza Tnormalnie, a powłoka przekierowuje swoje wyjście na Tdeskryptor 4.
• ftruncate wywołuje ftruncate (2) na deskryptorze 4, ustawiając długość na wartość bieżącego przesunięcia (dokładnie tam, gdzie zostawił go grep ).

Następnie podpowłoka kończy działanie, zamykając deskryptor 4. Oto 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;
}

Uwaga: ftruncate (2) nie może być importowany, jeśli jest używany w ten sposób. Aby uzyskać absolutną ogólność, przeczytaj ostatni zapisany bajt, ponownie otwórz plik O_WRONLY, wyszukaj, zapisz bajt i zamknij.

Biorąc pod uwagę, że pytanie ma 5 lat, powiem, że to rozwiązanie jest nieoczywiste. Korzysta z exec, aby otworzyć nowy deskryptor, a <>operator, oba są tajemne. Nie mogę wymyślić standardowego narzędzia, które manipuluje i-węzłem za pomocą deskryptora pliku. (Składnia może być ftruncate >&4, ale nie jestem pewien, czy poprawa.) Jest znacznie krótsza niż kompetentna, eksploracyjna odpowiedź camh. Jest tylko trochę jaśniejszy niż Stéphane, IMO, chyba że bardziej lubisz Perla niż ja. Mam nadzieję, że ktoś uzna to za przydatne.

Innym sposobem na zrobienie tego samego byłaby wykonywalna wersja lseek (2), która zgłasza bieżące przesunięcie; wyjście może być wykorzystane do / usr / bin / truncate , które zapewniają niektóre Linuxi.

ed jest prawdopodobnie właściwym wyborem do edycji pliku w miejscu:

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

Możesz użyć deskryptora pliku bash do odczytu / zapisu, aby otworzyć swój plik (aby go zastąpić na miejscu), a następnie sedi truncate... ale oczywiście nie dopuść do tego, aby zmiany były większe niż ilość odczytanych danych .

Oto skrypt (używa: zmienna bash $ 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

Oto wynik testu

# 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

Chciałbym zmapować plik w pamięci, zrobić wszystko w miejscu za pomocą wskaźników char * do nagiej pamięci, a następnie odwzorować plik i obciąć go.

Nie do końca na miejscu, ale - może to być przydatne w podobnych okolicznościach.
Jeśli miejsce na dysku stanowi problem, najpierw skompresuj plik (ponieważ jest to tekst, co da ogromną redukcję), a następnie użyj sed (lub grep, lub cokolwiek innego) w zwykły sposób w środku potoku dekompresji / kompresji.

# 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

Z korzyścią dla każdego, kto przejrzy to pytanie, poprawną odpowiedzią jest przestanie szukać niejasnych funkcji powłoki, które grożą uszkodzeniem pliku z powodu nieznacznego wzrostu wydajności, i zamiast tego należy użyć pewnej odmiany tego wzorca:

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

Tylko w niezwykle rzadkiej sytuacji , gdy z jakiegoś powodu nie jest to możliwe, powinieneś poważnie rozważyć inne odpowiedzi na tej stronie (chociaż z pewnością są interesujące do przeczytania). Przyznaję, że zagadka OP polegająca na braku miejsca na dysku do utworzenia drugiego pliku jest właśnie taką sytuacją. Chociaż nawet wtedy są dostępne inne opcje, np. Dostarczone przez @Ed Randall i @Basile Starynkevitch.

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