Divide arquivos grandes em partes sem dividir a entrada

Question

Eu tenho um arquivo .msg bastante grande formatado no formato UIEE.

$ wc -l big_db.msg
8726593 big_db.msg

Essencialmente, o arquivo é composto de entradas de vários tamanhos que se parecem com isso:

UR|1
AA|Condon, Richard
TI|Prizzi's Family
CN|Collectable- Good/Good
MT|FICTION
PU|G.P. Putnam & Sons
DP|1986
ED|First Printing.
BD|Hard Cover
NT|0399132104
KE|MAFIA
KE|FICTION
PR|44.9
XA|4
XB|1
XC|BO
XD|S

UR|10
AA|Gariepy, Henry
TI|Portraits of Perseverance
CN|Good/No Jacket
MT|SOLD
PU|Victor Books
DP|1989
BD|Mass Market Paperback
NT|1989 tpb g 100 meditations from the Book of Job "This book...help you
NT| persevere through the struggles of your life..."
KE|Bible
KE|religion
KE|Job
KE|meditations
PR|28.4
XA|4
XB|5
XC|BO
XD|S

Este é um exemplo de duas entradas, separadas por uma linha em branco. Desejo dividir este grande arquivo em arquivos menores sem dividir uma entrada em dois arquivos.

Cada entrada individual é separada por uma nova linha (uma linha completamente em branco) no arquivo. Desejo quebrar esse arquivo de linha de 8,7 milhões em 15 arquivos. Eu entendo que existem ferramentas como split , mas não tenho certeza de como dividir o arquivo, mas apenas dividi-lo em uma nova linha para que uma única entrada não seja dividida em vários arquivos.

    

Answer 1

Veja uma solução que pode funcionar:

seq 1 $(((lines=$(wc -l </tmp/file))/16+1)) $lines |
sed 'N;s|\(.*\)\(\n\)\(.*\)|d;,w /tmp/uptoline|;P;$d;D' |
sed -ne :nl -ne '/\n$/!{N;bnl}' -nf - /tmp/file

Funciona permitindo que o primeiro sed escreva o segundo script sed . O segundo sed primeiro reúne todas as linhas de entrada até encontrar uma linha em branco. Em seguida, grava todas as linhas de saída em um arquivo. O primeiro sed escreve um script para o segundo, instruindo-o sobre onde escrever sua saída. No meu caso de teste, esse script ficou assim:

1d;1,377w /tmp/uptoline377
377d;377,753w /tmp/uptoline753
753d;753,1129w /tmp/uptoline1129
1129d;1129,1505w /tmp/uptoline1505
1505d;1505,1881w /tmp/uptoline1881
1881d;1881,2257w /tmp/uptoline2257
2257d;2257,2633w /tmp/uptoline2633
2633d;2633,3009w /tmp/uptoline3009
3009d;3009,3385w /tmp/uptoline3385
3385d;3385,3761w /tmp/uptoline3761
3761d;3761,4137w /tmp/uptoline4137
4137d;4137,4513w /tmp/uptoline4513
4513d;4513,4889w /tmp/uptoline4889
4889d;4889,5265w /tmp/uptoline5265
5265d;5265,5641w /tmp/uptoline5641

Eu testei assim:

printf '%s\nand\nmore\nlines\nhere\n\n' $(seq 1000) >/tmp/file

Isso me forneceu um arquivo de 6000 linhas, que se parecia com isso:

<iteration#>
and
more
lines
here
#blank

... repetido 1000 vezes.

Depois de executar o script acima:

set -- /tmp/uptoline*
echo $# total splitfiles
for splitfile do
    echo $splitfile
    wc -l <$splitfile
    tail -n6 $splitfile
done    

OUTPUT

15 total splitfiles
/tmp/uptoline1129
378
188
and
more
lines
here

/tmp/uptoline1505
372
250
and
more
lines
here

/tmp/uptoline1881
378
313
and
more
lines
here

/tmp/uptoline2257
378
376
and
more
lines
here

/tmp/uptoline2633
372
438
and
more
lines
here

/tmp/uptoline3009
378
501
and
more
lines
here

/tmp/uptoline3385
378
564
and
more
lines
here

/tmp/uptoline3761
372
626
and
more
lines
here

/tmp/uptoline377
372
62
and
more
lines
here

/tmp/uptoline4137
378
689
and
more
lines
here

/tmp/uptoline4513
378
752
and
more
lines
here

/tmp/uptoline4889
372
814
and
more
lines
here

/tmp/uptoline5265
378
877
and
more
lines
here

/tmp/uptoline5641
378
940
and
more
lines
here

/tmp/uptoline753
378
125
and
more
lines
here

    

Answer 2

Usando a sugestão de csplit :

Divisão com base nos números de linha

$ csplit file.txt <num lines> "{repetitions}"

Exemplo

Digamos que eu tenha um arquivo com 1000 linhas.

$ seq 1000 > file.txt

