¿Cómo puedo ver el SQL que generará una consulta de ActiveRecord determinada en Ruby on Rails?

Me gustaría ver la declaración SQL que generará una consulta ActiveRecord determinada. Reconozco que puedo obtener esta información del registro después de que se haya emitido la consulta, pero me pregunto si hay un método al que se pueda llamar y ActiveRecord Query.

Por ejemplo:

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

Me gustaría abrir la consola irb y agregar un método al final que mostraría el SQL que generará esta consulta, pero no necesariamente ejecutará la consulta.

La última vez que intenté hacer esto, no había una forma oficial de hacerlo. Recurrí a usar la función que findusan y sus amigos para generar sus consultas directamente. Es una API privada, por lo que existe un gran riesgo de que Rails 3 la rompa por completo, pero para la depuración, es una buena solución.

El método es construct_finder_sql(options)( lib/active_record/base.rb:1681) que tendrá que usar sendporque es privado.

Editar : construct_finder_sql se eliminó en Rails 5.1.0.beta1 .

Similar a Penger, pero funciona en cualquier momento en la consola, incluso después de que se hayan cargado las clases y el registrador se haya almacenado en caché:

Para rieles 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 esto ya se hace de forma predeterminada en las consolas. En caso de que sea demasiado ruidoso y desee apagarlo , puede hacer:

ActiveRecord::Base.logger = nil

Pegue un puts query_object.classlugar para ver con qué tipo de objeto está trabajando, luego busque los documentos.

Por ejemplo, en Rails 3.0, los alcances usan ActiveRecord::Relationque tiene un #to_sqlmétodo. Por ejemplo:

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

Entonces, en algún lugar puedes hacer:

puts Contact.frequently_contacted.to_sql

Esta puede ser una pregunta antigua, pero yo uso:

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

El explainmétodo dará una declaración SQL bastante detallada sobre lo que va a hacer

solo use el to_sqlmétodo y generará la consulta SQL que se ejecutará. funciona en una relación de registro activa.

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

al hacerlo find, no funcionará, por lo que deberá agregar esa identificación manualmente a la consulta o ejecutarla usando where.

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

Esto es lo que suelo hacer para generar SQL en la consola

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

Tienes que hacer esto cuando inicias la consola por primera vez, si lo haces después de haber escrito algún código, no parece funcionar

Realmente no puedo tomar el crédito por esto, lo encontré hace mucho tiempo en el blog de alguien y no puedo recordar de quién es.

Cree un archivo .irbrc en su directorio de inicio y péguelo en:

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

Eso generará declaraciones SQL en su sesión de irb a medida que avanza.

EDITAR: Lo siento, todavía ejecutará la consulta, pero es lo más cercano que conozco.

EDITAR: Ahora con arel, puede construir alcances / métodos siempre que el objeto devuelva ActiveRecord :: Relation y llame a .to_sql en él y saldrá el sql que se va a ejecutar.

Mi forma típica de ver qué sql usa es introducir un "error" en el sql, luego aparecerá un mensaje de error en el registrador normal (y la pantalla web) que tiene el sql en cuestión. No es necesario encontrar a dónde va stdout ...

Prueba el complemento show_sql . El complemento le permite imprimir el SQL sin ejecutarlo

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

Puede cambiar el método de registro de la conexión para generar una excepción, evitando que se ejecute la consulta.

Es un truco total, pero parece funcionar para mí (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

En Rails 3 puedes agregar esta línea a config / environment / development.rb

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

Sin embargo, ejecutará la consulta. Pero la mitad fue respondida: