Cum se trec argumentele liniei de comandă la o sarcină rake (Programare, Ruby, Linie De Comandă, Rake, Argumente În Linia De Comandă)

Tilendor a intrebat.

Am o sarcină rake care trebuie să insereze o valoare în mai multe baze de date.

Aș dori să trec această valoare în sarcina rake din linia de comandă sau din un alt sarcină rake.

Cum pot să fac acest lucru?

Comentarii

  • rakefile rdoc –  > Por Brian Maltzan.
  • Documente au fost oglindite de SeattleRb. –  > Por Jonathan Allard.
  • Vă rugăm să schimbați răspunsul acceptat cu cel de la @BlairAnderson, deoarece răspunsul acceptat este foarte mult depășit acum. Această întrebare apare sus pe Google pentru acest subiect! –  > Por rmcsharry.
19 răspunsuri
Blair Anderson

Opțiunile și dependențele trebuie să fie în interiorul array-urilor:

namespace :thing do
  desc "it does a thing"
  task :work, [:option, :foo, :bar] do |task, args|
    puts "work", args
  end
  
  task :another, [:option, :foo, :bar] do |task, args|
    puts "another #{args}"
    Rake::Task["thing:work"].invoke(args[:option], args[:foo], args[:bar])
    # or splat the args
    # Rake::Task["thing:work"].invoke(*args)
  end

end

Apoi

rake thing:work[1,2,3]
=> work: {:option=>"1", :foo=>"2", :bar=>"3"}

rake thing:another[1,2,3]
=> another {:option=>"1", :foo=>"2", :bar=>"3"}
=> work: {:option=>"1", :foo=>"2", :bar=>"3"}

NOTĂ: variabila task este obiectul task, nu este foarte util dacă nu cunoașteți/îngrijiți de elementele interne ale Rake.

NOTĂ RAILS:

Dacă se execută sarcina din Rails, cel mai bine este să preîncărcați mediul prin adăugarea de => [:environment] care este o modalitate de a configura dependentă sarcini dependente.

  task :work, [:option, :foo, :bar] => [:environment] do |task, args|
    puts "work", args
  end

Comentarii

    29

  • De asemenea, asigurați-vă că nu folosiți spații între argumente. De exemplu, nu faceți așa: rake thing:work[1, 2, 3] deoarece nu va funcționa și veți primi o eroare Don't know how to build task –  > Por rpbaltazar.
  • De asemenea, asigurați-vă că includeți argumentul în șir de caractere. de exemplu, din linia de comandă rulați sarcina rake astfel rake thing:work'[1,2,3]' –  > Por theterminalguy.
  • 43

  • Din nefericire, zsh nu poate analiza corect apelul, trebuie să tastați comanda pe zsh astfel: rake thing:work[1,2,3], sau așa rake 'thing:work[1,2,3]' –  > Por hutusi.
  • @sakurashinken puteți elimina :environment simbolul din sarcina dvs. aplicațiile rails au o sarcină :environment… –  > Por Blair Anderson.
  • În loc să aveți o notă care să explice că t înseamnă task, de ce să nu folosim pur și simplu task ca nume de parametru? –  > Por Joshua Pinter.
Nick Desjardins

Puteți specifica argumente formale în rake prin adăugarea de argumente simbolice la apelul de sarcină. De exemplu:

require 'rake'

task :my_task, [:arg1, :arg2] do |t, args|
  puts "Args were: #{args} of class #{args.class}"
  puts "arg1 was: '#{args[:arg1]}' of class #{args[:arg1].class}"
  puts "arg2 was: '#{args[:arg2]}' of class #{args[:arg2].class}"
end

task :invoke_my_task do
  Rake.application.invoke_task("my_task[1, 2]")
end

# or if you prefer this syntax...
task :invoke_my_task_2 do
  Rake::Task[:my_task].invoke(3, 4)
end

# a task with prerequisites passes its 
# arguments to it prerequisites
task :with_prerequisite, [:arg1, :arg2] => :my_task #<- name of prerequisite task

# to specify default values, 
# we take advantage of args being a Rake::TaskArguments object
task :with_defaults, :arg1, :arg2 do |t, args|
  args.with_defaults(:arg1 => :default_1, :arg2 => :default_2)
  puts "Args with defaults were: #{args}"
end

Apoi, din linia de comandă:

