Jak mogę uniknąć wywołań zwrotnych ActiveRecord?

Mam kilka modeli, które mają wywołania zwrotne after_save. Zwykle jest to w porządku, ale w niektórych sytuacjach, na przykład podczas tworzenia danych programistycznych, chcę zapisać modele bez uruchamiania wywołań zwrotnych. Czy jest na to prosty sposób? Coś w rodzaju ...

Person#save( :run_callbacks => false )

lub

Person#save_without_callbacks

Zajrzałem do dokumentacji Rails i nic nie znalazłem. Jednak z mojego doświadczenia wynika, że ​​dokumentacja Rails nie zawsze opisuje całą historię.

AKTUALIZACJA

Znalazłem post na blogu, w którym wyjaśniono, jak usunąć wywołania zwrotne z takiego modelu:

Foo.after_save.clear

Nie mogłem znaleźć, gdzie ta metoda jest udokumentowana, ale wydaje się, że działa.

To rozwiązanie dotyczy tylko Rails 2.

Właśnie to zbadałem i myślę, że mam rozwiązanie. Istnieją dwie prywatne metody ActiveRecord, których możesz użyć:

update_without_callbacks
create_without_callbacks

Będziesz musiał użyć funkcji send, aby wywołać te metody. przykłady:

p = Person.new(:name => 'foo')
p.send(:create_without_callbacks)

p = Person.find(1)
p.send(:update_without_callbacks)

Jest to zdecydowanie coś, czego naprawdę będziesz chciał używać tylko w konsoli lub podczas wykonywania losowych testów. Mam nadzieję że to pomoże!

Użyj update_column(Rails> = v3.1) lub update_columns(Rails> = 4.0), aby pominąć wywołania zwrotne i walidację. Również w przypadku tych metod nieupdated_at jest aktualizowany.

#Rails >= v3.1 only
@person.update_column(:some_attribute, 'value')
#Rails >= v4.0 only
@person.update_columns(attributes)

http://api.rubyonrails.org/classes/ActiveRecord/Persistence.html#method-i-update_column

# 2: Pomijanie wywołań zwrotnych, które działają również podczas tworzenia obiektu

class Person < ActiveRecord::Base
  attr_accessor :skip_some_callbacks

  before_validation :do_something
  after_validation :do_something_else

  skip_callback :validation, :before, :do_something, if: :skip_some_callbacks
  skip_callback :validation, :after, :do_something_else, if: :skip_some_callbacks
end

person = Person.new(person_params)
person.skip_some_callbacks = true
person.save

Zaktualizowano:

Rozwiązanie @Vikrant Chaudhary wydaje się lepsze:

#Rails >= v3.1 only
@person.update_column(:some_attribute, 'value')
#Rails >= v4.0 only
@person.update_columns(attributes)

Moja pierwotna odpowiedź:

zobacz ten link: Jak pominąć wywołania zwrotne ActiveRecord?

w Rails3,

załóżmy, że mamy definicję klasy:

class User < ActiveRecord::Base
  after_save :generate_nick_name
end 

Podejście 1:

User.send(:create_without_callbacks)
User.send(:update_without_callbacks)

Podejście 2: Jeśli chcesz pominąć je w swoich plikach rspec lub czymkolwiek, spróbuj tego:

User.skip_callback(:save, :after, :generate_nick_name)
User.create!()

UWAGA: po wykonaniu tej czynności, jeśli nie jesteś w środowisku rspec, powinieneś zresetować wywołania zwrotne:

User.set_callback(:save, :after, :generate_nick_name)

u mnie działa dobrze na szynach 3.0.5

szyny 3:

MyModel.send("_#{symbol}_callbacks") # list  
MyModel.reset_callbacks symbol # reset

Jeśli celem jest po prostu wstawienie rekordu bez wywołań zwrotnych lub walidacji, a chciałbyś to zrobić bez uciekania się do dodatkowych klejnotów, dodawania sprawdzeń warunkowych, używania RAW SQL lub w jakikolwiek inny sposób z zamykającym kodem, rozważ użycie „shadow obiekt ”wskazujący na istniejącą tabelę db. Tak jak to:

class ImportedPerson < ActiveRecord::Base
  self.table_name = 'people'
end

Działa to z każdą wersją Railsów, jest bezpieczne dla wątków i całkowicie eliminuje wszelkie walidacje i wywołania zwrotne bez modyfikacji istniejącego kodu. Możesz po prostu wrzucić tę deklarację klasy tuż przed rzeczywistym importem i powinieneś być gotowy. Pamiętaj tylko, aby użyć nowej klasy do wstawienia obiektu, na przykład:

ImportedPerson.new( person_attributes )

Możesz spróbować czegoś takiego w swoim modelu Person:

after_save :something_cool, :unless => :skip_callbacks

def skip_callbacks
  ENV[RAILS_ENV] == 'development' # or something more complicated
end

EDYCJA: after_save nie jest symbolem, ale przynajmniej po raz tysięczny próbowałem to zrobić.

