Як я можу уникнути запуску зворотних викликів ActiveRecord?

У мене є кілька моделей, у яких є зворотні виклики after_save. Зазвичай це нормально, але в деяких ситуаціях, як, наприклад, при створенні даних про розробку, я хочу зберегти моделі, не запускаючи зворотні дзвінки. Чи є простий спосіб це зробити? Щось схоже на ...

Person#save( :run_callbacks => false )

або

Person#save_without_callbacks

Я заглянув у документи Rails і нічого не знайшов. Однак, на мій досвід, документи Rails не завжди розповідають всю історію.

ОНОВЛЕННЯ

Я знайшов повідомлення в блозі, в якому пояснюється, як можна видалити зворотні дзвінки з такої моделі:

Foo.after_save.clear

Я не міг знайти, де цей метод документально підтверджений, але він, здається, працює.

Це рішення лише для Rails 2.

Я щойно це досліджував і думаю, що у мене є рішення. Є два приватні методи ActiveRecord, якими ви можете скористатися:

update_without_callbacks
create_without_callbacks

Вам потрібно буде використовувати send для виклику цих методів. приклади:

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

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

Це, безумовно, те, що ви дійсно хочете використовувати в консолі або роблячи деякі випадкові тести. Сподіваюся, це допомагає!

Використовуйте update_column(Rails> = v3.1) або update_columns(Rails> = 4.0), щоб пропустити зворотні дзвінки та перевірки. Крім того, з допомогою цих методів, updated_atє НЕ оновлюється.

#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: Пропуск зворотних викликів, який також працює під час створення об'єкта

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

Оновлено:

Рішення @Vikrant Chaudhary здається кращим:

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

Моя оригінальна відповідь:

дивіться це посилання: Як пропустити зворотні дзвінки ActiveRecord?

в Rails3,

припустимо, у нас є визначення класу:

class User < ActiveRecord::Base
  after_save :generate_nick_name
end 

Підхід1:

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

Підхід 2: Коли ви хочете пропустити їх у ваші файли rspec чи будь-що інше, спробуйте це:

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

ПРИМІТКА. Після цього, якщо ви не знаходитесь у середовищі rspec, слід скинути зворотні виклики:

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

добре працює для мене на рейках 3.0.5

рейки 3:

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

Якщо мета - просто вставити запис без зворотних викликів чи перевірок, і ви хотіли б це зробити, не вдаючись до додаткових дорогоцінних каменів, додаючи умовні чеки, використовуючи RAW SQL або будь-яким чином збиваючись зі своїм вихідним кодом, подумайте про використання "тіні об'єкт ", що вказує на вашу існуючу таблицю db. Так:

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

Це працює з будь-якою версією Rails, є безпечною для потоків і повністю виключає всі перевірки та зворотні виклики, не змінюючи існуючий код. Ви можете просто кинути цю декларацію класу прямо перед вашим фактичним імпортом, і вам слід погодитися. Просто пам’ятайте, щоб використовувати новий клас для вставки об’єкта, наприклад:

ImportedPerson.new( person_attributes )

Ви можете спробувати щось подібне у вашій моделі Person:

after_save :something_cool, :unless => :skip_callbacks

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

EDIT: after_save - це не символ, але це, принаймні, 1000-й раз, коли я намагався зробити його одним.

Ви можете використовувати update_columns:

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

Оновляє задані атрибути об'єкта, не викликаючи збереження, отже, пропускаючи перевірки та зворотні виклики.

Єдиний спосіб запобігти всім зворотним викликам after_save - це перше повернення помилково.

Можливо, ви могли б спробувати щось на кшталт (неперевірене):

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

Схоже, одним із способів вирішити це в Rails 2.3 (оскільки оновлення_without_callbacks відсутнє тощо) було б використовувати update_all, який є одним із методів, який пропускає зворотні виклики згідно з розділом 12 Керівництва Rails до перевірок та зворотних викликів .

Також зауважте, що якщо ви робите щось у своєму зворотному виклику after_, це робить обчислення, засноване на багатьох асоціаціях (тобто, assoc has_many, де ви також приймаєте_nested_attributes_for), вам потрібно буде перезавантажити асоціацію, на випадок як частина збереження , один з її членів був видалений.

https://gist.github.com/576546

просто скиньте цей патч мавп у config / Initiators / skip_callbacks.rb

тоді

Project.skip_callbacks { @project.save }

тощо.

