R – ActiveRecord models cached in rake tasks

activerecordrakeruby-on-rails

I know that in rails 2.3.2 ActiveRecord queries are cached, i.e. you may see something in the development/production log:

CACHE (0.0ms)   SELECT * FROM `users` WHERE `users`.`id` = 1

I was wondering if the same principles apply to rake tasks.

I have a rake task that will query a lot of different models, and I want to know if I should implement my own caching, or if this behavior is included by default.

Also, is there a way to see the sql queries that are performed during the rake task? Similar to that of the development/production log

Best Answer

The SQL cache isn't enabled per default for rake tasks. You can wrap your code in a cache block, like this:

task :foobar => :environment do
  ActiveRecord::Base.connection.cache do
    User.find 1 # Will hit the db
    User.find 1 # Will hit the cache
  end
end

This is essentially what Rails does for controller actions. Note that the cache uses memory and rake tasks has a tendency to work with large sets of data, which might give you issues. You can selectively opt-out of caching for parts of your code, using uncached

If you need the task to behave as a method, how about using an actual method?

task :build => [:some_other_tasks] do
  build
end

task :build_all do
  [:debug, :release].each { |t| build t }
end

def build(type = :debug)
  # ...
end

If you'd rather stick to `rake`'s idioms, here are your possibilities, compiled from past answers:

This always executes the task, but it doesn't execute its dependencies:
```
Rake::Task["build"].execute
```
This one executes the dependencies, but it only executes the task if it has not already been invoked:
```
Rake::Task["build"].invoke
```
This first resets the task's already_invoked state, allowing the task to then be executed again, dependencies and all:
```
Rake::Task["build"].reenable
Rake::Task["build"].invoke
```
Note that dependencies already invoked are not automatically re-executed unless they are re-enabled. In Rake >= 10.3.2, you can use the following to re-enable those as well:
```
Rake::Task["build"].all_prerequisite_tasks.each(&:reenable)
```

Ruby – How to pass command line arguments to a rake task

You can specify formal arguments in rake by adding symbol arguments to the task call. For example:

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

Then, from the command line:

> 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"}

As demonstrated in the second example, if you want to use spaces, the quotes around the target name are necessary to keep the shell from splitting up the arguments at the space.

Looking at the code in rake.rb, it appears that rake does not parse task strings to extract arguments for prerequisites, so you can't do task :t1 => "dep[1,2]". The only way to specify different arguments for a prerequisite would be to invoke it explicitly within the dependent task action, as in :invoke_my_task and :invoke_my_task_2.

Note that some shells (like zsh) require you to escape the brackets: rake my_task\['arg1'\]

Best Answer

Related Solutions

Ruby – How to run Rake tasks from within Rake tasks

If you need the task to behave as a method, how about using an actual method?

If you'd rather stick to rake's idioms, here are your possibilities, compiled from past answers:

Ruby – How to pass command line arguments to a rake task

Related Topic

If you'd rather stick to `rake`'s idioms, here are your possibilities, compiled from past answers: