Execute o comando em cada linha do arquivo CSV, usando campos em diferentes locais do comando

O GNU parallelpode ler csv diretamente e possui substituição de itens incorporada.

Mais ou menos retirado diretamente de man parallel:

parallel --csv 'my_cmd --arg1 {2} --arg2 {1} --arg3 {3}' :::: file.csv

Adicione -j1antes my_cmdpara que essas invocações sejam executadas uma após a outra. Ou não, e faça com que sejam executadas em paralelo.

(no Debian e Fedora, está no pacote chamado parallel, não em moreutilsou moreutils-parallel)

Obrigado, Ole Tange!

Acho o awk um pouco mais fácil do que mexer no xargs, então costumo montar os argumentos usando o awk e depois passá-los para o xargs:

$ awk -F ',' '{ print "--arg1", $2, "--arg2", $1, "--arg3", $3 }' csv.txt | xargs -L1 echo
--arg1 42 --arg2 foo --arg3 red
--arg1 13 --arg2 bar --arg3 blue
--arg1 27 --arg2 baz --arg3 green

Aqui -L1diz "execute um comando por linha de entrada".

O seguinte primeiro usa Miller ( mlr) para converter a entrada CSV sem cabeçalho para a saída JSONL (linhas de objetos JSON únicos). O jqprocessador JSON então lê esses objetos e emite suas partes como argumentos para um comando. A saída é um código shell que pode ser eval-ed.