$ csplit file.txt 100 "{8}"
288
400
400
400
400
400
400
400
400
405

resulta em arquivos assim:

$ wc -l xx*
  99 xx00
 100 xx01
 100 xx02
 100 xx03
 100 xx04
 100 xx05
 100 xx06
 100 xx07
 100 xx08
 101 xx09
   1 xx10
1001 total

Você pode contornar a limitação estática de precisar especificar o número de repetições calculando previamente os números com base no número de linhas em seu arquivo específico com antecedência.

$ lines=100
$ echo $lines 
100

$ rep=$(( ($(wc -l file.txt | cut -d" " -f1) / $lines) -2 ))
$ echo $rep
8

$ csplit file.txt 100 "{$rep}"
288
400
400
400
400
400
400
400
400
405

Divisão baseada em linhas em branco

Se, por outro lado, você quiser simplesmente dividir um arquivo em linhas em branco contidas no arquivo, poderá usar essa versão de split :

$ csplit file2.txt '/^$/' "{*}"

Exemplo

Digamos que adicionei 4 linhas em branco ao file.txt acima e crie o arquivo file2.txt . Você pode ver que eles foram adicionados manualmente assim:

$ grep -A1 -B1 "^$" file2.txt
20

21
--
72

73
--
112

113
--
178

179

O acima mostra que eu os adicionei entre os números correspondentes dentro do meu arquivo de amostra. Agora, quando eu executo o comando csplit :

$ csplit file2.txt '/^$/' "{*}"
51
157
134
265
3290

Você pode ver que agora eu tenho 4 arquivos que foram divididos com base na linha em branco:

$ grep -A1 -B1 '^$' xx0*
xx01:
xx01-21
--
xx02:
xx02-73
--
xx03:
xx03-113
--
xx04:
xx04-179

Referências

• Unix Powertools - 35.10 Divisão de arquivos por contexto: csplit
• csplit: divida um arquivo com base em padrões
• Como dividir o arquivo na primeira linha vazia de forma portável no shell (por exemplo, usando sed)?

Answer 3

Se você não se importa com os pedidos dos registros, pode fazer:

gawk -vRS= '{printf "%s", $0 RT > "file.out." (NR-1)%15}' file.in

Caso contrário, você precisa primeiro obter o número de registros primeiro para saber quantos colocar em cada arquivo de saída:

gawk -vRS= -v "n=$(gawk -vRS= 'END {print NR}' file.in)" '
  {printf "%s", $0 RT > "file.out." int((NR-1)*15/n)}' file.in

    

Answer 4

Se você estiver procurando dividir apenas no final de uma linha, poderá fazê-lo com a opção -l para split .

Se você está procurando dividir em uma linha em branco ( \n\n ), aqui está como eu faria em ksh. Eu não testei, e provavelmente não é ideal, mas algo ao longo desta linha funcionaria:

filenum=0
counter=0
limit=580000

while read LINE
do
  counter=counter+1

  if (( counter >= limit ))
  then
    if [[ $LINE == "" ]]
    then
      filenum=filenum+1
      counter=0
    fi
  fi

  echo $LINE >>big_db$filenum.msg
done <big_db.msg

    

Answer 5

Experimente awk

awk 'BEGIN{RS="\n\n"}{print $0 > FILENAME"."FNR}' big_db.msg

    

Answer 6

Se você não se importa com a ordem dos registros, mas é particular a respeito de obter um determinado número de arquivos de saída, A resposta de Stephane é a maneira que eu iria. Mas tenho a sensação de que você poderia se importar mais com a especificação de um tamanho que cada arquivo de saída não deveria exceder. Isso realmente facilita, porque você pode ler seu arquivo de entrada e coletar registros até atingir esse tamanho e, em seguida, iniciar um novo arquivo de saída. Se isso funcionar para você, a maioria das linguagens de programação pode manipular sua tarefa com um script curto. Aqui está uma implementação do awk:

BEGIN {
    RS = "\n\n"
    ORS = "\n\n"
    maxlen = (maxlen == 0 ? 500000 : maxlen)
    oi = 1
}

{
    reclen = length($0) + 2
    if (n + reclen > maxlen) {
        oi++
        n = 0
    }
    n += reclen
    print $0 > FILENAME"."oi
}

Coloque isso em um arquivo, diga program.awk , e execute-o com awk -v maxlen=10000 -f program.awk big_db.msg , onde o valor de maxlen é o maior número de bytes que você deseja em qualquer arquivo. Ele usará 500k como padrão.

Se você deseja obter um número definido de arquivos, provavelmente a maneira mais fácil é simplesmente dividir o tamanho do arquivo de entrada pelo número de arquivos que deseja e, em seguida, adicionar um pouco a esse número para obter maxlen . Por exemplo, para obter 15 arquivos de seus 8726593 bytes, divida por 15 para obter 581773 e adicione alguns, então talvez dê maxlen=590000 ou maxlen=600000 . Se você quiser fazer isso repetidamente, seria possível configurar o programa para fazê-lo.