Come eseguire un aggiornamento raw sql con binding dinamico in rails

Voglio eseguire un aggiornamento raw sql come di seguito:

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

Questo SQL verrà eseguito da ActiveRecord::Base.connection.execute, ma non so come passare i valori dei parametri dinamici nel metodo.

Qualcuno potrebbe darmi un aiuto su questo?

Non sembra che l'API di Rails esponga i metodi per farlo in modo generico. Potresti provare ad accedere alla connessione sottostante e utilizzare i suoi metodi, ad esempio per MySQL:

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

Non sono sicuro che ci siano altre conseguenze nel farlo (connessioni lasciate aperte, ecc.). Traccerei il codice Rails per un normale aggiornamento per vedere cosa sta facendo a parte la query effettiva.

L'uso di query preparate può farti risparmiare una piccola quantità di tempo nel database, ma a meno che tu non lo stia facendo un milione di volte di seguito, probabilmente faresti meglio a creare l'aggiornamento con la normale sostituzione di Ruby, ad es.

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

o utilizzando ActiveRecord come hanno detto i commentatori.

ActiveRecord::Base.connectionha un quotemetodo che accetta un valore stringa (e facoltativamente l'oggetto colonna). Quindi puoi dire questo:

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

Nota se sei in una migrazione di Rails o in un oggetto ActiveRecord puoi abbreviarlo a:

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

AGGIORNAMENTO: come sottolinea @kolen, dovresti usare exec_updateinvece. Questo gestirà la citazione per te ed eviterà anche perdite di memoria. La firma funziona in modo leggermente diverso però:

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

Qui l'ultimo parametro è un array di tuple che rappresentano i parametri di bind. In ogni tupla, la prima voce è il tipo di colonna e la seconda è il valore. Puoi dare nilper il tipo di colonna e Rails di solito farà la cosa giusta.

Ci sono anche exec_query, exec_inserte exec_delete, a seconda di ciò di cui hai bisogno.

Dovresti semplicemente usare qualcosa come:

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

Quello farebbe il trucco. L'uso del metodo ActiveRecord :: Base # send per invocare sanitize_sql_for_assignment fa sì che Ruby (almeno la versione 1.8.7) salti il ​​fatto che sanitize_sql_for_assignment è effettivamente un metodo protetto.

A volte sarebbe meglio usare il nome della classe genitore invece del nome della tabella:

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

Ad esempio, classe base "Persona", sottoclassi (e tabelle database) "Cliente" e "Venditore" invece utilizzando:

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

Puoi usare l'oggetto della classe base in questo modo:

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

Perché usare SQL grezzo per questo?

Se hai un modello per esso usa 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 non hai un modello per esso (solo la tabella), puoi creare un file e un modello che erediteranno daActiveRecord::Base

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

e di nuovo usa wherelo stesso come sopra:

Ecco un trucco che ho recentemente elaborato per eseguire sql raw con bind:

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

dove lo ApplicationRecorddefinisce:

# 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 questo è simile a come AR lega le proprie query.

Avevo bisogno di usare sql grezzo perché non sono riuscito a far funzionare composite_primary_keys con activerecord 2.3.8. Quindi, per accedere alla tabella sqlserver 2000 con una chiave primaria composita, era richiesto sql non elaborato.

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 è disponibile una soluzione migliore, condividila.

In Rails 3.1, dovresti usare l'interfaccia di query:

• nuovo (attributi)
• create (attributi)
• create! (attributi)
• trova (id_or_array)
• distruggi (id_or_array)
• distruggere_all
• elimina (id_or_array)
• cancella tutto
• aggiornamento (ID, aggiornamenti)
• update_all (aggiornamenti)
• esiste?

update e update_all sono le operazioni di cui hai bisogno.

Vedi i dettagli qui: http://m.onkey.org/active-record-query-interface