ฉันจะหลีกเลี่ยงการเรียกใช้การเรียกกลับ ActiveRecord ได้อย่างไร

ฉันมีบางรุ่นที่มีการโทรกลับหลังบันทึก ปกติแล้วจะใช้ได้ แต่ในบางสถานการณ์เช่นเมื่อสร้างข้อมูลการพัฒนาฉันต้องการบันทึกโมเดลโดยไม่ต้องเรียกใช้การเรียกกลับ มีวิธีง่าย ๆ ในการทำเช่นนั้น? คล้ายกับ ...

Person#save( :run_callbacks => false )

หรือ

Person#save_without_callbacks

ฉันดูเอกสาร Rails แล้วไม่พบอะไรเลย อย่างไรก็ตามจากประสบการณ์ของฉันเอกสาร Rails ไม่ได้บอกเรื่องราวทั้งหมดเสมอไป

UPDATE

ฉันพบโพสต์บล็อกที่อธิบายถึงวิธีที่คุณสามารถลบการโทรกลับออกจากโมเดลดังนี้:

Foo.after_save.clear

ฉันไม่พบตำแหน่งที่บันทึกไว้ แต่ดูเหมือนว่าจะใช้งานได้

วิธีนี้เป็น Rails 2 เท่านั้น

ฉันเพิ่งตรวจสอบเรื่องนี้และฉันคิดว่าฉันมีทางออก มีสองวิธีส่วนตัวของ ActiveRecord ที่คุณสามารถใช้ได้:

update_without_callbacks
create_without_callbacks

คุณจะต้องใช้การส่งเพื่อโทรวิธีการเหล่านี้ ตัวอย่าง:

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

Updated:

วิธีแก้ปัญหาของ @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 

Approach1:

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 หรือลบล้างด้วยรหัสออกของคุณในทางใดทางหนึ่งพิจารณาด้วยการใช้ "เงา วัตถุ "ชี้ไปที่ตารางฐานข้อมูลที่มีอยู่ของคุณ ชอบมาก

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

สิ่งนี้ใช้ได้กับ Rails ทุกรุ่นเป็น threadsafe และกำจัดการตรวจสอบและเรียกกลับทั้งหมดโดยไม่มีการแก้ไขโค้ดที่มีอยู่ของคุณ คุณสามารถโยนการประกาศคลาสนั้นทันทีก่อนการนำเข้าจริงของคุณและคุณควรจะไป เพียงจำไว้ว่าให้ใช้คลาสใหม่ของคุณเพื่อแทรกวัตถุเช่น:

ImportedPerson.new( person_attributes )

คุณสามารถลองสิ่งนี้ในรูปแบบบุคคลของคุณ:

after_save :something_cool, :unless => :skip_callbacks

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

แก้ไข: after_save ไม่ได้เป็นสัญลักษณ์ แต่อย่างน้อย 1,000 ครั้งที่ฉันพยายามทำให้มันเป็นหนึ่ง

คุณสามารถใช้update_columns:

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

อัพเดตแอ็ตทริบิวต์ที่กำหนดของวัตถุโดยไม่ต้องเรียก save ดังนั้นการข้ามการตรวจสอบและการเรียกกลับ

วิธีเดียวที่จะป้องกันการเรียกกลับ 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 (ตั้งแต่ update_without_callbacks จะหายไป ฯลฯ ) จะใช้ update_all ซึ่งเป็นหนึ่งในวิธีการที่เรียกกลับข้ามตามมาตรา 12 ของรางเพื่อการตรวจสอบและเรียกกลับ

นอกจากนี้โปรดทราบว่าหากคุณกำลังทำอะไรบางอย่างใน after_ callback ของคุณนั่นเป็นการคำนวณตามการเชื่อมโยงมากมาย (เช่น has_many assoc ที่คุณยอมรับ accepts_nested_attributes_for) คุณจะต้องโหลดการเชื่อมโยงใหม่ในกรณีที่เป็นส่วนหนึ่งของการบันทึก สมาชิกหนึ่งรายถูกลบ

https://gist.github.com/576546

เพียงแค่ทำการติดตั้ง Monkey-patch นี้ลงใน config / initializers / skip_callbacks.rb

แล้วก็

Project.skip_callbacks { @project.save }

หรือชอบ

เครดิตทั้งหมดให้กับผู้เขียน

up-votedคำตอบส่วนใหญ่อาจดูสับสนในบางกรณี

คุณสามารถใช้การifตรวจสอบง่าย ๆหากคุณต้องการข้ามการติดต่อกลับเช่นนี้:

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

ทางออกที่ควรใช้กับ Rails ทุกรุ่นโดยไม่ต้องใช้ gem หรือ plugin นั้นเป็นเพียงการออกคำสั่ง update โดยตรง เช่น

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

นี่อาจเป็น (หรืออาจไม่) เป็นตัวเลือกขึ้นอยู่กับความซับซ้อนของการอัพเดทของคุณ นี้ทำงานได้ดีสำหรับการปรับปรุงเช่นธงในบันทึกจากภายในเรียกกลับ after_save (ไม่ retriggering โทรกลับ)

# 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

คุณสามารถใช้ส่อเสียด-Save อัญมณี: https://rubygems.org/gems/sneaky-save

หมายเหตุสิ่งนี้ไม่สามารถช่วยในการบันทึกการเชื่อมโยงไปโดยไม่มีการตรวจสอบความถูกต้อง มันพ่นข้อผิดพลาด 'created_at ไม่สามารถเป็นโมฆะ' เพราะมันแทรกแบบสอบถาม SQL โดยตรงไม่เหมือนรูปแบบ ในการดำเนินการนี้เราจำเป็นต้องอัปเดตคอลัมน์ทั้งหมดที่สร้างโดยอัตโนมัติของ db

ฉันต้องการวิธีแก้ปัญหาสำหรับ Rails 4 ดังนั้นฉันจึงพบสิ่งนี้:

app / รุ่น / กังวล / 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 ของคุณด้วยข้อมูลแนวทางที่ดีกว่าคือการสร้างงาน rake ที่ใช้ faker gem เพื่อสร้างข้อมูลที่ถูกต้องและนำเข้าสู่ 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

(วิธีการเดียวกันอาจทำให้การตรวจสอบข้ามง่ายขึ้น)

สเตฟาน

อีกวิธีหนึ่งคือใช้ hooks การตรวจสอบแทนการเรียกกลับ ตัวอย่างเช่น:

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โดยไม่ต้องขึ้นอยู่กับตัวเลือกหรือวิธีการส่งสัญญาณที่มีหรือไม่มีอยู่

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: ใช้ "โมเดล activerecord ที่แตกต่างกัน" บนตารางเดียวกัน

สำหรับการโทรกลับที่กำหนดเองให้ใช้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_callbackstrue

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'
  ...