Deleção sed - Erro: Argument list too long

Galera,

Boa noite,

Estou fazendo uma deleção via sed.
sed -i "${var}" Arquivo.TXT

Entretanto, como o arquivo possui mais de 1 milhão de linhas, aparentemente a quantidade de linhas que foram rejeitadas pelo meu script e devem ser deletadas gerou uma lista muito maior que o sed é capaz de deletar em uma única execução, dando a seguinte mensagem de erro:
--> " /usr/bin/sed: Argument list too long"

Sendo assim, gostaria de saber se é possível possível informar para o sed deletar por exemplo de 1.000 em 1.000 linhas, para evitar esse erro.

Por exemplo:
Suponhamos que variável $var tenha o valor:
var = 1d;2d;3d;4d;5d;6d;7d;8d;9d;10d;11d;12d;13d;14d;15d;16d;17d;18d;19d;20;

Consigo fazer esse código sed -i "${var}" Arquivo.TXT - deletar da linha 1 ao 10 na primeira execução e depois da 11 a 20 na segunda e assim sucessivamente?

Desde já mto obrigado galera.

Abç.

Boa noite Alex.
Atente-se ao detalhe.
Se deletar da linha 1 a 10,
Na próxima execução, a numeração das linhas estará alterada.
Exemplo:
1ª execução:
Deletou da 1 a 10,
2ª execução
A 1ª linha é a 11 inicial.....,
a 10ª linha é a linha 20 inicial.....
PS.: é o mesmo problema deste tópico?

https://www.vivaolinux.com.br/topico/Comandos/Delecao-varias-linhas-atraves-de-variavel 

______________________________________________________________________
Importante: echo -e "\n$(lynx --dump goo.gl/a9KeFc|sed -nr '/^[ ]+Se/,/dou.$/p')\n"
Att.: Marcelo Oliver
______________________________________________________________________

Marcelo,

Boa noite e mais uma vez obrigado pela disposição,

O problema atual se originou do tópico que você mencionou e que eu mesmo abri, porém com ajuda de vcs consegui resolver de uma maneira mais simples, porém foi impossível o uso da gawk, vou postar o código que solucionou o meu problema e encerrar o tópico anterior.

Porém fazendo com o delete através do sed -i e com o uso da variável var, que já possui os seus valores definidos, não previ que a variável poderia assumir um grande número de linhas, o que acarretou no erro: sed - Erro: Argument list too long.

Então neste caso, os valores das linhas não vão alterar pq eles já estão definidos na $var, só preciso que ao invés do sed deletar tudo de uma vez, ele delete por exemplo de 1.000 em 1.000 ou 10 em 10..., mas preciso diminuir a volumetria da deleção, por isso que no exemplo coloquei 20 linha aleatórias, com intuito de ver a possibilidade de se deletar de 10 em 10 por exemplo.

Sendo assim.
Se eu atribuir novos valores aleatórios para $var
var=2d;3d;4d;7d;8d;9d;10d;16d;17d;19d;27d;28d;30d;31d;33d;34d;35d;37d;38d;39d;41d;42d;43d;44d;

Eu gostaria de por exemplo deletar essa essas linhas de 10 em 10 ao invés de fazer isso uma única vez.
Então através do sed eu deletaria
1a execução --> 2d;3d;4d;7d;8d;9d;10d;16d;17d;19d;
2a execução --> 27d;28d;30d;31d;33d;34d;35d;37d;38d;39d;
3a execução --> 41d;42d;43d;44d;

Mas gostaria de fazer esse laço usando a estrutura que já tenho que é:
sed -i "${var}" Arquivo.TXT

Não sei se consegui me fazer entender melhor, mas é isso.

Obrigado.

Abç.

Boa noite Alex, deu para entender.
Como citei no post anterior, não da para excluir "por partes", pois,
após a 1ª execução, os números das linhas são alterados.
Sendo assim, a solução e:
#Coloca as linhas que estão fora do padrão no arquivo... Fora_do_Padrao.txt
sed -nr '/^[0-9]{11}-[0-9]{4}/!p' linhas.txt >> Fora_do_Padrao.txt
ou
#Mais Rápido
grep -Ev '^([0-9]{11}-[0-9]{4})' linhas.txt >> Fora_do_Padrao.txt
#Apaga as linhas que não estão no padrão, no arquivo original.
sed -nri '/^[0-9]{11}-[0-9]{4}/p' linhas.txt


______________________________________________________________________
Importante: echo -e "\n$(lynx --dump goo.gl/a9KeFc|sed -nr '/^[ ]+Se/,/dou.$/p')\n"
Att.: Marcelo Oliver
______________________________________________________________________