> rake my_task[1,false]
Args were: {:arg1=>"1", :arg2=>"false"} of class Rake::TaskArguments
arg1 was: '1' of class String
arg2 was: 'false' of class String

> rake "my_task[1, 2]"
Args were: {:arg1=>"1", :arg2=>"2"}

> rake invoke_my_task
Args were: {:arg1=>"1", :arg2=>"2"}

> rake invoke_my_task_2
Args were: {:arg1=>3, :arg2=>4}

> rake with_prerequisite[5,6]
Args were: {:arg1=>"5", :arg2=>"6"}

> rake with_defaults
Args with defaults were: {:arg1=>:default_1, :arg2=>:default_2}

> rake with_defaults['x','y']
Args with defaults were: {:arg1=>"x", :arg2=>"y"}

După cum se demonstrează în al doilea exemplu, dacă doriți să utilizați spații, ghilimelele din jurul numelui țintei sunt necesare pentru a împiedica shell-ul să împartă argumentele la spațiu.

Dacă ne uităm la codul din rake.rb, se pare că rake nu analizează șirurile de sarcini pentru a extrage argumentele pentru condiții prealabile, astfel încât nu puteți face task :t1 => "dep[1,2]". Singura modalitate de a specifica argumente diferite pentru o condiție prealabilă ar fi să o invocați explicit în cadrul acțiunii sarcinii dependente, ca în :invoke_my_task și :invoke_my_task_2.

Rețineți că unele shell-uri (cum ar fi zsh) vă cer să scăpați parantezele: rake my_task['arg1']

Comentarii

  • Pentru a invoca o sarcină în cadrul unui spațiu de nume, este suficient să faceți: Rake::Task[‘namespace:task’].invoke – –  > Por gaqzi.
  • Aceasta este o întrebare separată, Igoru, dar motivul pentru care apelul tău la invoke se execută o singură dată este că rake este orientat pe dependență, deci va executa o sarcină doar dacă este necesară. Pentru sarcinile generice, asta înseamnă dacă nu a fost deja executată. Pentru a executa în mod explicit o sarcină, indiferent de dependențele sale sau dacă este necesară, apelați execute în loc de invoke. –  > Por Nick Desjardins.
  • Notă: Conform rake, această sintaxă de acceptare a variabilelor în sarcini este depășită: WARNING: 'task :t, arg, :needs => [deps]' is deprecated. Please use 'task :t, [args] => [deps]' instead. –  > Por Ajedi32.
  • 59

  • Rețineți că zsh nu reușește să analizeze corect argumentele din linia de comandă (zsh: no matches found: ...), așa că trebuie să scăpați parantezele: rake my_task['arg1']. De la robots.thoughtbot.com/post/18129303042/… –  > Por Seth Bro.
  • @SethBro DA. Dacă comentariul tău nu ar fi fost ascuns în spatele linkului „Vezi mai multe comentarii” nu aș fi pierdut 10 minute fără să pot face să funcționeze acest lucru. –  > Por GMA.
timurb

În plus față de răspunsul lui kch (nu am găsit cum să las un comentariu la asta, scuze):

Nu trebuie să specificați variabilele ca ENV variabile înainte de rake comanda. Puteți să le setați ca parametrii obișnuiți ai liniei de comandă, așa:

rake mytask var=foo

și să le accesați din fișierul rake ca variabile ENV ca atare:

p ENV['var'] # => "foo"

Comentarii

  • Acesta este cel mai simplu răspuns IMO. A funcționat imediat. Ce anume face p înseamnă? –  > Por stevec.
  • @user5783745 La fel ca puts, dar în loc să înregistreze valoarea.to_s la ieșire standard, solicită Obj.inspect și înregistrează acest lucru la ieșire standard. ruby-doc.org/core-2.0.0/Kernel.html#method-i-p –  > Por kqcef.
  • Și să suprascrieți variabilele de mediu? Fantastic! –  > Por Damien Roche.
  • Rake este o mizerie complet supradimensionată și aceasta este singura modalitate care a funcționat. Și nu sunt doar eu, acest răspuns are același număr de voturi ca și răspunsul „corect”. –  > Por lzap.
Tombart

Dacă doriți să treceți argumente numite (de exemplu, cu standardul OptionParser) puteți folosi ceva de genul acesta:

$ rake user:create -- --user [email protected] --pass 123

notați --, care este necesar pentru a ocoli argumentele standard Rake. Ar trebui să funcționeze cu Rake 0.9.x, <= 10.3.x.