$ cat file
foo,42,red
bar,13,blue
baz,27,green
"""mute"" swan","1,23",* * green * *

$ mlr --c2l -N cat file
{"1": "foo", "2": 42, "3": "red"}
{"1": "bar", "2": 13, "3": "blue"}
{"1": "baz", "2": 27, "3": "green"}
{"1": "\"mute\" swan", "2": "1,23", "3": "* * green * *"}

$ mlr --c2l -N cat file | jq -r '["my_cmd", "--arg1", ."1", "--arg2", ."2", "--arg3", ."3"] | @sh'
'my_cmd' '--arg1' 'foo' '--arg2' 42 '--arg3' 'red'
'my_cmd' '--arg1' 'bar' '--arg2' 13 '--arg3' 'blue'
'my_cmd' '--arg1' 'baz' '--arg2' 27 '--arg3' 'green'
'my_cmd' '--arg1' '"mute" swan' '--arg2' '1,23' '--arg3' '* * green * *'

O @shoperador output tenta citar os dados fornecidos de uma forma que seria apropriada para um shell. Não é infalível, mas tende a fazer um bom trabalho na maioria das vezes.

$ eval "$(mlr --c2l -N cat file | jq -r '["my_cmd", "--arg1", ."1", "--arg2", ."2", "--arg3", ."3"] | @sh')"
zsh: command not found: my_cmd
zsh: command not found: my_cmd
zsh: command not found: my_cmd
zsh: command not found: my_cmd

$ my_cmd () { echo ""; printf 'arg: %s\n' "$@"; }
$ eval "$(mlr --c2l -N cat file | jq -r '["my_cmd", "--arg1", ."1", "--arg2", ."2", "--arg3", ."3"] | @sh')"

arg: --arg1
arg: foo
arg: --arg2
arg: 42
arg: --arg3
arg: red

arg: --arg1
arg: bar
arg: --arg2
arg: 13
arg: --arg3
arg: blue

arg: --arg1
arg: baz
arg: --arg2
arg: 27
arg: --arg3
arg: green

arg: --arg1
arg: "mute" swan
arg: --arg2
arg: 1,23
arg: --arg3
arg: * * green * *

Você também pode executar coisas diretamente do Miller, mas não sei o quão bem sua exec()função lida com valores que precisam ser citados no shell (ou se isso é mesmo um problema). Posso voltar mais tarde e revisar isso quando e se eu tiver tempo para testar isso.

Usando Raku (anteriormente conhecido como Perl_6)

...com o módulo Raku Text::CSV:

~$  raku -MText::CSV -e '

    my $fh = open "luator.txt", :r;
    my $parser = Text::CSV.new;

    until $fh.eof {
          $_ = $parser.getline($fh); 
          run "echo", .[0], .[1], .[2] given $_;
    }

    $fh.close;'

Raku é uma linguagem de programação da família Perl que apresenta algumas funções legais para invocar comandos externos. As duas opções são calling shellou calling run. De acordo com a Docs, chamar runé mais seguro.

Acima, quando você declara o $parserobjeto, você pode definir vários parâmetros, como aceitar um separador sem vírgula (exemplo: my $parser = Text::CSV.new(sep => "|");). Então o arquivo é lido/analisado linha a linha com getline(). Uma saída simples é mostrada acima usando echo.

Exemplo de entrada:

~$ cat luator.txt
foo,42,red
bar,13,blue
baz,27,green

Saída de exemplo (com echo):

foo 42 red
bar 13 blue
baz 27 green

Abaixo, usando run "printf", "%s\t", .[0].uc, .[1], .[2].uc given $_; run "printf", "\n";, separando a saída da coluna com \ttabulações. Note que aqui adicionamos .uca maiúsculas a primeira e a terceira colunas, para mostrar que você ainda pode limpar o texto se precisar (antes de invocar seu my_cmd):

Saída de exemplo (com printf):

FOO 42  RED
BAR 13  BLUE
BAZ 27  GREEN

Finalmente, você pode tirar arquivos de entrada da linha de comando usando $*ARGFILESa variável dinâmica do Raku. Obviamente, você substituirá seu my_cmdno lugar de printfabaixo:

~$ raku -MText::CSV -e '
         my $parser = Text::CSV.new;    
         until $*ARGFILES.eof {
               $_ = $parser.getline($*ARGFILES); 
         run "printf", "%s ", "--arg1", .[0], "--arg2", .[1], "--arg3", .[2] given $_;
         run "printf", "\n";
   };'   luator.txt
--arg1 foo --arg2 42 --arg3 red
--arg1 bar --arg2 13 --arg3 blue
--arg1 baz --arg2 27 --arg3 green

Caso contrário, veja o primeiro link abaixo para saber como salvar a saída em um objeto "Proc" (processo) do Raku, ou o segundo link abaixo para usar "Proc::Async" (interface de processo assíncrona).

https://docs.raku.org/type/Proc
https://docs.raku.org/type/Proc/Async
https://raku.org

Separando a seleção/ordenação de campos ( f=...abaixo) da adição --argN(do loop) para que seja fácil modificar campos e/ou ordenar e potencialmente usar o mesmo campo várias vezes, usando any awke um POSIX xargs:

$ awk -F, -v f='2,1,3' '
    {
        n = split(f, flds)
        for (i = 1; i <= n; i++) {
            printf " --arg%d \"%s\"", i, $(flds[i])
        }
        print ""
    }
' file | xargs -L1 echo my_cmd
my_cmd --arg1 42 --arg2 foo --arg3 red
my_cmd --arg1 13 --arg2 bar --arg3 blue
my_cmd --arg1 27 --arg2 baz --arg3 green

Remova echoquando terminar o teste.

Dado que, alterar a ordem e duplicar campos é tão simples quanto alterar f='...':

$ awk -F, -v f='3,1,3,2,1' '
    {
        n = split(f, flds)
        for (i = 1; i <= n; i++) {
            printf " --arg%d \"%s\"", i, $(flds[i])
        }
        print ""
    }
' file | xargs -L1 echo my_cmd
my_cmd --arg1 red --arg2 foo --arg3 red --arg4 42 --arg5 foo
my_cmd --arg1 blue --arg2 bar --arg3 blue --arg4 13 --arg5 bar
my_cmd --arg1 green --arg2 baz --arg3 green --arg4 27 --arg5 baz

Os \"s ao redor %ssão para garantir que xargsos campos que contêm espaços sejam manipulados corretamente, caso contrário, um campo como a bseria dividido em 2 argumentos separados para my_cmd.