Comment exécuter une mise à jour SQL brute avec une liaison dynamique dans les rails

Je veux exécuter une mise à jour de sql brut comme ci-dessous:

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

Ce SQL sera exécuté par ActiveRecord::Base.connection.execute, mais je ne sais pas comment passer les valeurs des paramètres dynamiques dans la méthode.

Quelqu'un pourrait-il m'aider à ce sujet?

Il ne semble pas que l'API Rails expose des méthodes pour le faire de manière générique. Vous pouvez essayer d'accéder à la connexion sous-jacente et d'utiliser ses méthodes, par exemple pour MySQL:

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

Je ne sais pas s'il y a d'autres ramifications à faire cela (connexions laissées ouvertes, etc.). Je tracerais le code Rails pour une mise à jour normale pour voir ce qu'il fait en dehors de la requête réelle.

L'utilisation de requêtes préparées peut vous faire gagner un peu de temps dans la base de données, mais à moins que vous ne le fassiez un million de fois de suite, vous feriez probablement mieux de simplement créer la mise à jour avec une substitution Ruby normale, par exemple

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

ou en utilisant ActiveRecord comme l'ont dit les commentateurs.

ActiveRecord::Base.connectiona une quoteméthode qui prend une valeur de chaîne (et éventuellement l'objet de colonne). Vous pouvez donc dire ceci:

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

Notez que si vous êtes dans une migration Rails ou un objet ActiveRecord, vous pouvez raccourcir cela en:

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

MISE À JOUR: comme @kolen le souligne, vous devriez utiliser à la exec_updateplace. Cela gérera les citations pour vous et évitera également les fuites de mémoire. La signature fonctionne un peu différemment cependant:

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

Ici, le dernier paramètre est un tableau de tuples représentant les paramètres de liaison. Dans chaque tuple, la première entrée est le type de colonne et la seconde est la valeur. Vous pouvez nilindiquer le type de colonne et Rails fera généralement la bonne chose.

Il existe également exec_query, exec_insertet exec_delete, en fonction de vos besoins.

Vous devriez simplement utiliser quelque chose comme:

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

Cela ferait l'affaire. Utiliser la méthode ActiveRecord :: Base # send pour invoquer sanitize_sql_for_assignment fait que Ruby (au moins la version 1.8.7) ignore le fait que sanitize_sql_for_assignment est en fait une méthode protégée.

Parfois, il serait préférable d'utiliser le nom de la classe parente au lieu du nom de la table:

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

Par exemple, classe de base "Personne", sous-classes (et tables de base de données) "Client" et "Vendeur" à la place en utilisant:

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

Vous pouvez utiliser l'objet de la classe de base de cette manière:

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

Pourquoi utiliser du SQL brut pour cela?

Si vous avez un modèle à utiliser 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

Si vous n'avez pas de modèle pour cela (juste la table), vous pouvez créer un fichier et un modèle qui hériteront deActiveRecord::Base

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

et utilisez à nouveau wherela même chose que ci-dessus:

Voici une astuce que j'ai récemment élaborée pour exécuter SQL brut avec des liaisons:

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

où ApplicationRecorddéfinit ceci:

# 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

et cela est similaire à la façon dont AR lie ses propres requêtes.

J'avais besoin d'utiliser raw sql car je n'avais pas réussi à faire fonctionner composite_primary_keys avec activerecord 2.3.8. Ainsi, pour accéder à la table sqlserver 2000 avec une clé primaire composite, un sql brut était requis.

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

Si une meilleure solution est disponible, veuillez la partager.

Dans Rails 3.1, vous devez utiliser l'interface de requête:

• nouveau (attributs)
• créer (attributs)
• create! (attributs)
• find (id_or_array)
• détruire (id_or_array)
• détruire_tous
• supprimer (id_or_array)
• delete_all
• mise à jour (identifiants, mises à jour)
• update_all (mises à jour)
• existe?

update et update_all sont l'opération dont vous avez besoin.

Voir les détails ici: http://m.onkey.org/active-record-query-interface