Możesz użyć update_columns:

User.first.update_columns({:name => "sebastian", :age => 25})

Aktualizuje podane atrybuty obiektu, bez wywoływania funkcji save, co powoduje pominięcie walidacji i wywołań zwrotnych.

Jedynym sposobem uniknięcia wszystkich wywołań zwrotnych after_save jest ustawienie pierwszego zwracającego false.

Być może mógłbyś spróbować czegoś takiego (niesprawdzone):

class MyModel < ActiveRecord::Base
  attr_accessor :skip_after_save

  def after_save
    return false if @skip_after_save
    ... blah blah ...
  end
end

...

m = MyModel.new # ... etc etc
m.skip_after_save = true
m.save

Wygląda na to, że jednym ze sposobów radzenia sobie z tym problemem w Railsach 2.3 (ponieważ aktualizacja_without_callbacks już nie istnieje, itd.), Byłoby użycie update_all, jednej z metod pomijających wywołania zwrotne zgodnie z sekcją 12 Przewodnika po walidacji i wywołania zwrotne Rails .

Zwróć również uwagę, że jeśli robisz coś w swoim wywołaniu zwrotnym after_, który wykonuje obliczenia oparte na wielu skojarzeniach (np. Asoc_as_many, gdzie również akceptujesz_nested_attributes_for), będziesz musiał ponownie załadować skojarzenie, na wypadek gdyby było częścią zapisywania , jeden z jego członków został usunięty.

https://gist.github.com/576546

po prostu zrzuć tę małpą łatkę do config / initializers / skip_callbacks.rb

następnie

Project.skip_callbacks { @project.save }

lub tym podobne.

wszystkie zasługi dla autora

W up-votedniektórych przypadkach większość odpowiedzi może wydawać się zagmatwana.

Możesz użyć prostego ifsprawdzenia, czy chcesz pominąć oddzwonienie, na przykład:

after_save :set_title, if: -> { !new_record? && self.name_changed? }

Rozwiązaniem, które powinno działać we wszystkich wersjach Railsów bez użycia klejnotu lub wtyczki, jest po prostu bezpośrednie wydawanie instrukcji update. na przykład

ActiveRecord::Base.connection.execute "update table set foo = bar where id = #{self.id}"

Może to być opcja (lub nie) w zależności od stopnia złożoności aktualizacji. Działa to dobrze na przykład flagi aktualizowanie na rekord od wewnątrz na after_save zwrotnego (bez ponownego wyzwolenia wywołania zwrotnego).

# for rails 3
  if !ActiveRecord::Base.private_method_defined? :update_without_callbacks
    def update_without_callbacks
      attributes_with_values = arel_attributes_values(false, false, attribute_names)
      return false if attributes_with_values.empty?
      self.class.unscoped.where(self.class.arel_table[self.class.primary_key].eq(id)).arel.update(attributes_with_values)
    end
  end

Żaden z tych punktów nie wskazuje na without_callbackswtyczkę, która po prostu robi to, czego potrzebujesz ...

class MyModel < ActiveRecord::Base
  before_save :do_something_before_save

  def after_save
    raise RuntimeError, "after_save called"
  end

  def do_something_before_save
    raise RuntimeError, "do_something_before_save called"
  end
end

o = MyModel.new
MyModel.without_callbacks(:before_save, :after_save) do
  o.save # no exceptions raised
end

http://github.com/cjbottaro/without_callbacks działa z Railsami 2.x

Napisałem wtyczkę, która implementuje update_without_callbacks w Railsach 3:

http://github.com/dball/skip_activerecord_callbacks

Myślę, że właściwym rozwiązaniem jest przepisanie modeli, aby przede wszystkim uniknąć wywołań zwrotnych, ale jeśli jest to niepraktyczne w najbliższym czasie, ta wtyczka może pomóc.

Jeśli używasz Railsów 2. Możesz użyć zapytania SQL do aktualizacji swojej kolumny bez wywołań zwrotnych i walidacji.

YourModel.connection.execute("UPDATE your_models SET your_models.column_name=#{value} WHERE your_models.id=#{ym.id}")

Myślę, że powinno działać w każdej wersji szynowej.

Gdy potrzebuję pełnej kontroli nad wywołaniem zwrotnym, tworzę inny atrybut, który jest używany jako przełącznik. Prosty i skuteczny:

Model:

class MyModel < ActiveRecord::Base
  before_save :do_stuff, unless: :skip_do_stuff_callback
  attr_accessor :skip_do_stuff_callback

  def do_stuff
    puts 'do stuff callback'
  end
end

Test:

m = MyModel.new()

# Fire callbacks
m.save

# Without firing callbacks
m.skip_do_stuff_callback = true
m.save

# Fire callbacks again
m.skip_do_stuff_callback = false
m.save

Do tworzenia danych testowych w Railsach używasz tego hacka:

record = Something.new(attrs)
ActiveRecord::Persistence.instance_method(:create_record).bind(record).call