Rake mai nou și-a schimbat analiza de --, iar acum trebuie să vă asigurați că nu este trecută la OptionParser#parse de exemplu cu parser.parse!(ARGV[2..-1])

require 'rake'
require 'optparse'
# Rake task for creating an account

namespace :user do |args|
  desc 'Creates user account with given credentials: rake user:create'
  # environment is required to have access to Rails models
  task :create do
    options = {}
    OptionParser.new(args) do |opts|
      opts.banner = "Usage: rake user:create [options]"
      opts.on("-u", "--user {username}","User's email address", String) do |user|
        options[:user] = user
      end
      opts.on("-p", "--pass {password}","User's password", String) do |pass|
        options[:pass] = pass
      end
    end.parse!

    puts "creating user account..."
    u = Hash.new
    u[:email] = options[:user]
    u[:password] = options[:pass]
    # with some DB layer like ActiveRecord:
    # user = User.new(u); user.save!
    puts "user: " + u.to_s
    puts "account created."
    exit 0
  end
end

exit la sfârșit se va asigura că argumentele suplimentare nu vor fi interpretate ca sarcină Rake.

De asemenea, prescurtarea pentru argumente ar trebui să funcționeze:

 rake user:create -- -u [email protected] -p 123

Când scripturile Rake arată astfel, poate că este timpul să căutăm un alt instrument care să permită acest lucru din start.

Comentarii

  • Din punctul meu de vedere, acesta este într-adevăr cel mai bun răspuns. Omiteți problemele legate de variabilele de mediu, sintaxa ciudată cu argumentele sarcinilor, beneficiul suplimentar pentru standardul --option-names. Singura mea sugestie ar fi să folosiți exit în loc de abort ca abort vă va lăsa cu un cod de returnare de 1 către shell. În cazul în care sarcina rake face parte dintr-un script de nivel superior, este mai obișnuit să se presupună că un exit diferit de zero reprezintă un anumit tip de eroare. –  > Por Joe.
  • Sunt de acord cu Joe, acesta este cel mai bun răspuns. Cel mai natural este să folosiți aceeași interfață pentru a transmite opțiuni către rake ca și atunci când transmiteți opțiuni către un script. –  > Por Rik Smith-Unna.
  • Sunt de acord că acesta este cel mai bun răspuns. Nu există o modalitate de a ocoli această metodă urâtă? --? Cum ar fi trecerea rake argumente la sarcina reală sau ceva de genul ăsta? Cum ar fi task :my_task, :*args do |t, args| sau ceva de genul ăsta? –  > Por Augustin Riedinger.
  • În plus, nu înțeleg ce înseamnă {username} este aici. Unde este folosit? De ce nu este acolo în -u {username}? Noroc –  > Por Augustin Riedinger.
  • Modul în care Rake analizează ARGV a fost schimbat în 10.4.1 și inversat în 10.4.2. github.com/ruby/rake/commit/… –  > Por Tombart.
Tilendor

Am găsit răspunsul de pe aceste două site-uri: Net Maniac și Aimred.

Trebuie să aveți versiunea > 0.8 de rake pentru a utiliza această tehnică

Descrierea normală a sarcinii rake este următoarea:

desc 'Task Description'
task :task_name => [:depends_on_taskA, :depends_on_taskB] do
  #interesting things
end

Pentru a trece argumente, faceți trei lucruri:

  1. Adăugați numele argumentelor după numele sarcinii, separate prin virgule.
  2. Puneți dependențele la sfârșit folosind :needs => […]
  3. Așezați |t, args| după do. (t este obiectul pentru această sarcină)

Pentru a accesa argumentele din script, folosiți args.arg_name

desc 'Takes arguments task'
task :task_name, :display_value, :display_times, :needs => [:depends_on_taskA, :depends_on_taskB] do |t, args|
  args.display_times.to_i.times do
    puts args.display_value
  end
end

Pentru a apela această sarcină din linia de comandă, treceți-i argumentele din []s

rake task_name['Hello',4]

se va afișa

Hello
Hello
Hello
Hello

iar dacă doriți să apelați această sarcină dintr-o altă sarcină și să-i transmiteți argumente, utilizați invoke

task :caller do
  puts 'In Caller'
  Rake::Task[:task_name].invoke('hi',2)
end

apoi comanda

rake caller

va ieși