Por que você está colocando os comandos numa variável? Você poderia colocá-los num arquivo, preferencialmente em múltiplas linhas, e depois mandar o sed executar os comandos desse arquivo.

sed -f /tmp/comandos_de_edição.sed -i Arquivo.TXT 

Tem como, mas, para tanto, seria melhor você fazer isso apagando, em cada bloco, as últimas linhas do arquivo primeiro, e depois as linhas mais próximas do início, porque, como bem lembrado acima pelos colegas, se você apagar primeiro as linhas iniciais, a iteração seguinte vai ter números de linhas diferentes das do arquivo original.


Acima também se mencionou um outro tópico aberto por você e relacionado a este. Lendo-o, e juntando-o a este tópico aqui, eu concordo com o que foi sugerido no outro tópico por outro colega, que sugeriu que você usasse mais os recursos do próprio shell, em vez de chamar ferramentas externas para fazer operações relativamente simples — e, pior ainda, chamando-as repetidamente e sobre os mesmos dados. Invocar ferramentas externas é ineficiente; se você precisa de eficiência, deve procurar aproveitar melhor os recursos de que dispõe, ou buscar ferramentas que ofereçam recursos mais apropriados para lidar com o problema que você tem de tratar.

Não fique acanhado de aprender coisas novas. Além de você não precisar, neste caso, de nada que seja muito difícil, existe documentação abundante para lhe ajudar no processo, bem como espaços como este aqui, com gente disposta a orientá-lo no caminho (e outros como este, em outras partes da Internet, em que talvez as respostas venham ainda mais depressa).

Fiquei com a impressão de que o tópico anterior era uma forma de identificar mudanças que seriam necessárias em um arquivo de dados, e que este seria para implementar tais mudanças. Esse é o tipo de coisa que você consegue fazer numa passada só, muito eficientemente, se usar as ferramentas e os recursos corretos.


(Comecei a brincar aqui com uma solução que acho que vai lhe ajudar bastante, mas preciso sair agora. Se conseguir, posto a referida solução mais tarde.)


... “Principium sapientiae timor Domini, et scientia sanctorum prudentia.” (Proverbia 9:10)

Como eu pretendia, fiz um programa que filtra o arquivo e gera as respectivas saídas numa passada só, o que creio que era o que você gostaria de implementar, juntando o tópico anterior e este.

Como você mencionou o KSH, fiz a primeira versão usando apenas dois comandos externos (ln, para criar o hard link, e mv, para substituir atomicamente o arquivo original com a nova versão), e cada um deles apenas uma vez (i.e. fora de qualquer laço de repetição); todo o resto é feito exclusivamente com recursos internos desse shell.

#!/bin/ksh



ORIG_FILE="/tmp/Arquivo.TXT"

BAD_FORMAT_FILE="/tmp/FormatoInvalido.TXT"



PATH=/bin:/usr/local/bin

export PATH



# Começa criando um back-up do arquivo original, e criando ponteiros para

# os arquivos de entrada e de saída.

backup_file="${ORIG_FILE}-$(date +%Y%m%d%H%M%S)"

new_file="$ORIG_FILE-new-$(date +%s).$$"



ln "$ORIG_FILE" "$backup_file"	# Cria hardlink para arquivo de backup.



exec 3< "$backup_file"			# Arquivo de entrada no FD 3

exec 4> "$new_file"				# Novo arquivo no FD 4

exec 5>> "$BAD_FORMAT_FILE"		# Erros no FD 5 (não sobrescreve, grava no fim)



# Lê as linhas do FD 3 (opção “-u”), interpretando um formato CSV-like (opção

# “-S”), separando os campos num array (opção “-A”).

