Como executar um sql de atualização bruto com vinculação dinâmica em trilhos

Eu quero executar uma atualização de sql bruto como abaixo:

update table set f1=? where f2=? and f3=?

Este SQL será executado por ActiveRecord::Base.connection.execute, mas não sei como passar os valores dos parâmetros dinâmicos para o método.

Alguém poderia me ajudar nisso?

Não parece que a API Rails expõe métodos para fazer isso genericamente. Você pode tentar acessar a conexão subjacente e usar seus métodos, por exemplo, para MySQL:

st = ActiveRecord::Base.connection.raw_connection.prepare("update table set f1=? where f2=? and f3=?")
st.execute(f1, f2, f3)
st.close

Não tenho certeza se existem outras ramificações para fazer isso (conexões deixadas em aberto, etc). Eu rastrearia o código do Rails para uma atualização normal para ver o que ele está fazendo além da consulta real.

Usar consultas preparadas pode economizar um pouco de tempo no banco de dados, mas a menos que você esteja fazendo isso um milhão de vezes seguidas, provavelmente seria melhor apenas construir a atualização com a substituição normal do Ruby, por exemplo

ActiveRecord::Base.connection.execute("update table set f1=#{ActiveRecord::Base.sanitize(f1)}")

ou usando ActiveRecord como os comentaristas disseram.

ActiveRecord::Base.connectiontem um quotemétodo que recebe um valor de string (e, opcionalmente, o objeto de coluna). Então você pode dizer o seguinte:

ActiveRecord::Base.connection.execute(<<-EOQ)
  UPDATE  foo
  SET     bar = #{ActiveRecord::Base.connection.quote(baz)}
EOQ

Observe se você estiver em uma migração Rails ou um objeto ActiveRecord, você pode encurtar para:

connection.execute(<<-EOQ)
  UPDATE  foo
  SET     bar = #{connection.quote(baz)}
EOQ

ATUALIZAÇÃO: como @kolen aponta, você deve usar em seu exec_updatelugar. Isso cuidará da cotação para você e também evitará o vazamento de memória. A assinatura funciona de maneira um pouco diferente:

connection.exec_update(<<-EOQ, "SQL", [[nil, baz]])
  UPDATE  foo
  SET     bar = $1
EOQ

Aqui, o último parâmetro é uma matriz de tuplas que representam os parâmetros de vinculação. Em cada tupla, a primeira entrada é o tipo de coluna e a segunda é o valor. Você pode dar nilpara o tipo de coluna e o Rails geralmente fará a coisa certa.

Existem também exec_query, exec_inserte exec_delete, dependendo do que você precisa.

Você deve apenas usar algo como:

YourModel.update_all(
  ActiveRecord::Base.send(:sanitize_sql_for_assignment, {:value => "'wow'"})
)

Isso resolveria o problema. Usar o método ActiveRecord :: Base # send para invocar sanitize_sql_for_assignment faz com que o Ruby (pelo menos a versão 1.8.7) ignore o fato de que sanitize_sql_for_assignment é na verdade um método protegido.

Às vezes seria melhor usar o nome da classe pai em vez do nome da tabela:

# Refers to the current class
self.class.unscoped.where(self.class.primary_key => id).update_all(created _at: timestamp)

Por exemplo, classe base "Pessoa", subclasses (e tabelas de banco de dados) "Cliente" e "Vendedor" Em vez de usar:

Client.where(self.class.primary_key => id).update_all(created _at: timestamp)
Seller.where(self.class.primary_key => id).update_all(created _at: timestamp)

Você pode usar o objeto da classe base desta forma:

person.class.unscoped.where(self.class.primary_key => id).update_all(created _at: timestamp)

Por que usar SQL bruto para isso?

Se você tiver um modelo para ele, use where:

f1 = 'foo'
f2 = 'bar'
f3 = 'buzz'
YourModel.where('f1 = ? and f2 = ?', f1, f2).each do |ym|
  # or where(f1: f1, f2: f2).each do (...)
  ym.update(f3: f3) 
end

Se você não tiver um modelo para ele (apenas a tabela), você pode criar um arquivo e um modelo que herdará deActiveRecord::Base

class YourTable < ActiveRecord::Base
  self.table_name = 'your_table' # specify explicitly if needed
end

e novamente use whereo mesmo que acima:

Aqui está um truque que descobri recentemente para executar sql bruto com binds:

binds = SomeRecord.bind(a_string_field: value1, a_date_field: value2) +
        SomeOtherRecord.bind(a_numeric_field: value3)
SomeRecord.connection.exec_query <<~SQL, nil, binds
  SELECT *
  FROM some_records
  JOIN some_other_records ON some_other_records.record_id = some_records.id
  WHERE some_records.a_string_field = $1
    AND some_records.a_date_field < $2
    AND some_other_records.a_numeric_field > $3
SQL

onde ApplicationRecorddefine isso:

# Convenient way of building custom sql binds
def self.bind(column_values)
  column_values.map do |column_name, value|
    [column_for_attribute(column_name), value]
  end
end

e isso é semelhante a como o AR vincula suas próprias consultas.

Eu precisei usar sql puro porque falhei em fazer com que o composite_primary_keys funcionasse com o activerecord 2.3.8. Portanto, para acessar a tabela sqlserver 2000 com uma chave primária composta, o sql bruto foi necessário.

sql = "update [db].[dbo].[#{Contacts.table_name}] " +
      "set [COLUMN] = 0 " +
      "where [CLIENT_ID] = '#{contact.CLIENT_ID}' and CONTACT_ID = '#{contact.CONTACT_ID}'"
st = ActiveRecord::Base.connection.raw_connection.prepare(sql)
st.execute

Se uma solução melhor estiver disponível, compartilhe.

No Rails 3.1, você deve usar a interface de consulta:

• novo (atributos)
• criar (atributos)
• criar! (atributos)
• find (id_or_array)
• destruir (id_or_array)
• destroy_all
• delete (id_or_array)
• delete_all
• atualização (ids, atualizações)
• update_all (atualizações)
• existe?

update e update_all são as operações de que você precisa.

Veja os detalhes aqui: http://m.onkey.org/active-record-query-interface