In Caller
hi
hi

Nu am găsit o modalitate de a trece argumente ca parte a unei dependențe, așa cum se rupe următorul cod:

task :caller => :task_name['hi',2]' do
   puts 'In Caller'
end

Comentarii

    15

  • Formatul pentru această funcționalitate s-a schimbat, după cum precizează acest avertisment: 'task :t, arg, :needs => [deps]' is deprecated. Please use 'task :t, [args] => [deps]' instead. –  > Por madh.
kch

O altă opțiune utilizată în mod obișnuit este trecerea variabilelor de mediu. În codul dvs. le citiți prin ENV['VAR']și le puteți trece chiar înainte de rake de exemplu

$ VAR=foo rake mytask

Comentarii

  • Sincer, speram ca rake task — these –go –to -a program și task-ul meu să le poată obține de la ARGV. Din păcate, nu sunt sigur că acest lucru este posibil, totuși, în prezent folosesc soluția ta: rake var1=val1 var2=val2 –  > Por JasonSmith.
  • @jhs: rake blah -- --these --go --to --a-program (rețineți că -- pentru a-i spune lui rake că întreruperile sale s-au încheiat), vezi stackoverflow.com/questions/5086224/… – –  > Por mu este prea scurt.
fl00r

De fapt, @Nick Desjardins a răspuns perfect. Dar doar pentru educație: puteți folosi abordarea murdară: folosind ENV argument

task :my_task do
  myvar = ENV['myvar']
  puts "myvar: #{myvar}"
end 

rake my_task myvar=10
#=> myvar: 10

Nate Flink

Nu mi-am putut da seama cum să trec args și, de asemenea, :environment până când am rezolvat acest lucru:

namespace :db do
  desc 'Export product data'
  task :export, [:file_token, :file_path] => :environment do |t, args|
    args.with_defaults(:file_token => "products", :file_path => "./lib/data/")

       #do stuff [...]

  end
end

Și apoi am apelat așa:

rake db:export['foo, /tmp/']

Comentarii

  • Mulțumesc pentru asta, o soluție excelentă, menținând în același timp :environment –  > Por Olivier JM.
Feng
desc 'an updated version'
task :task_name, [:arg1, :arg2] => [:dependency1, :dependency2] do |t, args|
    puts args[:arg1]
end

Comentarii

  • Pentru a apela acest lucru, mergeți: rake task_name[hello, world] –  > Por Dex.
  • de la rake.rubyforge.org/files/doc/rakefile_rdoc.html „Doar câteva cuvinte de precauție. Numele sarcinii rake și argumentele sale trebuie să fie un singur argument de linie de comandă pentru rake. Acest lucru înseamnă, în general, fără spații. Dacă sunt necesare spații, atunci întregul șir rake + argument trebuie să fie citat. Ceva de genul acesta: rake „nume[billy bob, smith]” ” –  > Por Gayle.
jassa

Am vrut doar să pot rula:

$ rake some:task arg1 arg2

Simplu, nu? (Nu!)

Rake interpretează arg1 și arg2 ca fiind sarcini și încearcă să le execute. Așa că trebuie doar să renunțăm înainte de a o face.

namespace :some do
  task task: :environment do
    arg1, arg2 = ARGV

    # your task...

    exit
  end
end

Luați asta, paranteze!

Disclaimer: Am vrut să pot face acest lucru într-un proiect de companie destul de mic. Nu este destinat utilizării în „lumea reală”, deoarece pierdeți capacitatea de a înlănțui sarcinile rake (de ex. rake task1 task2 task3). IMO nu merită. Folosiți pur și simplu urâtul rake task[arg1,arg2].

Comentarii

  • Necesar pentru a face acest lucru _, arg1, arg2 = ARGV deoarece primul arg a fost văzut ca fiind numele sarcinii rake. Dar asta exit este un truc frumos. –  > Por fatty.
  • rake task[arg1,arg2] && rake task2 && rake task3 Nu sunt sigur dacă e mai puțin urât decât rake task[arg1,arg2] task2 task3. Probabil că e mai puțin eficient totuși. –  > Por Nuclearman.
  • _, *args = ARGV este perfect pentru a capta toate argumentele ulterioare! Mulțumesc mult! –  > Por XtraSimplicity.
djburdick

Folosesc un argument obișnuit pentru ruby în fișierul rake:

DB = ARGV[1]

