Jak wykonać surową aktualizację sql z dynamicznym wiązaniem w railsach

Chcę wykonać jedną aktualizację surowego sql, jak poniżej:

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

Ten kod SQL zostanie wykonany przez ActiveRecord::Base.connection.execute, ale nie wiem, jak przekazać wartości parametrów dynamicznych do metody.

Czy ktoś mógłby mi w tym pomóc?

Wygląda na to, że API Railsów nie ujawnia metod służących do tego w sposób ogólny. Możesz spróbować uzyskać dostęp do podstawowego połączenia i użyć jego metod, np. Dla MySQL:

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

Nie jestem pewien, czy istnieją inne konsekwencje takiego działania (pozostawione otwarte połączenia itp.). Prześledziłbym kod Railsów dla normalnej aktualizacji, aby zobaczyć, co robi poza faktycznym zapytaniem.

Korzystanie z przygotowanych zapytań może zaoszczędzić ci trochę czasu w bazie danych, ale jeśli nie robisz tego milion razy z rzędu, prawdopodobnie lepiej byłoby po prostu zbudować aktualizację z normalnym podstawieniem Rubiego, np.

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

lub używając ActiveRecord, jak powiedzieli komentatorzy.

ActiveRecord::Base.connectionma quotemetodę, która przyjmuje wartość ciągu (i opcjonalnie obiekt kolumny). Możesz więc powiedzieć tak:

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

Zauważ, że jeśli jesteś w migracji Railsów lub w obiekcie ActiveRecord, możesz skrócić to do:

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

AKTUALIZACJA: Jak wskazuje @kolen, powinieneś użyć exec_updatezamiast tego. Spowoduje to wycenę za Ciebie, a także pozwoli uniknąć wycieku pamięci. Podpis działa jednak nieco inaczej:

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

Tutaj ostatni parametr to tablica krotek reprezentujących parametry wiązania. W każdej krotce pierwszy wpis to typ kolumny, a drugi to wartość. Możesz podać niltyp kolumny, a jednak Railsy zwykle postępują właściwie.

Istnieją również exec_query, exec_inserti exec_delete, w zależności od tego, czego potrzebujesz.

Powinieneś po prostu użyć czegoś takiego:

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

To wystarczy. Użycie metody ActiveRecord :: Base # send do wywołania sanitize_sql_for_assignment sprawia, że ​​Ruby (przynajmniej wersja 1.8.7) pomija fakt, że sanitize_sql_for_assignment jest w rzeczywistości metodą chronioną.

Czasami lepiej byłoby użyć nazwy klasy nadrzędnej zamiast nazwy tabeli:

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

Na przykład klasa bazowa „Osoba”, podklasy (i tabele bazy danych) „Klient” i „Sprzedawca” Zamiast tego użyj:

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

Możesz użyć obiektu klasy bazowej w następujący sposób:

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

Po co w tym celu używać surowego SQL?

Jeśli masz model do tego użyj 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

Jeśli nie masz dla niego modelu (tylko tabela), możesz utworzyć plik i model, które będą dziedziczyć poActiveRecord::Base

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

i ponownie użyj wheretego samego co powyżej:

Oto sztuczka, którą niedawno opracowałem, dotyczącą wykonywania surowego sql z powiązaniami:

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

gdzie ApplicationRecordto określa:

# 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

i to jest podobne do tego, jak AR wiąże swoje własne zapytania.

Musiałem użyć surowego sql, ponieważ nie udało mi się uzyskać composite_primary_keys do działania z activerecord 2.3.8. Tak więc, aby uzyskać dostęp do tabeli sqlserver 2000 ze złożonym kluczem podstawowym, wymagany był surowy sql.

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

Jeśli dostępne jest lepsze rozwiązanie, udostępnij.

W Railsach 3.1 powinieneś używać interfejsu zapytań:

• nowy (atrybuty)
• utwórz (atrybuty)
• utwórz! (atrybuty)
• znajdź (id_or_array)
• zniszcz (id_or_array)
• zniszcz_wszystkie
• usuń (id_or_array)
• Usuń wszystko
• aktualizacja (identyfikatory, aktualizacje)
• update_all (aktualizacje)
• istnieje?

update i update_all to operacja, której potrzebujesz.

Zobacz szczegóły tutaj: http://m.onkey.org/active-record-query-interface