while read -u 3 line; do

	if

		IFS=, read -A -S fields <<<"$line" &&

		(( ${#fields[@]} == 3 )) &&

		[[ -z "${fields[0]/~(P)^\d{11}-\d{4}$/}" ]]

	then

		print -u 4 -- "$line"

	else

		print -u 5 -- "$line"

	fi

done



exec 5>&-

exec 4>&-

exec 3<&-



mv "$new_file" "$ORIG_FILE" 

Testei esse programa usando um arquivo de dados com 50000 linhas (10000 repetições das linhas de exemplo que você colocou no outro tópico, depois de ajeitar a terceira delas delas para que o formato do CSV fosse válido), e o fiz em duas máquinas diferentes, sendo uma delas com um processador Pentium G2020T de 2.5GHz e a outra um Xeon E-2144G de 3.6GHz, com 30 rodadas em cada uma, a fim de poder ser estatisticamente relevante. Os resultados foram os seguintes.

+--------------+----------------+--------------+

|  Versão em   | Pentium G2020T | Xeon E-2144G |

|     KSH      |     2.5GHz     |    3.6GHz    |

+--------------+----------------+--------------+

| Média        |         9.568s |       4.351s |

| Desv. Padrão |         0.110s |       0.054s |

| Mediana      |         9.530s |       4.348s |

| Mínimo       |         9.406s |       4.252s |

| Máximo       |         9.838s |       4.514s |

+--------------+----------------+--------------+ 

Não sei os tempos que você teve aí, com as soluções suas e de outros colegas, mas eu acho que esses aí em cima são razoáveis para algo feito no shell, que definitivamente não é a melhor ferramenta para isso.

Fiz também uma versão em Perl, com a ajuda do módulo Text::CSV (que talvez tenha de ser instalado por meio de outro pacote — no Ubuntu é o libtext-csv-perl), e ele teve tempos bem melhores: 25 vezes mais rápido no G2020T, e quase 39 vezes mais rápido no Xeon E-2144G.

#!/usr/bin/perl



# +--------------+----------------+--------------+

# |  Versão em   | Pentium G2020T | Xeon E-2144G |

# |     Perl     |     2.5GHz     |    3.6GHz    |

# +--------------+----------------+--------------+

# | Média        |         0.376s |       0.112s |

# | Desv. Padrão |         0.020s |       0.002s |

# | Mediana      |         0.369s |       0.112s |

# | Mínimo       |         0.351s |       0.109s |

# | Máximo       |         0.427s |       0.120s |

# +--------------+----------------+--------------+



use strict;



use POSIX;

use Text::CSV;





my $ORIG_FILE="/tmp/Arquivo.TXT";

my $BAD_FORMAT_FILE="/tmp/FormatoInvalido.TXT";



$ENV{PATH}="/bin:/usr/local/bin";



my ($csv_parser, $csv_output);

if(

	!defined($csv_parser=Text::CSV->new({binary=>1, auto_diag=>1})) ||

	!defined($csv_output=Text::CSV->new({binary=>1, always_quote=>1, eol=>"\r\n"}))

){

	die("Cannot start CSV parser/output: " . Text::CSV->error_diag() . ".\n");

}



# Começa criando um back-up do arquivo original, e criando ponteiros para

# os arquivos de entrada e de saída.my $now=time();

my $now=time();

my $backup_file="$ORIG_FILE-".strftime("%Y%m%d%H%M%S", localtime($now));

my $new_file="$ORIG_FILE-new-$now.$$";



link($ORIG_FILE, $backup_file);	# Cria hardlink para arquivo de backup.



# Abre arquivo de entrada e arquivos de saída.

open(BKP, "<", $backup_file) || die("Cannot open original file: $!.\n");

open(NEW, ">", $new_file) || die("Cannot open new file: $!.\n");

open(BAD, ">>", $BAD_FORMAT_FILE) || die("Cannot open bad format file: $!.\n");



while(my $pfields=$csv_parser->getline(*BKP)){

	if(scalar(@$pfields)==3 && $pfields->[0]=~/^\d{11}-\d{4}$/){

		$csv_output->print(*NEW, $pfields);

	}

	else{

		$csv_output->print(*BAD, $pfields);

	}

}

if(!$csv_parser->eof()){

	# Erro de formato no arquivo de entrada (corrompido?).  Remove o arquivo

	# de back-up e o que seria o novo arquiv com registros bons (o velho

	# continua íntegro, mas o arquivo com dados inválidos pode já ter sido

	# alterado).

	unlink($backup_file, $new_file);

	die("Error while reading CSV file: " . $csv_parser->error_diag() . ".\n");

}

close(BAD);

close(NEW);

close(BKP);

rename($new_file, $ORIG_FILE); 

... “Principium sapientiae timor Domini, et scientia sanctorum prudentia.” (Proverbia 9:10)

Oi Marcelo,

O único problema dessa expressão pra mim é que strings iguais as que vou descrever abaixo não estão sendo deletadas
123456789102-2589
01234569871-12580

Pois perceba que na primeira string o valor antes do traço ultrapassa o valor de 11 posições e passar de 11 também deveria cair como erro, e no segundo caso a mesma coisa, após o traço eu tenho 5 posições e não 4 então deveria também ser removida.

Mas ao que me parece essa expressão --> sed -nri '/^[0-9]{11}[-][0-9]{4}/p' valida um valor mínimo e não exato.

Estou tentando adicionar a essa expressão que se essa string tiver um tamanho maior que 16 então ela também deverá ser removida.

Qualquer ajuda agradeço.