apoi am stub out sarcinile rake în partea de jos a fișierului (deoarece rake va căuta o sarcină bazată pe acest nume de argument).

task :database_name1
task :database_name2

linia de comandă:

rake mytask db_name

acest lucru mi se pare mai curat decât soluțiile var=foo ENV var și task args[blah, blah2].
stub-ul este un pic cam jenky, dar nu este prea rău dacă aveți doar câteva medii care sunt configurate o singură dată

Comentarii

  • Pentru a preveni problemele legate de șirurile înghețate, utilizați dup la sfârșit: db = ARGV[1].dup –  > Por Juanda.
  • Eveniment mai bun db = ARGV[1].dup unless ARGV[1].nil? pentru a preveni excepțiile de duplicare a unui nil. –  > Por Andre Figueiredo.
Asim Mushtaq

Modalitățile de transmitere a argumentului sunt corecte în răspunsul de mai sus. Cu toate acestea, pentru a rula o sarcină rake cu argumente, există o mică problemă tehnică implicată în versiunea mai nouă de rail

Va funcționa cu rake „namespace:taskname[‘argument1’]”

Observați ghilimelele inversate în rularea sarcinii din linia de comandă.

Gal

Pentru a transmite argumente la sarcina implicită, puteți face ceva de genul următor. De exemplu, să spunem că „versiune” este argumentul dumneavoastră:

task :default, [:version] => [:build]

task :build, :version do |t,args|
  version = args[:version]
  puts version ? "version is #{version}" : "no version passed"
end

Apoi, puteți să o apelați astfel:

$ rake
no version passed

sau

$ rake default[3.2.1]
version is 3.2.1

sau

$ rake build[3.2.1]
version is 3.2.1

Cu toate acestea, nu am găsit o modalitate de a evita specificarea numelui task-ului (implicit sau build) în timp ce se transmit argumente. Mi-ar plăcea să aflu dacă cineva cunoaște o modalitate.

Abdo

Îmi place sintaxa „querystring” pentru transmiterea de argumente, în special atunci când există multe argumente care trebuie transmise.

Exemplu:

rake "mytask[width=10&height=20]"

„Querystring” fiind:

width=10&height=20

Avertizare: rețineți că sintaxa este rake "mytask[foo=bar]" și NU rake mytask["foo=bar"]

Atunci când este analizat în cadrul sarcinii rake folosind Rack::Utils.parse_nested_query , obținem un Hash:

=> {"width"=>"10", "height"=>"20"}

(Lucrul interesant este că puteți trece hashes și array-uri, mai multe detalii mai jos)

Iată cum se obține acest lucru:

require 'rack/utils'

task :mytask, :args_expr do |t,args|
  args.with_defaults(:args_expr => "width=10&height=10")
  options = Rack::Utils.parse_nested_query(args[:args_expr])
end

Iată un exemplu mai extins pe care îl folosesc cu Rails în aplicația mea delayed_job_active_record_threaded gem:

bundle exec rake "dj:start[ebooks[workers_number]=16&ebooks[worker_timeout]=60&albums[workers_number]=32&albums[worker_timeout]=120]"

Parsat în același mod ca mai sus, cu o dependență de mediu (pentru a încărca mediul Rails)

namespace :dj do
  task :start, [ :args_expr ] => :environment do |t, args|
    # defaults here...
    options = Rack::Utils.parse_nested_query(args[:args_expr])  
  end
end

Dă următorul rezultat în options

=> {"ebooks"=>{"workers_number"=>"16", "worker_timeout"=>"60"}, "albums"=>{"workers_number"=>"32", "worker_timeout"=>"120"}}

hexinpeter

Majoritatea metodelor descrise mai sus nu au funcționat pentru mine, poate că sunt depreciate în versiunile mai noi. ghidul actualizat poate fi găsit aici: http://guides.rubyonrails.org/command_line.html#custom-rake-tasks

un ans copy-and-paste ans din ghid este aici:

task :task_name, [:arg_1] => [:pre_1, :pre_2] do |t, args|
  # You can use args from here
end

Invocă-l astfel

bin/rake "task_name[value 1]" # entire argument string should be quoted

xander-miller

Dacă nu vă puteți deranja să vă amintiți ce poziție de argument este pentru ce și vreți să faceți ceva de genul unui hash de argumente ruby. Puteți folosi un argument pentru a trece un șir de caractere și apoi regexarea acelui șir într-un hash de opțiuni.