вся заслуга автора

Найбільший up-voted відповідь може здатися заплутаною в деяких випадках.

ifЯкщо ви хочете пропустити зворотний дзвінок, ви можете просто перевірити, як це:

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

Рішення, яке повинно працювати у всіх версіях Rails без використання дорогоцінного каміння або плагіна, - це просто безпосередньо видавати заяви про оновлення. напр

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

Це може (а може і не бути) варіантом залежно від того, наскільки складним є ваше оновлення. Це добре працює , наприклад , для прапорів коригування на запис з в якості after_save зворотного виклику (без зворотного виклику перезапуску).

# 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

Жоден із цих пунктів для without_callbacksплагіна, який просто робить те, що вам потрібно ...

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 працює з Rails 2.x

Я написав плагін, який реалізує update_without_callbacks в Rails 3:

http://github.com/dball/skip_activerecord_callbacks

Правильне рішення, я думаю, полягає в тому, щоб переписати свої моделі, щоб у першу чергу уникнути зворотних дзвінків, але якщо це недоцільно найближчим часом, цей плагін може допомогти.

Якщо ви використовуєте Rails 2. Ви можете використовувати SQL-запит для оновлення стовпця без запуску зворотних викликів та перевірок.

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

Я думаю, що це має працювати в будь-яких версіях рейок.

Коли мені потрібен повний контроль над зворотним викликом, я створюю ще один атрибут, який використовується як комутатор. Простий та ефективний:

Модель:

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

Тест:

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

Для створення тестових даних у Rails ви використовуєте цей злом:

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

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

Ви можете використовувати саморобний дорогоцінний камінь: https://rubygems.org/gems/sneaky-save .

Зверніть увагу, це не може допомогти зберегти асоціації без перевірки. Він видає помилку 'created_at не може бути нульовою', оскільки він безпосередньо вставляє запит sql на відміну від моделі. Для цього нам потрібно оновити всі автоматично створені стовпці db.

Мені було потрібно рішення для Rails 4, тому я придумав таке:

додаток / моделі / проблеми / 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

у будь-якій моделі:

include SaveWithoutCallbacks

тоді ви можете:

record.save_without_callbacks

або

Model::WithoutCallbacks.create(attributes)

Чому б ви хотіли зробити це в розвитку? Звичайно, це означає, що ви будуєте свою програму з невірними даними, і як така вона буде вести себе дивно, а не так, як ви очікуєте на виробництві.

Якщо ви хочете заповнити свій dev db даними, кращим підходом було б побудувати завдання граблі, яке використовувало дорогоцінний камінь, щоб створити дійсні дані та імпортувати їх у db, створивши стільки чи мало записів, скільки ви хочете, але якщо ви є п'ятою нахилившись на цьому, і є вагома причина, я думаю, що update_without_callbacks та create_without_callbacks спрацюють нормально, але коли ви намагаєтесь зігнути рейки за своєю волею, запитайте себе, чи є у вас вагомі причини, і якщо те, що ви робите, справді хороша ідея.

Один варіант - мати окрему модель для таких маніпуляцій, використовуючи ту саму таблицю:

class NoCallbacksModel < ActiveRecord::Base
  set_table_name 'table_name_of_model_that_has_callbacks'

  include CommonModelMethods # if there are
  :
  :

end

(Один і той же підхід може полегшити ситуацію для обходу перевірок)

Стефан

Іншим способом було б використання гачків перевірки замість зворотних викликів. Наприклад:

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

Таким чином, ви можете отримати значення do_something за замовчуванням, але ви можете легко змінити це за допомогою:

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

Щось, що повинно працювати з усіма версіями ActiveRecordбез залежно від параметрів або методів activerecord, які можуть існувати або не існувати.

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: використовуйте "іншу модель активних записів" над тією ж таблицею

Для користувацьких зворотних дзвінків використовуйте attr_accessorіunless в зворотному виклику.

Визначте свою модель наступним чином:

class Person << ActiveRecord::Base

  attr_accessor :skip_after_save_callbacks

  after_save :do_something, unless: :skip_after_save_callbacks

end

І тоді, якщо вам потрібно зберегти запис, не потрапляючи на after_saveвизначені вами зворотні дзвінки, встановіть skip_after_save_callbacksвіртуальний атрибут 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.

Не найчистіший спосіб, але ви можете загорнути код зворотного виклику в умові, що перевіряє середовище Rails.

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