https://coderwall.com/p/y3yp2q/edit

Możesz użyć klejnotu podstępnego zapisu: https://rubygems.org/gems/sneaky-save .

Pamiętaj, że nie może to pomóc w zapisywaniu skojarzeń bez walidacji. Zgłasza błąd „created_at nie może być null”, ponieważ bezpośrednio wstawia zapytanie sql w przeciwieństwie do modelu. Aby to zaimplementować, musimy zaktualizować wszystkie automatycznie generowane kolumny bazy danych.

Potrzebowałem rozwiązania dla Rails 4, więc wymyśliłem to:

app / models / problems / save_without_callbacks.rb

module SaveWithoutCallbacks

  def self.included(base)
    base.const_set(:WithoutCallbacks,
      Class.new(ActiveRecord::Base) do
        self.table_name = base.table_name
      end
      )
  end

  def save_without_callbacks
    new_record? ? create_without_callbacks : update_without_callbacks
  end

  def create_without_callbacks
    plain_model = self.class.const_get(:WithoutCallbacks)
    plain_record = plain_model.create(self.attributes)
    self.id = plain_record.id
    self.created_at = Time.zone.now
    self.updated_at = Time.zone.now
    @new_record = false
    true
  end

  def update_without_callbacks
    update_attributes = attributes.except(self.class.primary_key)
    update_attributes['created_at'] = Time.zone.now
    update_attributes['updated_at'] = Time.zone.now
    update_columns update_attributes
  end

end

w dowolnym modelu:

include SaveWithoutCallbacks

wtedy możesz:

record.save_without_callbacks

lub

Model::WithoutCallbacks.create(attributes)

Dlaczego miałbyś chcieć móc to robić podczas programowania? Z pewnością będzie to oznaczać, że tworzysz aplikację z nieprawidłowymi danymi i jako taka będzie zachowywała się dziwnie, a nie tak, jak oczekujesz w produkcji.

Jeśli chcesz zapełnić swoją bazę deweloperską danymi, lepszym podejściem byłoby zbudowanie zadania prowizji, które wykorzystywało fałszywy klejnot do zbudowania prawidłowych danych i zaimportowanie ich do bazy danych, tworząc tyle rekordów, ile chcesz, ale jeśli jesteś na pięcie pochyliłem się nad tym i mam dobry powód Myślę, że update_without_callbacks i create_without_callbacks będą działać dobrze, ale kiedy próbujesz zgiąć szyny zgodnie ze swoją wolą, zapytaj siebie, masz dobry powód i czy to, co robisz, jest naprawdę dobrym pomysłem.

Jedną z opcji jest posiadanie oddzielnego modelu takich manipulacji przy użyciu tej samej tabeli:

class NoCallbacksModel < ActiveRecord::Base
  set_table_name 'table_name_of_model_that_has_callbacks'

  include CommonModelMethods # if there are
  :
  :

end

(To samo podejście może ułatwić omijanie walidacji)

Stephan

Innym sposobem byłoby użycie haków walidacji zamiast wywołań zwrotnych. Na przykład:

class Person < ActiveRecord::Base
  validate_on_create :do_something
  def do_something
    "something clever goes here"
  end
end

W ten sposób możesz domyślnie uzyskać do_something, ale możesz łatwo nadpisać to:

@person = Person.new
@person.save(false)

Coś, co powinno działać ze wszystkimi wersjami ActiveRecordbez w zależności od opcji lub metod activerecord, które mogą istnieć lub nie.

module PlainModel
  def self.included(base)
    plainclass = Class.new(ActiveRecord::Base) do
      self.table_name = base.table_name
    end
    base.const_set(:Plain, plainclass)
  end
end


# usage
class User < ActiveRecord::Base
  include PlainModel

  validates_presence_of :email
end

User.create(email: "")        # fail due to validation
User::Plain.create(email: "") # success. no validation, no callbacks

user = User::Plain.find(1)
user.email = ""
user.save

TLDR: użyj „innego modelu aktywnego rekordu” w tej samej tabeli

W przypadku niestandardowych wywołań zwrotnych użyj attr_accessori unlessw wywołaniu zwrotnym.

Zdefiniuj swój model w następujący sposób:

class Person << ActiveRecord::Base

  attr_accessor :skip_after_save_callbacks

  after_save :do_something, unless: :skip_after_save_callbacks

end

A następnie, jeśli chcesz zapisać rekord bez uderzania w after_savezdefiniowane wywołania zwrotne, ustaw skip_after_save_callbacksatrybut wirtualny na true.

person.skip_after_save_callbacks #=> nil
person.save # By default, this *will* call `do_something` after saving.

person.skip_after_save_callbacks = true
person.save # This *will not* call `do_something` after saving.

person.skip_after_save_callbacks = nil # Always good to return this value back to its default so you don't accidentally skip callbacks.

Nie jest to najczystszy sposób, ale możesz opakować kod wywołania zwrotnego w warunku, który sprawdza środowisko Railsów.

if Rails.env == 'production'
  ...