namespace :dummy_data do
  desc "Tests options hash like arguments"
  task :test, [:options] => :environment do |t, args|
    arg_options = args[:options] || '' # nil catch incase no options are provided
    two_d_array = arg_options.scan(/W*(w*): (w*)W*/)
    puts two_d_array.to_s + ' # options are regexed into a 2d array'
    string_key_hash = two_d_array.to_h
    puts string_key_hash.to_s + ' # options are in a hash with keys as strings'
    options = two_d_array.map {|p| [p[0].to_sym, p[1]]}.to_h
    puts options.to_s + ' # options are in a hash with symbols'
    default_options = {users: '50', friends: '25', colour: 'red', name: 'tom'}
    options = default_options.merge(options)
    puts options.to_s + ' # default option values are merged into options'
  end
end

Iar pe linia de comandă veți obține.

$ rake dummy_data:test["users: 100 friends: 50 colour: red"]
[["users", "100"], ["friends", "50"], ["colour", "red"]] # options are regexed into a 2d array
{"users"=>"100", "friends"=>"50", "colour"=>"red"} # options are in a hash with keys as strings
{:users=>"100", :friends=>"50", :colour=>"red"} # options are in a hash with symbols
{:users=>"100", :friends=>"50", :colour=>"red", :name=>"tom"} # default option values are merged into options

Comentarii

  • Codul tău are nevoie de câteva linii goale bine plasate. Nu știu cum ai citit acest zid de text. –  > Por Joshua Pinter.
Daniel Garmoshka

Pentru a rula sarcini rake cu stilul tradițional de argumente:

rake task arg1 arg2

Și apoi folosiți:

task :task do |_, args|
  puts "This is argument 1: #{args.first}"
end

Adăugați următorul patch de rake gem:

Rake::Application.class_eval do

  alias origin_top_level top_level

  def top_level
    @top_level_tasks = [top_level_tasks.join(' ')]
    origin_top_level
  end

  def parse_task_string(string) # :nodoc:
    parts = string.split ' '
    return parts.shift, parts
  end

end

Rake::Task.class_eval do

  def invoke(*args)
    invoke_with_call_chain(args, Rake::InvocationChain::EMPTY)
  end

end

lobati

Un lucru pe care nu-l văd aici este cum să se gestioneze argumentele arbitrare. Dacă treceți argumente care nu sunt listate în definiția sarcinii, acestea sunt în continuare accesibile sub args.extras:

task :thing, [:foo] do |task, args|
  puts args[:foo]     # named argument
  puts args.extras    # any additional arguments that were passed
end

tundervirld

În timp ce treceți parametrii, este o opțiune mai bună este un fișier de intrare, poate fi acesta un excel un json sau orice aveți nevoie și de acolo citiți structura de date și variabilele de care aveți nevoie din acel fișier, inclusiv numele variabilei, după cum este necesar.Pentru a citi un fișier poate avea următoarea structură.

  namespace :name_sapace_task do
    desc "Description task...."
      task :name_task  => :environment do
        data =  ActiveSupport::JSON.decode(File.read(Rails.root+"public/file.json")) if defined?(data)
    # and work whit yoour data, example is data["user_id"]

    end
  end

Exemplu json

{
  "name_task": "I'm a task",
  "user_id": 389,
  "users_assigned": [389,672,524],
  "task_id": 3
}

Execuție

rake :name_task 

Comentarii

  • Dacă aveți nevoie de un fișier de instrucțiuni JSON pentru sarcina Rake, probabil că faceți prea multe lucruri în sarcina Rake. –  > Por ZiggyTheHamster.
  • Acesta este mod prea complicat ceva care este incredibil de simplu. –  > Por jeffdill2.
  • Foloseam o sarcină rake pentru a face multe lucruri complexe ca o sarcină. Unul dintre ele era să fie intrarea într-un proces ETL și puteai avea nevoie de multe câmpuri de intrare pentru a face acest lucru. foloseam o sarcină rake pentru a face multe lucruri complexe ca o sarcină. Unul dintre ele era să fie intrarea într-un proces ETL și puteai avea nevoie de multe câmpuri de intrare pentru a face acest lucru. Dacă vă gândiți că o sarcină Rake este doar pentru cel mai simplu lucru, poate că nu o utilizați în alte contexte complexe. Vă mulțumim pentru comentarii. –  > Por tundervirld.