unix - divide um enorme arquivo .gz por linha

Question

Tenho certeza de que alguém teve a necessidade abaixo, o que é uma maneira rápida de dividir um arquivo enorme de .gz por linha? O arquivo de texto subjacente tem 120 milhões de linhas. Eu não tenho espaço em disco suficiente para gunzip o arquivo inteiro de uma só vez, então eu queria saber se alguém sabe de um script bash / perl ou ferramenta que poderia dividir o arquivo (.gz ou .txt interno) em arquivos de linha 3x 40mn . ou seja, chamando assim:

    bash splitter.sh hugefile.txt.gz 4000000 1
 would get lines 1 to 40 mn    
    bash splitter.sh hugefile.txt.gz 4000000 2
would get lines 40mn to 80 mn
    bash splitter.sh hugefile.txt.gz 4000000 3
would get lines 80mn to 120 mn

Está talvez fazendo uma série dessas uma solução ou o gunzip -c precisa de espaço suficiente para o arquivo inteiro ser descompactado (isto é, o problema original): gunzip -c hugefile.txt.gz | cabeça 4000000

Nota: não consigo disco extra.

Obrigado!

    

Answer 1

Como fazer isso melhor depende do que você deseja:

• Deseja extrair uma única parte do arquivo grande?
• Ou você quer criar todas as partes de uma só vez?

Se você quiser uma única parte do arquivo , sua ideia de usar gunzip e head está correta. Você pode usar:

gunzip -c hugefile.txt.gz | head -n 4000000

Isso produziria as primeiras 4000000 linhas na saída padrão - você provavelmente deseja acrescentar outro pipe para realmente fazer algo com os dados.

Para obter as outras partes, você usaria uma combinação de head e tail , como:

gunzip -c hugefile.txt.gz | head -n 8000000 |tail -n 4000000

para obter o segundo bloco.

Is perhaps doing a series of these a solution or would the gunzip -c require enough space for the entire file to be unzipped

Não, o gunzip -c não requer nenhum espaço em disco - ele faz tudo na memória e o transmite para o stdout.

Se você quiser criar todas as partes de uma só vez , é mais eficiente criá-las todas com um único comando, porque o arquivo de entrada é lido apenas uma vez. Uma boa solução é usar split ; veja a resposta de jim mcnamara para detalhes.

    

Answer 2

pipe para dividir use gunzip -c ou zcat para abrir o arquivo

gunzip -c bigfile.gz | split -l 400000

Adicione especificações de saída ao comando split.

    

Answer 3

Como você está trabalhando em um fluxo (não rebobinável), você vai querer usar a forma de cauda '+ N' para obter linhas a partir da linha N em diante.

zcat hugefile.txt.gz | head -n 40000000
zcat hugefile.txt.gz | tail -n [phone] | head -n 40000000
zcat hugefile.txt.gz | tail -n [phone] | head -n 40000000

    

Answer 4

Eu consideraria usar divisão .

split a file into pieces

    

Answer 5

Aqui está um script python para abrir um conjunto globbed de arquivos de um diretório, gunzip-los, se necessário, e lê-los através de linha a linha. Ele usa apenas o espaço necessário na memória para armazenar os nomes dos arquivos e a linha atual, além de um pouco de sobrecarga.

#!/usr/bin/env python
import gzip, bz2
import os
import fnmatch

def gen_find(filepat,top):
    for path, dirlist, filelist in os.walk(top):
        for name in fnmatch.filter(filelist,filepat):
            yield os.path.join(path,name)

def gen_open(filenames):
    for name in filenames:
        if name.endswith(".gz"):
            yield gzip.open(name)
        elif name.endswith(".bz2"):
            yield bz2.BZ2File(name)
        else:
            yield open(name)

def gen_cat(sources):
    for s in sources:
        for item in s:
            yield item

def main(regex, searchDir):
    fileNames = gen_find(regex,searchDir)
    fileHandles = gen_open(fileNames)
    fileLines = gen_cat(fileHandles)
    for line in fileLines:
        print line

if __name__ == '__main__':
    parser = argparse.ArgumentParser(description='Search globbed files line by line', version='%(prog)s 1.0')
    parser.add_argument('regex', type=str, default='*', help='Regular expression')
    parser.add_argument('searchDir', , type=str, default='.', help='list of input files')
    args = parser.parse_args()
    main(args.regex, args.searchDir)

O comando da linha de impressão enviará todas as linhas para std out, para que você possa redirecionar para um arquivo. Alternativamente, se você nos informar o que você quer fazer com as linhas, eu posso adicioná-lo ao script python e você não precisará deixar pedaços do arquivo por aí.

    

Answer 6

Aqui está um programa perl que pode ser usado para ler stdin, e dividir as linhas, canalizando cada clump para um comando separado que pode usar uma variável do shell $ SPLIT para rotea-lo para um destino diferente. Para o seu caso, seria invocado com

zcat hugefile.txt.gz | perl xsplit.pl 40000000 'cat > tmp$SPLIT.txt; do_something tmp$SPLIT.txt; rm tmp$SPLIT.txt'

Desculpe, o processamento da linha de comando é um pouco desajeitado, mas você tem a idéia.

#!/usr/bin/perl -w
#####
# xsplit.pl: like xargs but instead of clumping input into each command's args, clumps it into each command's input.
# Usage: perl xsplit.pl LINES 'COMMAND'
# where: 'COMMAND' can include shell variable expansions and can use $SPLIT, e.g.
#   'cat > tmp$SPLIT.txt'
# or:
#   'gzip > tmp$SPLIT.gz'
#####
use strict;

sub pipeHandler {
    my $sig = shift @_;
    print " Caught SIGPIPE: $sig\n";
    exit(1);
}
$SIG{PIPE} = \&pipeHandler;

my $LINES = shift;
die "LINES must be a positive number\n" if ($LINES <= 0);
my $COMMAND = shift || die "second argument should be COMMAND\n";

my $line_number = 0;

while (<STDIN>) {
    if ($line_number%$LINES == 0) {
        close OUTFILE;
        my $split = $ENV{SPLIT} = sprintf("%05d", $line_number/$LINES+1);
        print "$split\n";
        my $command = $COMMAND;
        open (OUTFILE, "| $command") or die "failed to write to command '$command'\n";
    }
    print OUTFILE $_;
    $line_number++;
}

exit 0;

    

Answer 7

Divida diretamente o arquivo .gz para os arquivos .gz:

zcat bigfile.gz | split -l 400000 --filter='gzip > $FILE.gz'

Eu acho que isso é o que o OP queria, porque ele não tem muito espaço.