Como posso ver o SQL que será gerado por uma determinada consulta ActiveRecord em Ruby on Rails

Gostaria de ver a instrução SQL que uma determinada consulta ActiveRecord irá gerar. Reconheço que posso obter essas informações do log após a consulta ter sido emitida, mas estou me perguntando se há um método que pode ser chamado e ActiveRecord Query.

Por exemplo:

SampleModel.find(:all, :select => "DISTINCT(*)", :conditions => ["`date` > #{self.date}"], :limit => 1, :order => '`date`', :group => "`date`")

Gostaria de abrir o console do irb e adicionar um método no final que mostre o SQL que essa consulta irá gerar, mas não necessariamente executará a consulta.

Da última vez que tentei fazer isso, não havia uma maneira oficial de fazê-lo. Recorri a usar a função que finde seus amigos usam para gerar suas consultas diretamente. É uma API privada, então há um grande risco de que o Rails 3 vá quebrá-la totalmente, mas para depuração, é uma solução ok.

O método é construct_finder_sql(options)( lib/active_record/base.rb:1681) você terá que usar sendporque é privado.

Editar : construct_finder_sql foi removido no Rails 5.1.0.beta1 .

Semelhante ao penger, mas funciona a qualquer momento no console, mesmo depois que as classes foram carregadas e o logger foi armazenado em cache:

Para Rails 2:

ActiveRecord::Base.connection.instance_variable_set :@logger, Logger.new(STDOUT)

Para Rails 3.0.x:

ActiveRecord::Base.logger = Logger.new(STDOUT)

Para Rails> = 3.1.0, isso já é feito por padrão nos consoles. Caso seja muito barulhento e você queira desligá-lo, você pode:

ActiveRecord::Base.logger = nil

Cole em puts query_object.classalgum lugar para ver com que tipo de objeto está trabalhando e, em seguida, consulte os documentos.

Por exemplo, no Rails 3.0, os escopos usam o ActiveRecord::Relationque tem um #to_sqlmétodo. Por exemplo:

class Contact < ActiveRecord::Base
  scope :frequently_contacted, where('messages_count > 10000')
end

Então, em algum lugar você pode fazer:

puts Contact.frequently_contacted.to_sql

Esta pode ser uma pergunta antiga, mas eu uso:

SampleModel.find(:all,
                 :select => "DISTINCT(*)",
                 :conditions => ["`date` > #{self.date}"], 
                 :limit=> 1, 
                 :order => '`date`',
                 :group => "`date`"
                 ).explain

O explainmétodo fornecerá uma instrução SQL bastante detalhada sobre o que irá fazer

apenas use o to_sqlmétodo e ele irá gerar a consulta sql que será executada. funciona em uma relação de registro ativo.

irb(main):033:0> User.limit(10).where(:username => 'banana').to_sql
=> "SELECT  "users".* FROM "users"  WHERE "users"."username" = 'banana'
LIMIT 10"

ao fazer findisso, não funcionará, então você precisará adicionar esse id manualmente à consulta ou executá-lo usando where.

irb(main):037:0* User.where(id: 1).to_sql
=> "SELECT "users".* FROM "users"  WHERE "users"."id" = 1"

Isso é o que eu geralmente faço para obter o SQL gerado no console

-> script/console
Loading development environment (Rails 2.1.2)
>> ActiveRecord::Base.logger = Logger.new STDOUT
>> Event.first

Você tem que fazer isso ao iniciar o console pela primeira vez, se fizer isso depois de digitar algum código, não parece funcionar

Não consigo levar o crédito por isso, encontrei há muito tempo no blog de alguém e não consigo lembrar de quem é.

Crie um arquivo .irbrc em seu diretório inicial e cole-o em:

if ENV.include?('RAILS_ENV') && !Object.const_defined?('RAILS_DEFAULT_LOGGER')
  require 'logger'
  RAILS_DEFAULT_LOGGER = Logger.new(STDOUT)
end

Isso produzirá instruções SQL em sua sessão irb conforme você avança.

EDIT: Desculpe, ainda vou executar a consulta, mas é o mais próximo que eu conheço.

EDIT: Agora com arel, você pode construir escopos / métodos, desde que o objeto retorne ActiveRecord :: Relation e chame .to_sql nele e ele irá colocar o sql que vai ser executado.

Minha maneira típica de ver que sql ele usa é introduzir um "bug" no sql, então você receberá uma mensagem de erro enviada para o logger normal (e a tela da web) que tem o sql em questão. Não há necessidade de descobrir para onde o stdout está indo ...

Experimente o plugin show_sql . O plugin permite que você imprima o SQL sem executá-lo

SampleModel.sql(:select => "DISTINCT(*)", :conditions => ["`date` > #{self.date}"], :limit => 1, :order => '`date`', :group => "`date`")

Você pode alterar o método de registro da conexão para gerar uma exceção, evitando que a consulta seja executada.

É um hack total, mas parece funcionar para mim (Rails 2.2.2, MySQL):

module ActiveRecord
  module ConnectionAdapters
    class AbstractAdapter
      def log_with_raise(sql, name, &block)
        puts sql
        raise 'aborting select' if caller.any? { |l| l =~ /`select'/ }
        log_without_raise(sql, name, &block)
      end
      alias_method_chain :log, :raise
    end
  end
end

No Rails 3, você pode adicionar esta linha ao config / environment / development.rb

config.active_record.logger = Logger.new(STDOUT)

No entanto, ele executará a consulta. Mas metade foi respondida: